func main() { http.HandleFunc("/call/receive", receiveCallHandler) http.HandleFunc("/sms/send", sendSMSHandler) http.HandleFunc("/sms/receive", receiveSMSHandler) appengine.Main() }
func main() { // Serve static files from "static" directory. http.Handle("/static/", http.FileServer(http.Dir("."))) http.HandleFunc("/", homepageHandler) appengine.Main() }
func main() { // the appengine package provides a convenient method to handle the health-check requests // and also run the app on the correct port. We just need to add Echo to the default handler e := echo.New(":8080") http.Handle("/", e) appengine.Main() }
func main() { redisAddr := os.Getenv("REDIS_ADDR") redisPassword := os.Getenv("REDIS_PASSWORD") redisPool = &redis.Pool{ Dial: func() (redis.Conn, error) { conn, err := redis.Dial("tcp", redisAddr) if redisPassword == "" { return conn, err } if err != nil { return nil, err } if _, err := conn.Do("AUTH", redisPassword); err != nil { conn.Close() return nil, err } return conn, nil }, // TODO: Tune other settings, like IdleTimeout, MaxActive, MaxIdle, TestOnBorrow. } http.HandleFunc("/", handle) appengine.Main() }
func main() { // the appengine package provides a convenient method to handle the health-check requests // and also run the app on the correct port. We just need to add Vodka to the default handler s := standard.New(":8080") s.SetHandler(e) http.Handle("/", s) appengine.Main() }
func main() { var err error api.Tracer, err = trace.NewClient(appengine.BackgroundContext(), "ellies-pad") if err != nil { panic(err) } appengine.Main() }
func main() { initStorage() go restartAbandonedOperations() setupHandlers() appengine.Main() }
func main() { ctx := context.Background() var err error storageClient, err = storage.NewClient(ctx) if err != nil { log.Fatal(err) } http.HandleFunc("/", formHandler) http.HandleFunc("/upload", uploadHandler) appengine.Main() }
func main() { r := mux.NewRouter() r.Path("/echo").Methods("POST"). HandlerFunc(echoHandler) r.Path("/auth/info/googlejwt").Methods("GET"). HandlerFunc(authInfoHandler) r.Path("/auth/info/googleidtoken").Methods("GET"). HandlerFunc(authInfoHandler) http.Handle("/", r) appengine.Main() }
func main() { go http.ListenAndServe(":8090", http.HandlerFunc(ws.Handle)) http.HandleFunc("/_ah/mail/", controllers.ReceiveMail) http.HandleFunc("/cert", hsts(controllers.Certificate)) http.HandleFunc("/status", hsts(controllers.Status)) r := mux.NewRouter() r.HandleFunc("/subscriptions", hsts(controllers.Subscriptions)) r.HandleFunc("/code/download", hsts(guard(controllers.Template))) r.HandleFunc("/invitations", setup(controllers.Invitation)) r.HandleFunc("/tokens", setup(controllers.Tokens)) r.HandleFunc("/tokens/collect", setup(controllers.CollectTokens)) r.HandleFunc("/challenges", setup(controllers.CreateChallenge)) r.HandleFunc("/challenges/{key}", setup(controllers.ChallengeByKey)) r.HandleFunc("/challenges/{key}/results", setup(controllers.GetResultsByChallenge)) r.HandleFunc("/companies", setup(controllers.PostCompany)) r.HandleFunc("/companies/{key}/challenges", setup(controllers.GetChallengesForCompany)) r.HandleFunc("/companies/{key}/users", setup(controllers.GetUsersByCompany)) r.HandleFunc("/mock", controllers.Mock) r.HandleFunc("/profiles/{key}", setup(controllers.GetProfileByKey)) r.HandleFunc("/profiles/{key}", setup(controllers.DeleteProfile)) r.HandleFunc("/profiles/{key}/challenges", setup(controllers.GetChallengesForProfile)) r.HandleFunc("/results", setup(controllers.CreateResult)) r.HandleFunc("/results/{resultKey}/tasks/{taskKey}/submissions", setup(controllers.PostSubmission)) r.HandleFunc("/results/{resultKey}/finalSubmissions/{index}", setup(controllers.FinalSubmission)) r.HandleFunc("/results/{resultKey}", setup(controllers.GetResult)) r.HandleFunc("/user/company", setup(controllers.GetCompanyByUser)) r.HandleFunc("/user", setup(controllers.WhoAmI)) r.HandleFunc("/users", setup(controllers.User)) r.HandleFunc("/users/{key}", setup(controllers.GetUser)) r.HandleFunc("/users/{key}/profile", setup(controllers.GetProfileForUser)) r.HandleFunc("/tasks/{key}", setup(controllers.TaskByKey)) r.HandleFunc("/tasks", setup(controllers.Tasks)) r.HandleFunc("/whoami", setup(controllers.WhoAmI)) http.Handle("/", r) appengine.Main() }
func main() { ctx := context.Background() // Set this in app.yaml when running in production. projectID := os.Getenv("GCLOUD_DATASET_ID") var err error datastoreClient, err = datastore.NewClient(ctx, projectID) if err != nil { log.Fatal(err) } http.HandleFunc("/", handle) appengine.Main() }
func main() { ctx := context.Background() client, err := pubsub.NewClient(ctx, mustGetenv("GCLOUD_PROJECT")) if err != nil { log.Fatal(err) } // Create topic if it doesn't exist. topic, _ = client.CreateTopic(ctx, mustGetenv("PUBSUB_TOPIC")) http.HandleFunc("/", listHandler) http.HandleFunc("/pubsub/publish", publishHandler) http.HandleFunc("/pubsub/push", pushHandler) appengine.Main() }
func main() { host := os.Getenv("MEMCACHE_PORT_11211_TCP_ADDR") if host == "" { host = "localhost" } port := os.Getenv("MEMCACHE_PORT_11211_TCP_PORT") if port == "" { port = "11211" } addr := fmt.Sprintf("%s:%s", host, port) memcacheClient = memcache.New(addr) http.HandleFunc("/", handle) appengine.Main() }
func main() { ctx := context.Background() // Set this in app.yaml when running in production. projectID := os.Getenv("GCLOUD_PROJECT") topic = os.Getenv("PUBSUB_TOPIC") var err error pubsubCtx, err = pubsubContext(ctx, projectID) if err != nil { log.Fatal(err) } http.HandleFunc("/", listHandler) http.HandleFunc("/pubsub/publish", publishHandler) http.HandleFunc("/pubsub/push", pushHandler) appengine.Main() }
func main() { // Set this in app.yaml when running in production. datastoreName := os.Getenv("MYSQL_CONNECTION") var err error db, err = sql.Open("mysql", datastoreName) if err != nil { log.Fatal(err) } // Ensure the table exists. // Running an SQL query also checks the connection to the MySQL server // is authenticated and valid. if err := createTable(); err != nil { log.Fatal(err) } http.HandleFunc("/", handle) appengine.Main() }
func main() { ctx := context.Background() // Set up admin client, tables, and column families. // NewAdminClient uses Application Default Credentials to authenticate. adminClient, err := bigtable.NewAdminClient(ctx, project, instance) if err != nil { log.Fatalf("Unable to create a table admin client. %v", err) } tables, err := adminClient.Tables(ctx) if err != nil { log.Fatalf("Unable to fetch table list. %v", err) } if !sliceContains(tables, tableName) { if err := adminClient.CreateTable(ctx, tableName); err != nil { log.Fatalf("Unable to create table: %v. %v", tableName, err) } } tblInfo, err := adminClient.TableInfo(ctx, tableName) if err != nil { log.Fatalf("Unable to read info for table: %v. %v", tableName, err) } if !sliceContains(tblInfo.Families, familyName) { if err := adminClient.CreateColumnFamily(ctx, tableName, familyName); err != nil { log.Fatalf("Unable to create column family: %v. %v", familyName, err) } } adminClient.Close() // Set up Bigtable data operations client. // NewClient uses Application Default Credentials to authenticate. client, err = bigtable.NewClient(ctx, project, instance) if err != nil { log.Fatalf("Unable to create data operations client. %v", err) } http.Handle("/", appHandler(mainHandler)) appengine.Main() // Never returns. }
func main() { http.HandleFunc("/sendmail", sendMailHandler) appengine.Main() }
func main() { registerHandlers() appengine.Main() }
func init() { http.HandleFunc("/", handle) appengine.Main() }
func main() { flag.Parse() log.Printf("Starting server, os.Args=%s", strings.Join(os.Args, " ")) doc.SetDefaultGOOS(*defaultGOOS) httpClient = newHTTPClient() var ( gceLogName string projID string ) if metadata.OnGCE() { acct, err := metadata.ProjectAttributeValue("ga-account") if err != nil { log.Printf("querying metadata for ga-account: %v", err) } else { gaAccount = acct } // Get the log name on GCE and setup context for creating a GCE log client. if name, err := metadata.ProjectAttributeValue("gce-log-name"); err != nil { log.Printf("querying metadata for gce-log-name: %v", err) } else { gceLogName = name if id, err := metadata.ProjectID(); err != nil { log.Printf("querying metadata for project ID: %v", err) } else { projID = id } } } else { gaAccount = os.Getenv("GA_ACCOUNT") } if err := parseHTMLTemplates([][]string{ {"about.html", "common.html", "layout.html"}, {"bot.html", "common.html", "layout.html"}, {"cmd.html", "common.html", "layout.html"}, {"dir.html", "common.html", "layout.html"}, {"home.html", "common.html", "layout.html"}, {"importers.html", "common.html", "layout.html"}, {"importers_robot.html", "common.html", "layout.html"}, {"imports.html", "common.html", "layout.html"}, {"notfound.html", "common.html", "layout.html"}, {"pkg.html", "common.html", "layout.html"}, {"results.html", "common.html", "layout.html"}, {"tools.html", "common.html", "layout.html"}, {"std.html", "common.html", "layout.html"}, {"subrepo.html", "common.html", "layout.html"}, {"graph.html", "common.html"}, }); err != nil { log.Fatal(err) } if err := parseTextTemplates([][]string{ {"cmd.txt", "common.txt"}, {"dir.txt", "common.txt"}, {"home.txt", "common.txt"}, {"notfound.txt", "common.txt"}, {"pkg.txt", "common.txt"}, {"results.txt", "common.txt"}, }); err != nil { log.Fatal(err) } var err error db, err = database.New() if err != nil { log.Fatalf("Error opening database: %v", err) } go runBackgroundTasks() staticServer := httputil.StaticServer{ Dir: *assetsDir, MaxAge: time.Hour, MIMETypes: map[string]string{ ".css": "text/css; charset=utf-8", ".js": "text/javascript; charset=utf-8", }, } statusImageHandlerPNG = staticServer.FileHandler("status.png") statusImageHandlerSVG = staticServer.FileHandler("status.svg") apiMux := http.NewServeMux() apiMux.Handle("/favicon.ico", staticServer.FileHandler("favicon.ico")) apiMux.Handle("/google3d2f3cd4cc2bb44b.html", staticServer.FileHandler("google3d2f3cd4cc2bb44b.html")) apiMux.Handle("/humans.txt", staticServer.FileHandler("humans.txt")) apiMux.Handle("/robots.txt", staticServer.FileHandler("apiRobots.txt")) apiMux.Handle("/search", apiHandler(serveAPISearch)) apiMux.Handle("/packages", apiHandler(serveAPIPackages)) apiMux.Handle("/importers/", apiHandler(serveAPIImporters)) apiMux.Handle("/imports/", apiHandler(serveAPIImports)) apiMux.Handle("/", apiHandler(serveAPIHome)) mux := http.NewServeMux() mux.Handle("/-/site.js", staticServer.FilesHandler( "third_party/jquery.timeago.js", "site.js")) mux.Handle("/-/site.css", staticServer.FilesHandler("site.css")) mux.Handle("/-/bootstrap.min.css", staticServer.FilesHandler("bootstrap.min.css")) mux.Handle("/-/bootstrap.min.js", staticServer.FilesHandler("bootstrap.min.js")) mux.Handle("/-/jquery-2.0.3.min.js", staticServer.FilesHandler("jquery-2.0.3.min.js")) if *sidebarEnabled { mux.Handle("/-/sidebar.css", staticServer.FilesHandler("sidebar.css")) } mux.Handle("/-/", http.NotFoundHandler()) mux.Handle("/-/about", handler(serveAbout)) mux.Handle("/-/bot", handler(serveBot)) mux.Handle("/-/go", handler(serveGoIndex)) mux.Handle("/-/subrepo", handler(serveGoSubrepoIndex)) mux.Handle("/-/refresh", handler(serveRefresh)) mux.Handle("/-/admin/reindex", http.HandlerFunc(runReindex)) mux.Handle("/-/admin/purgeindex", http.HandlerFunc(runPurgeIndex)) mux.Handle("/about", http.RedirectHandler("/-/about", http.StatusMovedPermanently)) mux.Handle("/favicon.ico", staticServer.FileHandler("favicon.ico")) mux.Handle("/google3d2f3cd4cc2bb44b.html", staticServer.FileHandler("google3d2f3cd4cc2bb44b.html")) mux.Handle("/humans.txt", staticServer.FileHandler("humans.txt")) mux.Handle("/robots.txt", staticServer.FileHandler("robots.txt")) mux.Handle("/BingSiteAuth.xml", staticServer.FileHandler("BingSiteAuth.xml")) mux.Handle("/C", http.RedirectHandler("http://golang.org/doc/articles/c_go_cgo.html", http.StatusMovedPermanently)) mux.Handle("/code.jquery.com/", http.NotFoundHandler()) mux.Handle("/_ah/health", http.HandlerFunc(serveHealthCheck)) mux.Handle("/_ah/", http.NotFoundHandler()) mux.Handle("/", handler(serveHome)) cacheBusters.Handler = mux var root http.Handler = rootHandler{ {"api.", apiMux}, {"talks.godoc.org", otherDomainHandler{"https", "go-talks.appspot.com"}}, {"www.godoc.org", otherDomainHandler{"https", "godoc.org"}}, {"", mux}, } if gceLogName != "" { ctx := context.Background() logc, err := logging.NewClient(ctx, projID) if err != nil { log.Fatalf("Failed to create cloud logging client: %v", err) } logger := logc.Logger(gceLogName) if err := logc.Ping(ctx); err != nil { log.Fatalf("Failed to ping Google Cloud Logging: %v", err) } gceLogger = newGCELogger(logger) } http.Handle("/", root) appengine.Main() }
func main() { http.HandleFunc("/", handler) appengine.Main() }
func main() { http.HandleFunc("/", handleMainPage) http.HandleFunc("/sign", handleSign) appengine.Main() }
func main() { // ... appengine.Main() }
func main() { http.HandleFunc("/send", sendEmail) appengine.Main() }
func main() { http.HandleFunc("/send_simple", sendSimpleMessageHandler) http.HandleFunc("/send_complex", sendComplexMessageHandler) appengine.Main() }
func Main() { appengine.Main() }
func main() { http.HandleFunc("/module1/sayhi", sayHiHandle) http.HandleFunc("/", handle) appengine.Main() }
// Start will start the SimpleServer at it's configured address. // If they are configured, this will start health checks and access logging. func (s *SimpleServer) Start() error { healthHandler := RegisterHealthHandler(s.cfg, s.monitor, s.mux) s.cfg.HealthCheckPath = healthHandler.Path() // if expvar, register on our router if s.cfg.Metrics.Type == metricscfg.Expvar { if s.cfg.Metrics.Path == "" { s.cfg.Metrics.Path = "/debug/vars" } s.mux.HandleFunc("GET", s.cfg.Metrics.Path, expvarHandler) } // if this is an App Engine setup, just run it here if s.cfg.appEngine { http.Handle("/", s) appengine.Main() return nil } wrappedHandler, err := NewAccessLogMiddleware(s.cfg.HTTPAccessLog, s) if err != nil { Log.Fatalf("unable to create http access log: %s", err) } srv := http.Server{ Handler: wrappedHandler, MaxHeaderBytes: maxHeaderBytes, ReadTimeout: readTimeout, WriteTimeout: writeTimeout, } l, err := net.Listen("tcp", fmt.Sprintf(":%d", s.cfg.HTTPPort)) if err != nil { return err } l = net.Listener(TCPKeepAliveListener{l.(*net.TCPListener)}) // add TLS if in the configs if s.cfg.TLSCertFile != nil && s.cfg.TLSKeyFile != nil { cert, err := tls.LoadX509KeyPair(*s.cfg.TLSCertFile, *s.cfg.TLSKeyFile) if err != nil { return err } srv.TLSConfig = &tls.Config{ Certificates: []tls.Certificate{cert}, NextProtos: []string{"http/1.1"}, } l = tls.NewListener(l, srv.TLSConfig) } go func() { if err := srv.Serve(l); err != nil { Log.Error("encountered an error while serving listener: ", err) } }() Log.Infof("Listening on %s", l.Addr().String()) // join the LB go func() { exit := <-s.exit // let the health check clean up if it needs to if err := healthHandler.Stop(); err != nil { Log.Warn("health check Stop returned with error: ", err) } // flush any remaining metrics and close connections s.mets.Stop() // stop the listener exit <- l.Close() }() return nil }
func main() { appengine.Main() //init(); }
func main() { go http.ListenAndServe(":8090", http.HandlerFunc(ws.Handle)) http.Handle("/", controllers.Handler()) appengine.Main() }