func main() {
username, password := waitForPostgres(serviceName)
db, err := postgres.Open(serviceName, fmt.Sprintf("dbname=postgres user=%s password=%s", username, password))
if err != nil {
log.Fatal(err)
}
r := martini.NewRouter()
m := martini.New()
m.Use(martini.Logger())
m.Use(martini.Recovery())
m.Use(render.Renderer())
m.Action(r.Handle)
m.Map(db)
r.Post("/databases", createDatabase)
r.Get("/ping", ping)
port := os.Getenv("PORT")
if port == "" {
port = "3000"
}
addr := ":" + port
if err := discoverd.Register(serviceName+"-api", addr); err != nil {
log.Fatal(err)
}
log.Fatal(http.ListenAndServe(addr, m))
}
func APIHandler(conf *Config) http.Handler {
r := martini.NewRouter()
m := martini.New()
m.Use(martini.Logger())
m.Use(martini.Recovery())
m.Use(render.Renderer(render.Options{
Directory: conf.StaticPath,
Extensions: []string{".html"},
}))
m.Action(r.Handle)
m.Map(conf)
httpInterfaceURL := conf.InterfaceURL
if strings.HasPrefix(conf.InterfaceURL, "https") {
httpInterfaceURL = "http" + strings.TrimPrefix(conf.InterfaceURL, "https")
}
m.Use(cors.Allow(&cors.Options{
AllowOrigins: []string{conf.InterfaceURL, httpInterfaceURL},
AllowMethods: []string{"GET", "POST", "PUT", "PATCH", "DELETE", "HEAD"},
AllowHeaders: []string{"Authorization", "Accept", "Content-Type", "If-Match", "If-None-Match"},
ExposeHeaders: []string{"ETag"},
AllowCredentials: true,
MaxAge: time.Hour,
}))
r.Group(conf.PathPrefix, func(r martini.Router) {
m.Use(reqHelperMiddleware)
r.Post("/user/sessions", binding.Json(LoginInfo{}), login)
r.Delete("/user/session", logout)
r.Get("/config", getConfig)
r.Get("/cert", getCert)
r.Any("/assets/dashboard.*.js", serveDashboardJs)
r.Any("/assets.*", martini.Static(filepath.Join(conf.StaticPath, "assets"), martini.StaticOptions{
Prefix: "/assets",
}))
r.Get("/.*", func(r render.Render) {
r.HTML(200, "dashboard", "")
})
})
return m
}
func apiHandler(router *Router) http.Handler {
r := martini.NewRouter()
m := martini.New()
m.Use(martini.Logger())
m.Use(martini.Recovery())
m.Use(render.Renderer())
m.Action(r.Handle)
m.Map(router)
r.Post("/routes", binding.Bind(strowger.Route{}), createRoute)
r.Put("/routes", binding.Bind(strowger.Route{}), createOrReplaceRoute)
r.Get("/routes", getRoutes)
r.Get("/routes/:route_type/:route_id", getRoute)
r.Delete("/routes/:route_type/:route_id", deleteRoute)
return m
}
func apiHandler(rtr *Router) http.Handler {
r := martini.NewRouter()
m := martini.New()
m.Map(log.New(os.Stdout, "[router] ", log.LstdFlags|log.Lmicroseconds))
m.Use(martini.Logger())
m.Use(martini.Recovery())
m.Use(render.Renderer())
m.Action(r.Handle)
m.Map(rtr)
r.Post("/routes", binding.Bind(router.Route{}), createRoute)
r.Put("/routes", binding.Bind(router.Route{}), createOrReplaceRoute)
r.Get("/routes", getRoutes)
r.Get("/routes/:route_type/:route_id", getRoute)
r.Delete("/routes/:route_type/:route_id", deleteRoute)
return m
}
func APIHandler(conf *Config) http.Handler {
r := martini.NewRouter()
m := martini.New()
m.Use(martini.Logger())
m.Use(martini.Recovery())
m.Use(render.Renderer(render.Options{}))
m.Action(r.Handle)
m.Map(conf)
httpInterfaceURL := conf.InterfaceURL
if strings.HasPrefix(conf.InterfaceURL, "https") {
httpInterfaceURL = "http" + strings.TrimPrefix(conf.InterfaceURL, "https")
}
m.Use(corsHandler(&cors.Options{
AllowOrigins: []string{conf.InterfaceURL, httpInterfaceURL},
AllowMethods: []string{"GET", "POST", "PUT", "PATCH", "DELETE", "HEAD"},
AllowHeaders: []string{"Authorization", "Accept", "Content-Type", "If-Match", "If-None-Match"},
ExposeHeaders: []string{"ETag"},
AllowCredentials: true,
MaxAge: time.Hour,
}))
r.Get(status.Path, status.HealthyHandler.ServeHTTP)
r.Group(conf.PathPrefix, func(r martini.Router) {
m.Use(reqHelperMiddleware)
r.Post("/user/sessions", binding.Bind(LoginInfo{}), login)
r.Delete("/user/session", logout)
r.Get("/config", getConfig)
r.Get("/cert", getCert)
r.Any("/assets/dashboard.*.js", serveDashboardJs)
r.Any("/assets.*", serveAsset)
r.Get("/ping", pingHandler)
r.Get("/.*", serveTemplate)
})
return m
}
func apiHandler(rtr *Router) http.Handler {
r := martini.NewRouter()
m := martini.New()
m.Map(log.New(os.Stdout, "[router] ", log.LstdFlags|log.Lmicroseconds))
m.Use(martini.Logger())
m.Use(martini.Recovery())
m.Use(render.Renderer())
m.Action(r.Handle)
m.Map(rtr)
r.Get(status.Path, status.SimpleHandler(rtr.HTTP.Ping).ServeHTTP)
r.Post("/routes", binding.Bind(router.Route{}), createRoute)
r.Put("/routes/:route_type/:id", binding.Bind(router.Route{}), updateRoute)
r.Get("/routes", getRoutes)
r.Get("/routes/:route_type/:id", getRoute)
r.Delete("/routes/:route_type/:id", deleteRoute)
r.Get("/events", streamEvents)
r.Any("/debug/**", pprof.Handler.ServeHTTP)
return m
}
func appHandler(c handlerConfig) (http.Handler, *martini.Martini) {
r := martini.NewRouter()
m := martini.New()
m.Use(martini.Logger())
m.Use(martini.Recovery())
m.Use(render.Renderer())
m.Use(responseHelperHandler)
m.Action(r.Handle)
d := NewDB(c.db)
providerRepo := NewProviderRepo(d)
keyRepo := NewKeyRepo(d)
resourceRepo := NewResourceRepo(d)
appRepo := NewAppRepo(d, os.Getenv("DEFAULT_ROUTE_DOMAIN"), c.sc)
artifactRepo := NewArtifactRepo(d)
releaseRepo := NewReleaseRepo(d)
jobRepo := NewJobRepo(d)
formationRepo := NewFormationRepo(d, appRepo, releaseRepo, artifactRepo)
m.Map(resourceRepo)
m.Map(appRepo)
m.Map(artifactRepo)
m.Map(releaseRepo)
m.Map(jobRepo)
m.Map(formationRepo)
m.Map(c.dc)
m.MapTo(c.cc, (*clusterClient)(nil))
m.MapTo(c.sc, (*strowgerc.Client)(nil))
m.MapTo(c.dc, (*resource.DiscoverdClient)(nil))
getAppMiddleware := crud("apps", ct.App{}, appRepo, r)
getReleaseMiddleware := crud("releases", ct.Release{}, releaseRepo, r)
getProviderMiddleware := crud("providers", ct.Provider{}, providerRepo, r)
crud("artifacts", ct.Artifact{}, artifactRepo, r)
crud("keys", ct.Key{}, keyRepo, r)
r.Put("/apps/:apps_id/formations/:releases_id", getAppMiddleware, getReleaseMiddleware, binding.Bind(ct.Formation{}), putFormation)
r.Get("/apps/:apps_id/formations/:releases_id", getAppMiddleware, getFormationMiddleware, getFormation)
r.Delete("/apps/:apps_id/formations/:releases_id", getAppMiddleware, getFormationMiddleware, deleteFormation)
r.Get("/apps/:apps_id/formations", getAppMiddleware, listFormations)
r.Post("/apps/:apps_id/jobs", getAppMiddleware, binding.Bind(ct.NewJob{}), runJob)
r.Put("/apps/:apps_id/jobs/:jobs_id", getAppMiddleware, binding.Bind(ct.Job{}), putJob)
r.Get("/apps/:apps_id/jobs", getAppMiddleware, listJobs)
r.Delete("/apps/:apps_id/jobs/:jobs_id", getAppMiddleware, connectHostMiddleware, killJob)
r.Get("/apps/:apps_id/jobs/:jobs_id/log", getAppMiddleware, connectHostMiddleware, jobLog)
r.Put("/apps/:apps_id/release", getAppMiddleware, binding.Bind(releaseID{}), setAppRelease)
r.Get("/apps/:apps_id/release", getAppMiddleware, getAppRelease)
r.Post("/providers/:providers_id/resources", getProviderMiddleware, binding.Bind(ct.ResourceReq{}), resourceServerMiddleware, provisionResource)
r.Get("/providers/:providers_id/resources", getProviderMiddleware, getProviderResources)
r.Get("/providers/:providers_id/resources/:resources_id", getProviderMiddleware, getResourceMiddleware, getResource)
r.Put("/providers/:providers_id/resources/:resources_id", getProviderMiddleware, binding.Bind(ct.Resource{}), putResource)
r.Get("/apps/:apps_id/resources", getAppMiddleware, getAppResources)
r.Post("/apps/:apps_id/routes", getAppMiddleware, binding.Bind(strowger.Route{}), createRoute)
r.Get("/apps/:apps_id/routes", getAppMiddleware, getRouteList)
r.Get("/apps/:apps_id/routes/:routes_type/:routes_id", getAppMiddleware, getRouteMiddleware, getRoute)
r.Delete("/apps/:apps_id/routes/:routes_type/:routes_id", getAppMiddleware, getRouteMiddleware, deleteRoute)
return rpcMuxHandler(m, rpcHandler(formationRepo), c.key), m
}