func APIHandler(conf *Config) http.Handler {
api := &API{
conf: conf,
}
if conf.Cache {
if err := api.cacheDashboardJS(); err != nil {
panic(err)
}
}
router := httprouter.New()
router2 := httprouter.New()
prefixPath := func(p string) string {
return path.Join(conf.PathPrefix, p)
}
router.HandlerFunc("GET", status.Path, status.HealthyHandler.ServeHTTP)
router.POST(prefixPath("/user/sessions"), api.WrapHandler(api.Login))
router.DELETE(prefixPath("/user/session"), api.WrapHandler(api.Logout))
router.GET(prefixPath("/config"), api.WrapHandler(api.GetConfig))
router.GET(prefixPath("/cert"), api.WrapHandler(api.GetCert))
router.NotFound = router2.ServeHTTP
router2.GET(prefixPath("/*path"), api.WrapHandler(api.ServeAsset))
return httphelper.ContextInjector("dashboard",
httphelper.NewRequestLogger(
api.CorsHandler(router)))
}
// NewHandler returns a new instance of Handler.
func NewHandler() *Handler {
h := &Handler{router: httprouter.New()}
h.router.HandlerFunc("GET", status.Path, status.HealthyHandler.ServeHTTP)
h.router.PUT("/services/:service", h.servePutService)
h.router.DELETE("/services/:service", h.serveDeleteService)
h.router.GET("/services/:service", h.serveGetService)
h.router.PUT("/services/:service/meta", h.servePutServiceMeta)
h.router.GET("/services/:service/meta", h.serveGetServiceMeta)
h.router.PUT("/services/:service/instances/:instance_id", h.servePutInstance)
h.router.DELETE("/services/:service/instances/:instance_id", h.serveDeleteInstance)
h.router.GET("/services/:service/instances", h.serveGetInstances)
h.router.PUT("/services/:service/leader", h.servePutLeader)
h.router.GET("/services/:service/leader", h.serveGetLeader)
h.router.GET("/raft/leader", h.serveGetRaftLeader)
h.router.POST("/raft/nodes", h.servePostRaftNodes)
h.router.DELETE("/raft/nodes", h.serveDeleteRaftNodes)
h.router.GET("/ping", h.servePing)
return h
}
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 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", api.createDatabase)
router.DELETE("/databases", api.dropDatabase)
router.GET("/ping", 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 ServeHTTP() error {
api := &httpAPI{
InstallerPrompts: make(map[string]*httpPrompt),
InstallerStacks: make(map[string]*httpInstaller),
}
if creds, err := aws.EnvCreds(); err == nil {
api.AWSEnvCreds = creds
}
httpRouter := httprouter.New()
httpRouter.GET("/", api.ServeTemplate)
httpRouter.GET("/install", api.ServeTemplate)
httpRouter.GET("/install/:id", api.ServeTemplate)
httpRouter.POST("/install", api.InstallHandler)
httpRouter.GET("/events/:id", api.EventsHandler)
httpRouter.POST("/prompt/:id", api.PromptHandler)
httpRouter.GET("/assets/*assetPath", api.ServeAsset)
l, err := net.Listen("tcp", "127.0.0.1:0")
if err != nil {
return err
}
addr := fmt.Sprintf("http://localhost:%d", l.Addr().(*net.TCPAddr).Port)
if err := api.OpenAddr(addr); err != nil {
fmt.Printf("Open %s in your browser to continue.\n", addr)
}
return http.Serve(l, api.CorsHandler(httpRouter, addr))
}
func ServeHTTP() error {
logger := log.New()
installer := NewInstaller(logger)
api := &httpAPI{
Installer: installer,
logger: logger,
clientConfig: installerJSConfig{
Endpoints: map[string]string{
"clusters": "/clusters",
"cluster": "/clusters/:id",
"upload_backup": "/clusters/:id/upload-backup",
"cert": "/clusters/:id/ca-cert",
"events": "/events",
"prompt": "/clusters/:id/prompts/:prompt_id",
"credentials": "/credentials",
"regions": "/regions",
"azureSubscriptions": "/azure/subscriptions",
},
},
}
if creds, err := aws.EnvCreds(); err == nil {
api.AWSEnvCreds = creds
if c, err := creds.Credentials(); err == nil {
api.clientConfig.HasAWSEnvCredentials = true
api.clientConfig.AWSEnvCredentialsID = c.AccessKeyID
}
}
httpRouter := httprouter.New()
httpRouter.GET("/", api.ServeTemplate)
httpRouter.GET("/credentials", api.ServeTemplate)
httpRouter.GET("/credentials/:id", api.ServeTemplate)
httpRouter.GET("/clusters/:id", api.ServeTemplate)
httpRouter.POST("/clusters/:id/upload-backup", api.ReceiveBackup)
httpRouter.GET("/clusters/:id/ca-cert", api.GetCert)
httpRouter.GET("/clusters/:id/delete", api.ServeTemplate)
httpRouter.GET("/oauth/azure", api.ServeTemplate)
httpRouter.DELETE("/clusters/:id", api.DeleteCluster)
httpRouter.GET("/clusters", api.RedirectRoot)
httpRouter.POST("/clusters", api.LaunchCluster)
httpRouter.GET("/events", api.Events)
httpRouter.POST("/clusters/:id/prompts/:prompt_id", api.Prompt)
httpRouter.GET("/assets/*assetPath", api.ServeAsset)
httpRouter.POST("/credentials", api.NewCredential)
httpRouter.DELETE("/credentials/:type/:id", api.DeleteCredential)
httpRouter.GET("/regions", api.GetCloudRegions)
httpRouter.GET("/azure/subscriptions", api.GetAzureSubscriptions)
l, err := net.Listen("tcp", "127.0.0.1:0")
if err != nil {
return err
}
addr := fmt.Sprintf("http://localhost:%d", l.Addr().(*net.TCPAddr).Port)
fmt.Printf("Open %s in your browser to continue.\n", addr)
browser.OpenURL(addr)
return http.Serve(l, api.CorsHandler(httpRouter, addr))
}
func NewHTTPHandler(ds Datastore) http.Handler {
router := httprouter.New()
api := &httpAPI{
Store: ds,
}
router.PUT("/services/:service", api.AddService)
router.DELETE("/services/:service", api.RemoveService)
router.GET("/services/:service", api.GetServiceStream)
router.PUT("/services/:service/meta", api.SetServiceMeta)
router.GET("/services/:service/meta", api.GetServiceMeta)
router.PUT("/services/:service/instances/:instance_id", api.AddInstance)
router.DELETE("/services/:service/instances/:instance_id", api.RemoveInstance)
router.GET("/services/:service/instances", api.GetInstances)
router.PUT("/services/:service/leader", api.SetLeader)
router.GET("/services/:service/leader", api.GetLeader)
router.GET("/ping", func(http.ResponseWriter, *http.Request, httprouter.Params) {})
return router
}
// NewHandler returns a new instance of Handler.
func NewHandler() *Handler {
r := httprouter.New()
h := &Handler{Handler: r}
if os.Getenv("DEBUG") != "" {
h.Handler = hh.ContextInjector("discoverd", hh.NewRequestLogger(h.Handler))
}
r.HandlerFunc("GET", status.Path, status.HealthyHandler.ServeHTTP)
r.PUT("/services/:service", h.servePutService)
r.DELETE("/services/:service", h.serveDeleteService)
r.GET("/services/:service", h.serveGetService)
r.PUT("/services/:service/meta", h.servePutServiceMeta)
r.GET("/services/:service/meta", h.serveGetServiceMeta)
r.PUT("/services/:service/instances/:instance_id", h.servePutInstance)
r.DELETE("/services/:service/instances/:instance_id", h.serveDeleteInstance)
r.GET("/services/:service/instances", h.serveGetInstances)
r.PUT("/services/:service/leader", h.servePutLeader)
r.GET("/services/:service/leader", h.serveGetLeader)
r.GET("/raft/leader", h.serveGetRaftLeader)
r.POST("/raft/nodes", h.servePostRaftNodes)
r.DELETE("/raft/nodes", h.serveDeleteRaftNodes)
r.GET("/ping", h.servePing)
return h
}
// NewHandler returns a new instance of Handler.
func NewHandler() *Handler {
h := &Handler{
router: httprouter.New(),
}
h.router.Handler("GET", status.Path, status.Handler(h.healthStatus))
h.router.GET("/status", h.handleGetStatus)
h.router.POST("/stop", h.handlePostStop)
return h
}
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),
)
}
// NewAPIHandler returns a new instance of APIHandler.
func NewHandler() *Handler {
h := &Handler{
router: httprouter.New(),
Logger: log15.New(),
}
h.router.POST("/clusters", h.servePostCluster)
h.router.DELETE("/clusters", h.serveDeleteCluster)
h.router.GET("/ping", h.serveGetPing)
return h
}
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 (h *Host) ServeHTTP() {
r := httprouter.New()
r.POST("/attach", (&attachHandler{state: h.state, backend: h.backend}).ServeHTTP)
jobAPI := &jobAPI{host: h}
jobAPI.RegisterRoutes(r)
volAPI := volumeapi.NewHTTPAPI(cluster.NewClient(), h.vman)
volAPI.RegisterRoutes(r)
go http.Serve(h.listener, httphelper.ContextInjector("host", httphelper.NewRequestLogger(r)))
}
func ServeHTTP(pg *Postgres, peer *state.Peer, hb discoverd.Heartbeater, log log15.Logger) error {
api := &HTTP{
pg: pg,
peer: peer,
hb: hb,
log: log,
}
r := httprouter.New()
r.Handler("GET", status.Path, status.Handler(api.GetHealthStatus))
r.GET("/status", api.GetStatus)
r.POST("/stop", api.Stop)
return http.ListenAndServe(":5433", r)
}
func (h *Host) ServeHTTP() {
r := httprouter.New()
r.POST("/attach", newAttachHandler(h.state, h.backend, h.log).ServeHTTP)
jobAPI := &jobAPI{
host: h,
addJobRatelimitBucket: make(chan struct{}, h.maxJobConcurrency),
}
jobAPI.RegisterRoutes(r)
volAPI := volumeapi.NewHTTPAPI(cluster.NewClient(), h.vman)
volAPI.RegisterRoutes(r)
go http.Serve(h.listener, httphelper.ContextInjector("host", 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))
}
// NewHandler returns a new instance of Handler.
func NewHandler(proxy bool, peers []string) *Handler {
r := httprouter.New()
h := &Handler{Handler: r}
h.Shutdown.Store(false)
h.Peers = peers
h.Proxy.Store(proxy)
if os.Getenv("DEBUG") != "" {
h.Handler = hh.ContextInjector("discoverd", hh.NewRequestLogger(h.Handler))
}
r.HandlerFunc("GET", status.Path, status.HealthyHandler.ServeHTTP)
r.PUT("/services/:service", h.servePutService)
r.DELETE("/services/:service", h.serveDeleteService)
r.GET("/services/:service", h.serveGetService)
r.PUT("/services/:service/meta", h.servePutServiceMeta)
r.GET("/services/:service/meta", h.serveGetServiceMeta)
r.PUT("/services/:service/instances/:instance_id", h.servePutInstance)
r.DELETE("/services/:service/instances/:instance_id", h.serveDeleteInstance)
r.GET("/services/:service/instances", h.serveGetInstances)
r.PUT("/services/:service/leader", h.servePutLeader)
r.GET("/services/:service/leader", h.serveGetLeader)
r.GET("/raft/leader", h.serveGetRaftLeader)
r.GET("/raft/peers", h.serveGetRaftPeers)
r.PUT("/raft/peers/:peer", h.servePutRaftPeer)
r.DELETE("/raft/peers/:peer", h.serveDeleteRaftPeer)
r.POST("/raft/promote", h.servePromote)
r.POST("/raft/demote", h.serveDemote)
r.GET("/ping", h.servePing)
r.POST("/shutdown", h.serveShutdown)
return h
}
func serveHTTP(h *Host, addr string, attach *attachHandler, clus *cluster.Client, vman *volumemanager.Manager, connectDiscoverd func(string) error) error {
l, err := net.Listen("tcp", addr)
if err != nil {
return err
}
shutdown.BeforeExit(func() { l.Close() })
r := httprouter.New()
r.POST("/attach", attach.ServeHTTP)
jobAPI := &jobAPI{
host: h,
connectDiscoverd: connectDiscoverd,
}
jobAPI.RegisterRoutes(r)
volAPI := volumeapi.NewHTTPAPI(clus, vman)
volAPI.RegisterRoutes(r)
go http.Serve(l, httphelper.ContextInjector("host", httphelper.NewRequestLogger(r)))
return nil
}
func (r *Runner) start() error {
r.authKey = os.Getenv("AUTH_KEY")
if r.authKey == "" {
return errors.New("AUTH_KEY not set")
}
r.githubToken = os.Getenv("GITHUB_TOKEN")
if r.githubToken == "" {
return errors.New("GITHUB_TOKEN not set")
}
awsAuth, err := aws.EnvAuth()
if err != nil {
return err
}
r.s3Bucket = s3.New(awsAuth, aws.USEast).Bucket(logBucket)
_, listenPort, err = net.SplitHostPort(args.ListenAddr)
if err != nil {
return err
}
bc := r.bc
bc.Network = r.allocateNet()
if r.rootFS, err = cluster.BuildFlynn(bc, args.RootFS, "origin/master", false, os.Stdout); err != nil {
return fmt.Errorf("could not build flynn: %s", err)
}
r.releaseNet(bc.Network)
shutdown.BeforeExit(func() { removeRootFS(r.rootFS) })
db, err := bolt.Open(args.DBPath, 0600, &bolt.Options{Timeout: 5 * time.Second})
if err != nil {
return fmt.Errorf("could not open db: %s", err)
}
r.db = db
shutdown.BeforeExit(func() { r.db.Close() })
if err := r.db.Update(func(tx *bolt.Tx) error {
_, err := tx.CreateBucketIfNotExists(dbBucket)
return err
}); err != nil {
return fmt.Errorf("could not create builds bucket: %s", err)
}
for i := 0; i < maxConcurrentBuilds; i++ {
r.buildCh <- struct{}{}
}
if err := r.buildPending(); err != nil {
log.Printf("could not build pending builds: %s", err)
}
go r.connectIRC()
go r.watchEvents()
router := httprouter.New()
router.RedirectTrailingSlash = true
router.Handler("GET", "/", http.RedirectHandler("/builds", 302))
router.POST("/", r.handleEvent)
router.GET("/builds/:build", r.getBuildLog)
router.POST("/builds/:build/restart", r.restartBuild)
router.POST("/builds/:build/explain", r.explainBuild)
router.GET("/builds", r.getBuilds)
router.ServeFiles("/assets/*filepath", http.Dir(args.AssetsDir))
router.GET("/cluster/:cluster", r.clusterAPI(r.getCluster))
router.POST("/cluster/:cluster", r.clusterAPI(r.addHost))
router.POST("/cluster/:cluster/release", r.clusterAPI(r.addReleaseHosts))
router.DELETE("/cluster/:cluster/:host", r.clusterAPI(r.removeHost))
srv := &http.Server{
Addr: args.ListenAddr,
Handler: router,
TLSConfig: tlsconfig.SecureCiphers(nil),
}
log.Println("Listening on", args.ListenAddr, "...")
if err := srv.ListenAndServeTLS(args.TLSCert, args.TLSKey); err != nil {
return fmt.Errorf("ListenAndServeTLS: %s", err)
}
return nil
}
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)))
}
