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