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")) }