func init() {
// BASE_URL, AUTH_USER and AUTH_PASS, AWS_S3_BASE_URL are not required or else wercker tests would fail
baseURL = os.Getenv("BASE_URL")
authUser = os.Getenv("AUTH_USER")
authPass = os.Getenv("AUTH_PASS")
s3BaseURL = os.Getenv("AWS_S3_BASE_URL")
if awsAuth, err := aws.EnvAuth(); err != nil {
// not required or else wercker tests would fail
log.Println(err)
} else {
// TODO(jrubin) allow region to be chosen by env variable
s3Data := s3.New(awsAuth, aws.USWest2)
s3Bucket = s3Data.Bucket(os.Getenv("AWS_S3_BUCKET_NAME"))
}
m = martini.Classic()
m.Use(gzip.All())
m.Use(render.Renderer())
m.Get("/", func() string {
return "hello, world"
})
m.Post(
"/v1/transcribe",
auth.Basic(authUser, authPass),
strict.Accept("application/json"),
strict.ContentType("application/x-www-form-urlencoded"),
binding.Bind(transcribeData{}),
binding.ErrorHandler,
handleTranscribe,
)
m.Post(
"/v1/transcribe/process",
strict.ContentType("application/x-www-form-urlencoded"),
binding.Bind(telapi.TranscribeCallbackData{}),
binding.ErrorHandler,
handleTranscribeProcess,
)
m.Post(
"/v1/transcribe/upload",
auth.Basic(authUser, authPass),
strict.Accept("application/json"),
binding.MultipartForm(transcribeUploadData{}),
binding.ErrorHandler,
handleTranscribeUpload,
)
m.Router.NotFound(strict.MethodNotAllowed, strict.NotFound)
}
func main() {
list := karambie.List()
route := mux.NewRouter() // use gorilla as router
martini := martinihelper.New() // and also martini as middleware, see below
currentDir, _ := os.Getwd()
log := log.New(os.Stdout, "[Karambie] ", 0)
logger := logger.New(log, false) // log every request
recovery := recovery.New(log, nil) // recover if panic
notfoundhandler := notfoundhandler.New(true, nil) // show 404, add trailing slash to url if necessary
static := static.New(filepath.Join(currentDir, "public"), log) // serve static file in folder "public"
// register logger service for martini
martini.Map(log)
// the list is immutable, every calling to Add or AddFunc will create new list
list = list.Add(logger, recovery)
list = list.Add(karambie.Later(notfoundhandler))
list = list.Add(karambie.Later(static))
// or you can use karambie/middleware.Common() to build those list
// list is [logger, recovery, notfoundhandler, static]
// but the order of execution is [logger, recovery, static, notfoundhandler]
// karambie.Later will create new handler that will be executed after succeeding handler
// list processing will stop if one of them respond the request (http response status != 0)
secureList := list.Add(martini.Conv(auth.Basic("user", "pass"))) // execution of secureList is [logger, recovery, auth, static, notfoundhandler]
list = list.Add(martini.Conv(render.Renderer())) // execution of list is [logger, recovery, render, static, notfoundhandler]
// list != secureList, because it is immutable, every calling to Add or AddFunc will create new list
// using http.HandlerFunc style
route.Handle("/helloworld", list.AddFunc(hello)) // [logger, recovery, render, hello]
// 'static' and 'notfoundhandler' will be ignored because 'hello' response the request
// we can user list as NotFoundHandler (handle static file, and show error 404 if necessary)
route.NotFoundHandler = list // [logger, recovery, static, notfoundhandler]
// 'notfoundhandler' will be ignored if 'static' response the request
// using martini.Handler style and gorilla routing
route.Handle("/sayhi/{name}", list.Add(martini.Conv(sayhi))) // [logger, recovery, render, sayhi]
// use secureList for sensitive resource
route.Handle("/secret", secureList.AddFunc(secret)) // [logger, recovery, auth, secret]
// add filterheader to list
apiList := list.AddFunc(filterheader) // execution of apiList is [logger, recovery, filterheader, static, notfoundhandler]
route.Handle("/api", apiList.AddFunc(http.HandlerFunc(func(rw http.ResponseWriter, r *http.Request) {
// this handler will not be called if 'filterheader' is not passed
// get apikey
ctx := karambie.Context(rw)
key := ctx.Get("apikey").(string)
fmt.Fprintln(rw, "Your api key : "+key)
})))
http.ListenAndServe(":3000", route)
}
func init() {
m = martini.New()
//set up middleware
m.Use(martini.Recovery())
m.Use(martini.Logger())
m.Use(auth.Basic(AuthToken, ""))
m.Use(MapEncoder)
// set up routes
r := martini.NewRouter()
r.Get(`/albums`, GetAlbums)
r.Get(`/albums/:id`, GetAlbum)
r.Post(`/albums`, AddAlbum)
r.Put(`/albums/:id`, UpdateAlbum)
r.Delete(`/albums/:id`, DeleteAlbum)
// inject database
// maps db package variable to the DB interface defined in data.go
// The syntax for the second parameter may seem weird,
// it is just converting nil to the pointer-to-DB-interface type,
// because all the injector needs is the type to map the first parameter to.
m.MapTo(db, (*DB)(nil))
// add route action
// adds the router’s configuration to the list of handlers that Martini will call.
m.Action(r.Handle)
}
// standardHttp starts serving standard HTTP (api/web) requests, to be used by normal clients
func standardHttp(discovery bool) {
m := martini.Classic()
if config.Config.HTTPAuthUser != "" {
m.Use(auth.Basic(config.Config.HTTPAuthUser, config.Config.HTTPAuthPassword))
}
// Render html templates from templates directory
m.Use(render.Renderer(render.Options{
Directory: "resources",
Layout: "templates/layout",
HTMLContentType: "text/html",
}))
m.Use(martini.Static("resources/public"))
log.Info("Starting HTTP")
if discovery {
go orchestrator.ContinuousDiscovery()
}
http.API.RegisterRequests(m)
http.Web.RegisterRequests(m)
// Serve
m.Run()
}
// standardHttp starts serving standard HTTP (api/web) requests, to be used by normal clients
func standardHttp(discovery bool) {
m := martini.Classic()
switch strings.ToLower(config.Config.AuthenticationMethod) {
case "basic":
{
if config.Config.HTTPAuthUser == "" {
// Still allowed; may be disallowed in future versions
log.Warning("AuthenticationMethod is configured as 'basic' but HTTPAuthUser undefined. Running without authentication.")
}
m.Use(auth.Basic(config.Config.HTTPAuthUser, config.Config.HTTPAuthPassword))
}
case "multi":
{
if config.Config.HTTPAuthUser == "" {
// Still allowed; may be disallowed in future versions
log.Fatal("AuthenticationMethod is configured as 'multi' but HTTPAuthUser undefined")
}
m.Use(auth.BasicFunc(func(username, password string) bool {
if username == "readonly" {
// Will be treated as "read-only"
return true
}
return auth.SecureCompare(username, config.Config.HTTPAuthUser) && auth.SecureCompare(password, config.Config.HTTPAuthPassword)
}))
}
default:
{
// We inject a dummy User object because we have function signatures with User argument in api.go
m.Map(auth.User(""))
}
}
m.Use(gzip.All())
// Render html templates from templates directory
m.Use(render.Renderer(render.Options{
Directory: "resources",
Layout: "templates/layout",
HTMLContentType: "text/html",
}))
m.Use(martini.Static("resources/public"))
inst.SetMaintenanceOwner(logic.ThisHostname)
log.Info("Starting HTTP")
if discovery {
go logic.ContinuousDiscovery()
}
inst.ReadClusterAliases()
http.API.RegisterRequests(m)
http.Web.RegisterRequests(m)
// Serve
if err := nethttp.ListenAndServe(config.Config.ListenAddress, m); err != nil {
log.Fatale(err)
}
}
// Http starts serving HTTP (api/web) requests
func Http() {
martini.Env = martini.Prod
m := martini.Classic()
if config.Config.HTTPAuthUser != "" {
m.Use(auth.Basic(config.Config.HTTPAuthUser, config.Config.HTTPAuthPassword))
}
m.Use(gzip.All())
// Render html templates from templates directory
m.Use(render.Renderer(render.Options{
Directory: "resources",
Layout: "templates/layout",
HTMLContentType: "text/html",
}))
m.Use(martini.Static("resources/public"))
go agent.ContinuousOperation()
log.Infof("Starting HTTP on port %d", config.Config.HTTPPort)
http.API.RegisterRequests(m)
// Serve
if config.Config.UseSSL {
log.Info("Serving via SSL")
err := nethttp.ListenAndServeTLS(fmt.Sprintf(":%d", config.Config.HTTPPort), config.Config.SSLCertFile, config.Config.SSLPrivateKeyFile, m)
if err != nil {
log.Fatale(err)
}
} else {
nethttp.ListenAndServe(fmt.Sprintf(":%d", config.Config.HTTPPort), m)
}
}
// Http starts serving HTTP (api/web) requests
func Http() {
martini.Env = martini.Prod
m := martini.Classic()
if config.Config.HTTPAuthUser != "" {
m.Use(auth.Basic(config.Config.HTTPAuthUser, config.Config.HTTPAuthPassword))
}
m.Use(gzip.All())
// Render html templates from templates directory
m.Use(render.Renderer(render.Options{
Directory: "resources",
Layout: "templates/layout",
HTMLContentType: "text/html",
}))
m.Use(martini.Static("resources/public"))
if config.Config.UseMutualTLS {
m.Use(ssl.VerifyOUs(config.Config.SSLValidOUs))
}
go agent.ContinuousOperation()
log.Infof("Starting HTTP on port %d", config.Config.HTTPPort)
http.API.RegisterRequests(m)
listenAddress := fmt.Sprintf(":%d", config.Config.HTTPPort)
// Serve
if config.Config.UseSSL {
if len(config.Config.SSLCertFile) == 0 {
log.Fatale(errors.New("UseSSL is true but SSLCertFile is unspecified"))
}
if len(config.Config.SSLPrivateKeyFile) == 0 {
log.Fatale(errors.New("UseSSL is true but SSLPrivateKeyFile is unspecified"))
}
log.Info("Starting HTTPS listener")
tlsConfig, err := ssl.NewTLSConfig(config.Config.SSLCAFile, config.Config.UseMutualTLS)
if err != nil {
log.Fatale(err)
}
if err = ssl.AppendKeyPair(tlsConfig, config.Config.SSLCertFile, config.Config.SSLPrivateKeyFile); err != nil {
log.Fatale(err)
}
if err = ssl.ListenAndServeTLS(listenAddress, m, tlsConfig); err != nil {
log.Fatale(err)
}
} else {
log.Info("Starting HTTP listener")
if err := nethttp.ListenAndServe(listenAddress, m); err != nil {
log.Fatale(err)
}
}
log.Info("Web server started")
}
func main() {
m := martini.Classic()
baseGUID = os.Getenv("BASE_GUID")
if baseGUID == "" {
baseGUID = "29140B3F-0E69-4C7E-8A35"
}
serviceName = os.Getenv("SERVICE_NAME")
if serviceName == "" {
serviceName = "some-service-name" // replace with cfenv.AppName
}
servicePlan = os.Getenv("SERVICE_PLAN")
if servicePlan == "" {
servicePlan = "shared"
}
authUser = os.Getenv("AUTH_USER")
authPassword = os.Getenv("AUTH_PASSWORD")
if (authUser != "") && (authPassword != "") {
// secure service broker with basic auth if both env variables are set
m.Use(auth.Basic(authUser, authPassword))
}
serviceBinding.SyslogDrainURL = os.Getenv("SYSLOG_DRAIN_URL")
credentials := os.Getenv("CREDENTIALS")
if credentials == "" {
credentials = "{\"port\": \"4000\"}"
}
tags = os.Getenv("TAGS")
imageURL = os.Getenv("IMAGE_URL")
json.Unmarshal([]byte(credentials), &serviceBinding.Credentials)
fmt.Printf("%# v\n", pretty.Formatter(serviceBinding))
appEnv, err := cfenv.Current()
if err == nil {
appURL = fmt.Sprintf("https://%s", appEnv.ApplicationURIs[0])
} else {
appURL = "http://localhost:5000"
}
fmt.Println("Running as", appURL)
// Cloud Foundry Service API
m.Get("/v2/catalog", brokerCatalog)
m.Put("/v2/service_instances/:service_id", createServiceInstance)
m.Delete("/v2/service_instances/:service_id", deleteServiceInstance)
m.Put("/v2/service_instances/:service_id/service_bindings/:binding_id", createServiceBinding)
m.Delete("/v2/service_instances/:service_id/service_bindings/:binding_id", deleteServiceBinding)
// Service Instance Dashboard
m.Get("/dashboard", showServiceInstanceDashboard)
m.Run()
}
func (this *Server) registerJobsRoutes() {
if config.GetConfig().Admin.UserName == "" {
this.Martini.Group("/jobs", func(r martini.Router) {
jobs_request.CreateJobsRoutes(r)
})
} else {
this.Martini.Group("/jobs", func(r martini.Router) {
jobs_request.CreateJobsRoutes(r)
}, auth.Basic(config.GetConfig().Admin.UserName, config.GetConfig().Admin.Password))
}
}
func main() {
// BasicAuth credentials for admin functions
username := "******"
password := "******"
m := martini.Classic()
//needs import ("time")
m.Use(render.Renderer(render.Options{
Directory: "templates",
Layout: "layout",
Funcs: []template.FuncMap{
{
"formatTime": func(args ...interface{}) string {
t1 := time.Time(args[0].(time.Time))
return t1.Format("Jan 2, 2006 at 3:04pm (MST)")
},
"unescaped": func(args ...interface{}) template.HTML {
return template.HTML(args[0].(string))
},
},
},
}))
// Middleware for mongodb connection
m.Use(Mongo())
// Setup static file serving
m.Use(martini.Static("assets"))
// Setup routing
m.Get("/", BlogEntryList)
m.Post("/blog/add/submit", auth.Basic(username, password), binding.Form(dbBlogEntry{}), addBlogEntrySubmit)
m.Get("/blog/add", auth.Basic(username, password), addBlogEntry)
m.Get("/post/:Id", BlogEntry)
m.Get("/about", About)
m.Get("/impressum", Impressum)
m.Run()
}
func tSetup(output string) {
tMux = http.NewServeMux()
tServer = httptest.NewServer(tMux)
m := martini.New()
r := martini.NewRouter()
r.Post("/transmission/rpc", func() string {
return output
})
m.Action(r.Handle)
m.Use(auth.Basic("test", "test"))
tMux.Handle("/", m)
transmissionClient = New(tServer.URL, "test", "test")
}
func cSetup() {
// test server
cMux = http.NewServeMux()
m := martini.New()
r := martini.NewRouter()
r.Post("/transmission/rpc", RPCHandler)
m.Action(r.Handle)
m.Use(auth.Basic("test", "test"))
cMux.Handle("/", m)
cServer = httptest.NewServer(cMux)
// github client configured to use test server
client = NewClient(cServer.URL+"/transmission/rpc", "test", "test")
}
func main() {
var config, port, api string
flag.StringVar(&config, "c", "config.json", "Config file")
flag.StringVar(&port, "p", "8080", "Port")
flag.StringVar(&api, "a", "DEFAULT", "API key")
flag.Usage = func() {
fmt.Fprintf(os.Stderr, `Usage: %s [options]
Barycenter serves a JSON configuration file over HTTP
using basic authentication (so run it over SSL).
Run an endpoint as follows:
%s -c config.json -a DEFAULT -p 8080
You can then make a request against the endpoint.
curl -u DEFAULT: 127.0.0.1:8080
OPTIONS:
`, os.Args[0], os.Args[0])
flag.PrintDefaults()
}
flag.Parse()
if flag.NArg() != 0 {
flag.Usage()
os.Exit(1)
}
json, err := ioutil.ReadFile(config)
if err != nil {
log.Fatalf("Could not read configuration: %s", err)
}
m := martini.Classic()
m.Use(gzip.All())
m.Use(auth.Basic(api, ""))
m.Get("/", func(w http.ResponseWriter, req *http.Request) string {
w.Header().Set("Content-Type", "application/json; charset=utf-8")
return string(json)
})
http.ListenAndServe(":"+port, m)
}
// Serve sets everything up and runs the docker-builder server
func Serve(context *cli.Context) {
// set vars
setVarsFromContext(context)
// set up auth functions
if shouldBasicAuth {
basicAuthFunc = auth.Basic(un, pwd)
} else {
basicAuthFunc = func(http.ResponseWriter, *http.Request) {}
}
if shouldTravisAuth {
travisAuthFunc = vauth.TravisCI(travisToken)
}
if shouldGitHubAuth {
githubAuthFunc = vauth.GitHub(githubSecret)
}
// configure webhooks
webhook.Logger(logger)
webhook.APIToken(apiToken)
server = setupServer()
if shouldTravis {
server.Post(TravisRoute, travisAuthFunc, webhook.Travis)
}
if shouldGitHub {
server.Post(GitHubRoute, githubAuthFunc, webhook.Github)
}
// base routes
server.Get(HealthRoute, func() (int, string) { return 200, "200 OK" })
server.Post(BuildRoute, basicAuthFunc, webhook.DockerBuild)
// job control routes
server.Group(JobRoute, func(r martini.Router) {
r.Get("/:id", job.Get)
r.Get("/:id/tail", job.TailN)
r.Post("", webhook.DockerBuild)
r.Get("", job.GetAll)
}, basicAuthFunc)
// start server
http.ListenAndServe(portString, server)
}
func RunServer() {
con := db.GetDbConn()
defer con.Close()
m := martini.Classic()
m.Use(auth.Basic("kelly", "kelly"))
m.Use(render.Renderer(render.Options{
Directory: "templates",
Layout: "layout",
Charset: "UTF-8",
}))
m.Get("/", hello)
m.Get("/create_user", createUserView)
m.Post("/create_user", binding.Bind(NewUser{}), createUser)
m.Run()
}
func main() {
router := mux.NewRouter()
router.HandleFunc("/{user}", func(w http.ResponseWriter, req *http.Request) {
fmt.Fprintf(w, "Welcome to the home page, %s!", mux.Vars(req)["user"])
})
middle := interpose.New()
// Use Martini-Auth, a Martini library for basic HTTP authentication
middle.Use(adaptors.FromMartini(auth.Basic("user", "basic")))
// Finally, add the router
middle.UseHandler(router)
// Now visit http://localhost:3001/guest and enter username "user"
// and password "basic"
http.ListenAndServe(":3001", middle)
}
func init() {
m = martini.New()
// Setup middleware
m.Use(martini.Recovery())
m.Use(martini.Logger())
m.Use(auth.Basic(AuthToken, ""))
m.Use(MapEncoder)
// Setup routes
r := martini.NewRouter()
r.Get(`/albums`, GetAlbums)
r.Get(`/albums/:id`, GetAlbum)
r.Post(`/albums`, AddAlbum)
r.Put(`/albums/:id`, UpdateAlbum)
r.Delete(`/albums/:id`, DeleteAlbum)
// Inject database
m.MapTo(db, (*DB)(nil))
// Add the router action
m.Action(r.Handle)
}
func App(settings *Settings, DB *gorm.DB) *martini.ClassicMartini {
m := martini.Classic()
username := os.Getenv("AUTH_USER")
password := os.Getenv("AUTH_PASS")
m.Use(auth.Basic(username, password))
m.Use(render.Renderer())
m.Map(DB)
m.Map(settings)
log.Println("Loading Routes")
// Serve the catalog with services and plans
m.Get("/v2/catalog", func(r render.Render) {
services := BuildCatalog()
catalog := map[string]interface{}{
"services": services,
}
r.JSON(200, catalog)
})
// Create the service instance (cf create-service-instance)
m.Put("/v2/service_instances/:id", CreateInstance)
// Bind the service to app (cf bind-service)
m.Put("/v2/service_instances/:instance_id/service_bindings/:id", BindInstance)
// Unbind the service from app
m.Delete("/v2/service_instances/:instance_id/service_bindings/:id", func(p martini.Params, r render.Render) {
var emptyJson struct{}
r.JSON(200, emptyJson)
})
// Delete service instance
m.Delete("/v2/service_instances/:id", DeleteInstance)
return m
}
func Init() (*martini.ClassicMartini, error) {
m := martini.Classic()
// set up our database
db, err := database.Init()
if err != nil {
return nil, err
}
// database is available to handlers as *Database
m.Map(db)
// drops route
m.Get("/drops", listDrops)
m.Post("/drops", binding.MultipartForm(database.FormDrop{}), addDrop)
// add regex for url+ to go to full size
m.Get("/drops/:url", getDrop)
m.Delete("/drops/:url", deleteDrop)
m.Use(auth.Basic("zach", "zachorr"))
m.Use(render.Renderer())
return m, nil
}
// standardHttp starts serving HTTP or HTTPS (api/web) requests, to be used by normal clients
func standardHttp(discovery bool) {
m := martini.Classic()
switch strings.ToLower(config.Config.AuthenticationMethod) {
case "basic":
{
if config.Config.HTTPAuthUser == "" {
// Still allowed; may be disallowed in future versions
log.Warning("AuthenticationMethod is configured as 'basic' but HTTPAuthUser undefined. Running without authentication.")
}
m.Use(auth.Basic(config.Config.HTTPAuthUser, config.Config.HTTPAuthPassword))
}
case "multi":
{
if config.Config.HTTPAuthUser == "" {
// Still allowed; may be disallowed in future versions
log.Fatal("AuthenticationMethod is configured as 'multi' but HTTPAuthUser undefined")
}
m.Use(auth.BasicFunc(func(username, password string) bool {
if username == "readonly" {
// Will be treated as "read-only"
return true
}
return auth.SecureCompare(username, config.Config.HTTPAuthUser) && auth.SecureCompare(password, config.Config.HTTPAuthPassword)
}))
}
default:
{
// We inject a dummy User object because we have function signatures with User argument in api.go
m.Map(auth.User(""))
}
}
m.Use(gzip.All())
// Render html templates from templates directory
m.Use(render.Renderer(render.Options{
Directory: "resources",
Layout: "templates/layout",
HTMLContentType: "text/html",
}))
m.Use(martini.Static("resources/public"))
if config.Config.UseMutualTLS {
m.Use(ssl.VerifyOUs(config.Config.SSLValidOUs))
}
inst.SetMaintenanceOwner(process.ThisHostname)
if discovery {
log.Info("Starting Discovery")
go logic.ContinuousDiscovery()
}
log.Info("Registering endpoints")
http.API.RegisterRequests(m)
http.Web.RegisterRequests(m)
// Serve
if config.Config.ListenSocket != "" {
log.Infof("Starting HTTP listener on unix socket %v", config.Config.ListenSocket)
unixListener, err := net.Listen("unix", config.Config.ListenSocket)
if err != nil {
log.Fatale(err)
}
defer unixListener.Close()
if err := nethttp.Serve(unixListener, m); err != nil {
log.Fatale(err)
}
} else if config.Config.UseSSL {
log.Info("Starting HTTPS listener")
tlsConfig, err := ssl.NewTLSConfig(config.Config.SSLCAFile, config.Config.UseMutualTLS)
if err != nil {
log.Fatale(err)
}
tlsConfig.InsecureSkipVerify = config.Config.SSLSkipVerify
if err = ssl.AppendKeyPairWithPassword(tlsConfig, config.Config.SSLCertFile, config.Config.SSLPrivateKeyFile, sslPEMPassword); err != nil {
log.Fatale(err)
}
if err = ssl.ListenAndServeTLS(config.Config.ListenAddress, m, tlsConfig); err != nil {
log.Fatale(err)
}
} else {
log.Infof("Starting HTTP listener on %+v", config.Config.ListenAddress)
if err := nethttp.ListenAndServe(config.Config.ListenAddress, m); err != nil {
log.Fatale(err)
}
}
log.Info("Web server started")
}
func withAuthOrNot() (authHandler martini.Handler) {
if conf.Auth.Use {
return auth.Basic(conf.Auth.Username, conf.Auth.Password)
}
return
}
func main() {
flag.StringVar(&appDir, "app-dir", "", "Path to grafana installation")
flag.StringVar(&dbDir, "db-dir", "dashboards", "Path to dashboard storage dir")
flag.StringVar(&authDomain, "auth-domain", "", "OAuth2 domain users must authenticated from (mydomain.com)")
flag.StringVar(&basicAuth, "auth", "", "Basic auth username (user:pw)")
flag.StringVar(&sessionSecret, "session-secret", defaultSessionSecret, "Session secret key")
flag.StringVar(&httpAddr, "http-addr", ":8080", "HTTP Server bind address")
flag.StringVar(&httpsAddr, "https-addr", ":8443", "HTTPS Server bind address")
flag.StringVar(&graphiteURL, "graphite-url", "", "Graphite URL (http://host:port)")
flag.StringVar(&influxDBURL, "influxdb-url", "", "InfluxDB URL (http://host:8086/db/mydb)")
flag.StringVar(&influxDBUser, "influxdb-user", "", "InfluxDB username")
flag.StringVar(&influxDBPass, "influxdb-pass", "", "InfluxDB password")
flag.StringVar(&openTSDBUrl, "opentsdb-url", "", "OpenTSDB URL (http://host:4242)")
flag.StringVar(&sslCert, "ssl-cert", "", "SSL cert (PEM formatted)")
flag.StringVar(&sslKey, "ssl-key", "", "SSL key (PEM formatted)")
flag.StringVar(&hostAddr, "host-addr", "http://localhost:8080", "Public server address (http://mydomain.com)")
flag.StringVar(&googleClientID, "google-client-id", "", "Google Oauth2 Client ID")
flag.StringVar(&googleClientSecret, "google-client-secret", "", "Google Oauth2 Client Sercret")
flag.BoolVar(&version, "version", false, "show version")
flag.Parse()
if version {
println(buildVersion)
return
}
if sessionSecret == defaultSessionSecret {
log.Printf("WARN: Session secret key is using the hard-coded default. Use -session-secret <value> for a live deployment.\n")
}
if graphiteURL == "" && influxDBURL == "" && openTSDBUrl == "" {
fmt.Printf("No graphite-url, influxdb-url or opentsdb-url specified.\nUse -graphite-url http://host:port or -influxdb-url http://host:8086/db/mydb or -opentsdb-url http://host:4242\n")
return
}
log.Printf("Starting gofana %s", buildVersion)
if _, err := os.Stat(dbDir); os.IsNotExist(err) {
fmt.Printf("%s does not exist. Creating.\n", dbDir)
err := os.Mkdir(dbDir, 0766)
if err != nil {
fmt.Printf("ERROR: %s\n", err)
return
}
}
db = &DashboardRepository{Dir: dbDir}
err := db.Load()
if err != nil {
fmt.Printf("ERROR: %s\n", err)
return
}
logger := log.New(os.Stderr, "", log.LstdFlags)
r := martini.NewRouter()
m := martini.New()
m.Map(logger)
m.Use(martini.Recovery())
m.MapTo(r, (*martini.Routes)(nil))
m.Action(r.Handle)
if sslCert != "" && sslKey != "" {
m.Use(secure.Secure(secure.Options{}))
}
b := make([]byte, 32)
_, err = rand.Read(b)
if err != nil {
fmt.Printf("ERROR: %s\n", err)
return
}
m.Use(sessions.Sessions("session", sessions.NewCookieStore([]byte(sessionSecret))))
if oauthEnabled() {
if authDomain == "" {
fmt.Println("ERROR: No -auth-domain specified. Cannot authenticate with OAuth2.\n")
return
}
gomniauth.SetSecurityKey(signature.RandomKey(64))
providers := gomniauth.WithProviders()
if googleOauthEnabled() {
providers.Add(google.New(googleClientID, googleClientSecret, fmt.Sprintf("%s/google/oauth2callback", hostAddr)))
}
m.Use(loginRequired)
}
m.Use(addCorsHeaders)
m.Use(render.Renderer())
if basicAuth != "" && strings.Contains(basicAuth, ":") {
parts := strings.Split(basicAuth, ":")
m.Use(auth.Basic(parts[0], parts[1]))
}
var static martini.Handler
if appDir == "" {
static = staticbin.Static("grafana-1.9.1", grafana.Asset)
} else {
static = martini.Static(appDir, martini.StaticOptions{Fallback: "/index.html", Exclude: "/api/v"})
}
r.NotFound(static, http.NotFound)
r.Get("/search", searchDashboards)
r.Get("/dashboard/:id", getDashboard)
r.Post("/dashboard/:id", saveDashboard)
r.Delete("/dashboard/:id", deleteDashboard)
r.Get("/plugins/datasource.gofana.js", gofanaDatasource)
r.Get("/config.js", gofanaConfig)
r.Get("/graphite/**", proxyGraphite)
r.Post("/graphite/**", proxyGraphite)
r.Get("/influxdb/**", proxyInfluxDB)
r.Post("/influxdb/**", proxyInfluxDB)
r.Get("/opentsdb/**", proxyOpenTSDB)
r.Post("/opentsdb/**", proxyOpenTSDB)
r.Get("/:provider/auth", authRedirect)
r.Get("/:provider/oauth2callback", oauth2callback)
r.Get("/signin", getSignin)
// HTTP Listener
wg.Add(1)
go func() {
defer wg.Done()
log.Printf("HTTP listening on %s\n", httpAddr)
if err := http.ListenAndServe(httpAddr, m); err != nil {
log.Fatal(err)
}
}()
// HTTPS Listener
if sslCert != "" && sslKey != "" {
wg.Add(1)
go func() {
defer wg.Done()
log.Printf("HTTPS listening on %s", httpsAddr)
if err := http.ListenAndServeTLS(httpsAddr, sslCert, sslKey, m); err != nil {
log.Fatal(err)
}
}()
}
wg.Wait()
}
Driver string `json:"driver"`
Connection *jsonConnection `json:"connection"`
Commands []string `json:"commands"`
}
type jsonConnection struct {
Name string `json:"name"`
Port string `json:"port"`
Adaptor string `json:"adaptor"`
}
var startApi = func(me *api) {
username := me.Username
if username != "" {
password := me.Password
me.server.Use(auth.Basic(username, password))
}
port := me.Port
if port == "" {
port = "3000"
}
host := me.Host
cert := me.Cert
key := me.Key
log.Println("Initializing API on " + host + ":" + port + "...")
if cert != "" && key != "" {
go http.ListenAndServeTLS(host+":"+port, cert, key, me.server)
} else {
func main() {
// load env
err := godotenv.Load()
if err != nil {
panic(err)
}
// startup server
m := martini.Classic()
m.Use(render.Renderer())
m.Use(auth.Basic(os.Getenv("USERNAME"), os.Getenv("PASSWORD")))
m.Use(dbConnect())
// index route
m.Get("/entries", func(r render.Render) {
r.JSON(200, entry.All(dbMap))
})
// get latests entry
m.Get("/entries/latest", binding.Json(entry.Entry{}),
func(params martini.Params, e entry.Entry, r render.Render) {
r.JSON(200, entry.Latest(dbMap))
})
// index route
m.Get("/entries/:id", func(params martini.Params, r render.Render) {
e, err := dbMap.Get(entry.Entry{}, params["id"])
if err != nil || e == nil {
r.JSON(404, "Entry not found")
return
}
r.JSON(200, e)
})
// add route
m.Post("/entries", binding.Json(entry.Entry{}), func(params martini.Params, e entry.Entry, r render.Render) {
err := dbMap.Insert(&e)
if err != nil {
r.JSON(404, "Unable to update entry.")
return
}
r.JSON(200, e)
})
// add route
m.Delete("/entries", func(r render.Render) {
err := dbMap.TruncateTables()
if err != nil {
r.JSON(404, "Unable to remove all entries.")
return
}
r.JSON(202, nil)
})
// replace route
m.Put("/entries/:id", binding.Json(entry.Entry{}), func(params martini.Params, e entry.Entry, r render.Render) {
en, err := dbMap.Get(entry.Entry{}, params["id"])
if err != nil || en == nil {
r.JSON(404, "Entry not found")
return
}
//replace existing
_, err = dbMap.Update(&e)
if err != nil {
r.JSON(404, "Unable to update entry.")
return
}
r.JSON(200, e)
})
// initialize server
m.Run()
}
func ApiAuth() martini.Handler {
return auth.Basic(os.Getenv("API_USERNAME"), os.Getenv("API_PASSWORD"))
}
