func main() {
defer shutdown.Exit()
db := postgres.Wait(&postgres.Conf{
Service: serviceName,
User: "******",
Password: os.Getenv("PGPASSWORD"),
Database: "postgres",
}, nil)
api := &pgAPI{db}
router := httprouter.New()
router.POST("/databases", httphelper.WrapHandler(api.createDatabase))
router.DELETE("/databases", httphelper.WrapHandler(api.dropDatabase))
router.GET("/ping", httphelper.WrapHandler(api.ping))
port := os.Getenv("PORT")
if port == "" {
port = "3000"
}
addr := ":" + port
hb, err := discoverd.AddServiceAndRegister(serviceName+"-api", addr)
if err != nil {
shutdown.Fatal(err)
}
shutdown.BeforeExit(func() { hb.Close() })
handler := httphelper.ContextInjector(serviceName+"-api", httphelper.NewRequestLogger(router))
shutdown.Fatal(http.ListenAndServe(addr, handler))
}
func main() {
defer shutdown.Exit()
api := &API{}
router := httprouter.New()
router.POST("/databases", httphelper.WrapHandler(api.createDatabase))
router.DELETE("/databases", httphelper.WrapHandler(api.dropDatabase))
router.GET("/ping", httphelper.WrapHandler(api.ping))
port := os.Getenv("PORT")
if port == "" {
port = "3000"
}
addr := ":" + port
hb, err := discoverd.AddServiceAndRegister(serviceName+"-api", addr)
if err != nil {
shutdown.Fatal(err)
}
shutdown.BeforeExit(func() { hb.Close() })
handler := httphelper.ContextInjector(serviceName+"-api", httphelper.NewRequestLogger(router))
shutdown.Fatal(http.ListenAndServe(addr, handler))
}
func main() {
defer shutdown.Exit()
dsn := &mariadb.DSN{
Host: serviceHost + ":3306",
User: "******",
Password: os.Getenv("MYSQL_PWD"),
Database: "mysql",
}
db, err := sql.Open("mysql", dsn.String())
api := &API{db}
router := httprouter.New()
router.POST("/databases", httphelper.WrapHandler(api.createDatabase))
router.DELETE("/databases", httphelper.WrapHandler(api.dropDatabase))
router.GET("/ping", httphelper.WrapHandler(api.ping))
port := os.Getenv("PORT")
if port == "" {
port = "3000"
}
addr := ":" + port
hb, err := discoverd.AddServiceAndRegister(serviceName+"-api", addr)
if err != nil {
shutdown.Fatal(err)
}
shutdown.BeforeExit(func() { hb.Close() })
handler := httphelper.ContextInjector(serviceName+"-api", httphelper.NewRequestLogger(router))
shutdown.Fatal(http.ListenAndServe(addr, handler))
}
func apiHandler(agg *Aggregator, cursors *HostCursors) http.Handler {
api := aggregatorAPI{agg, cursors}
r := httprouter.New()
r.Handler("GET", status.Path, status.HealthyHandler)
r.GET("/log/:channel_id", httphelper.WrapHandler(api.GetLog))
r.GET("/cursors", httphelper.WrapHandler(api.GetCursors))
return httphelper.ContextInjector(
"logaggregator-api",
httphelper.NewRequestLogger(r),
)
}
func apiHandler(agg *Aggregator) http.Handler {
api := aggregatorAPI{agg: agg}
r := httprouter.New()
r.GET("/log/:channel_id", httphelper.WrapHandler(api.GetLog))
return httphelper.ContextInjector(
"logaggregator-api",
httphelper.NewRequestLogger(r),
)
}
func apiHandler(rtr *Router) http.Handler {
api := &API{router: rtr}
r := httprouter.New()
r.HandlerFunc("GET", status.Path, status.HealthyHandler.ServeHTTP)
r.POST("/routes", httphelper.WrapHandler(api.CreateRoute))
r.PUT("/routes/:route_type/:id", httphelper.WrapHandler(api.UpdateRoute))
r.GET("/routes", httphelper.WrapHandler(api.GetRoutes))
r.GET("/routes/:route_type/:id", httphelper.WrapHandler(api.GetRoute))
r.DELETE("/routes/:route_type/:id", httphelper.WrapHandler(api.DeleteRoute))
r.GET("/events", httphelper.WrapHandler(api.StreamEvents))
r.HandlerFunc("GET", "/debug/*path", pprof.Handler.ServeHTTP)
return httphelper.ContextInjector("router", httphelper.NewRequestLogger(r))
}
func appHandler(c handlerConfig) http.Handler {
err := schema.Load(schemaRoot)
if err != nil {
shutdown.Fatal(err)
}
q := que.NewClient(c.pgxpool)
providerRepo := NewProviderRepo(c.db)
keyRepo := NewKeyRepo(c.db)
resourceRepo := NewResourceRepo(c.db)
appRepo := NewAppRepo(c.db, os.Getenv("DEFAULT_ROUTE_DOMAIN"), c.rc)
artifactRepo := NewArtifactRepo(c.db)
releaseRepo := NewReleaseRepo(c.db)
jobRepo := NewJobRepo(c.db)
formationRepo := NewFormationRepo(c.db, appRepo, releaseRepo, artifactRepo)
deploymentRepo := NewDeploymentRepo(c.db, c.pgxpool)
api := controllerAPI{
appRepo: appRepo,
releaseRepo: releaseRepo,
providerRepo: providerRepo,
formationRepo: formationRepo,
artifactRepo: artifactRepo,
jobRepo: jobRepo,
resourceRepo: resourceRepo,
deploymentRepo: deploymentRepo,
clusterClient: c.cc,
logaggc: c.lc,
routerc: c.rc,
que: q,
}
httpRouter := httprouter.New()
crud(httpRouter, "apps", ct.App{}, appRepo)
crud(httpRouter, "releases", ct.Release{}, releaseRepo)
crud(httpRouter, "providers", ct.Provider{}, providerRepo)
crud(httpRouter, "artifacts", ct.Artifact{}, artifactRepo)
crud(httpRouter, "keys", ct.Key{}, keyRepo)
httpRouter.POST("/apps/:apps_id", httphelper.WrapHandler(api.UpdateApp))
httpRouter.GET("/apps/:apps_id/log", httphelper.WrapHandler(api.appLookup(api.AppLog)))
httpRouter.GET("/apps/:apps_id/events", httphelper.WrapHandler(api.appLookup(api.AppEvents)))
httpRouter.DELETE("/apps/:apps_id", httphelper.WrapHandler(api.appLookup(api.DeleteApp)))
httpRouter.PUT("/apps/:apps_id/formations/:releases_id", httphelper.WrapHandler(api.appLookup(api.PutFormation)))
httpRouter.GET("/apps/:apps_id/formations/:releases_id", httphelper.WrapHandler(api.appLookup(api.GetFormation)))
httpRouter.DELETE("/apps/:apps_id/formations/:releases_id", httphelper.WrapHandler(api.appLookup(api.DeleteFormation)))
httpRouter.GET("/apps/:apps_id/formations", httphelper.WrapHandler(api.appLookup(api.ListFormations)))
httpRouter.GET("/formations", httphelper.WrapHandler(api.GetFormations))
httpRouter.POST("/apps/:apps_id/jobs", httphelper.WrapHandler(api.appLookup(api.RunJob)))
httpRouter.GET("/apps/:apps_id/jobs/:jobs_id", httphelper.WrapHandler(api.appLookup(api.GetJob)))
httpRouter.PUT("/apps/:apps_id/jobs/:jobs_id", httphelper.WrapHandler(api.appLookup(api.PutJob)))
httpRouter.GET("/apps/:apps_id/jobs", httphelper.WrapHandler(api.appLookup(api.ListJobs)))
httpRouter.DELETE("/apps/:apps_id/jobs/:jobs_id", httphelper.WrapHandler(api.appLookup(api.KillJob)))
httpRouter.POST("/apps/:apps_id/deploy", httphelper.WrapHandler(api.appLookup(api.CreateDeployment)))
httpRouter.GET("/deployments/:deployment_id", httphelper.WrapHandler(api.GetDeployment))
httpRouter.PUT("/apps/:apps_id/release", httphelper.WrapHandler(api.appLookup(api.SetAppRelease)))
httpRouter.GET("/apps/:apps_id/release", httphelper.WrapHandler(api.appLookup(api.GetAppRelease)))
httpRouter.GET("/apps/:apps_id/releases", httphelper.WrapHandler(api.appLookup(api.GetAppReleases)))
httpRouter.POST("/providers/:providers_id/resources", httphelper.WrapHandler(api.ProvisionResource))
httpRouter.GET("/providers/:providers_id/resources", httphelper.WrapHandler(api.GetProviderResources))
httpRouter.GET("/providers/:providers_id/resources/:resources_id", httphelper.WrapHandler(api.GetResource))
httpRouter.PUT("/providers/:providers_id/resources/:resources_id", httphelper.WrapHandler(api.PutResource))
httpRouter.DELETE("/providers/:providers_id/resources/:resources_id", httphelper.WrapHandler(api.DeleteResource))
httpRouter.GET("/apps/:apps_id/resources", httphelper.WrapHandler(api.appLookup(api.GetAppResources)))
httpRouter.POST("/apps/:apps_id/routes", httphelper.WrapHandler(api.appLookup(api.CreateRoute)))
httpRouter.GET("/apps/:apps_id/routes", httphelper.WrapHandler(api.appLookup(api.GetRouteList)))
httpRouter.GET("/apps/:apps_id/routes/:routes_type/:routes_id", httphelper.WrapHandler(api.appLookup(api.GetRoute)))
httpRouter.DELETE("/apps/:apps_id/routes/:routes_type/:routes_id", httphelper.WrapHandler(api.appLookup(api.DeleteRoute)))
httpRouter.POST("/apps/:apps_id/meta", httphelper.WrapHandler(api.appLookup(api.UpdateAppMeta)))
return httphelper.ContextInjector("controller",
httphelper.NewRequestLogger(muxHandler(httpRouter, c.keys)))
}
func crud(r *httprouter.Router, resource string, example interface{}, repo Repository) {
resourceType := reflect.TypeOf(example)
prefix := "/" + resource
r.POST(prefix, httphelper.WrapHandler(func(ctx context.Context, rw http.ResponseWriter, req *http.Request) {
thing := reflect.New(resourceType).Interface()
if err := httphelper.DecodeJSON(req, thing); err != nil {
respondWithError(rw, err)
return
}
if err := schema.Validate(thing); err != nil {
respondWithError(rw, err)
return
}
if err := repo.Add(thing); err != nil {
respondWithError(rw, err)
return
}
httphelper.JSON(rw, 200, thing)
}))
lookup := func(ctx context.Context) (interface{}, error) {
params, _ := ctxhelper.ParamsFromContext(ctx)
return repo.Get(params.ByName(resource + "_id"))
}
singletonPath := prefix + "/:" + resource + "_id"
r.GET(singletonPath, httphelper.WrapHandler(func(ctx context.Context, rw http.ResponseWriter, _ *http.Request) {
thing, err := lookup(ctx)
if err != nil {
respondWithError(rw, err)
return
}
httphelper.JSON(rw, 200, thing)
}))
r.GET(prefix, httphelper.WrapHandler(func(ctx context.Context, rw http.ResponseWriter, _ *http.Request) {
list, err := repo.List()
if err != nil {
respondWithError(rw, err)
return
}
httphelper.JSON(rw, 200, list)
}))
if remover, ok := repo.(Remover); ok {
r.DELETE(singletonPath, httphelper.WrapHandler(func(ctx context.Context, rw http.ResponseWriter, _ *http.Request) {
_, err := lookup(ctx)
if err != nil {
respondWithError(rw, err)
return
}
params, _ := ctxhelper.ParamsFromContext(ctx)
if err = remover.Remove(params.ByName(resource + "_id")); err != nil {
respondWithError(rw, err)
return
}
rw.WriteHeader(200)
}))
}
}