func init() { if err := cfg.Init(cfg.EnvProvider{Namespace: "XENIA"}); err != nil { log.Println("Unable to initialize configuration") os.Exit(1) } // Insert the base url for requests by this client. DefaultClient.BaseURL = cfg.MustURL(cfgWebHost).String() platformPrivateKey, err := cfg.String(cfgPlatformPrivateKey) if err != nil || platformPrivateKey == "" { if err != nil { log.Printf("Downstream Auth : Disabled : %s\n", err.Error()) return } log.Printf("Downstream Auth : Disabled\n") return } // If the platformPrivateKey is provided, then we should generate the token // signing function to be used when composing requests down to the platform. signer, err := auth.NewSigner(platformPrivateKey) if err != nil { log.Printf("Downstream Auth : Error : %s", err.Error()) os.Exit(1) } // Requests can now be signed with the given signer function which we will // save on the application wide context. In the event that a function // requires a call down to a downstream platform, we will include a signed // header using the signer function here. DefaultClient.Signer = signer log.Println("Downstream Auth : Enabled") }
// API returns a handler for a set of routes. func API() http.Handler { w := web.New(logm.Midware, errorm.Midware) publicKey, err := cfg.String(cfgAuthPublicKey) if err != nil || publicKey == "" { log.User("startup", "Init", "%s is missing, internal authentication is disabled", cfgAuthPublicKey) } // If the public key is provided then add the auth middleware or fail using // the provided public key. if publicKey != "" { log.Dev("startup", "Init", "Initializing Auth") authm, err := authm.Midware(publicKey, authm.MidwareOpts{}) if err != nil { log.Error("startup", "Init", err, "Initializing Auth") os.Exit(1) } // Apply the authentication middleware on top of the application as the // first middleware. w.Use(authm) } platformPrivateKey, err := cfg.String(cfgPlatformPrivateKey) if err != nil || platformPrivateKey == "" { log.User("startup", "Init", "%s is missing, downstream platform authentication is disabled", cfgPlatformPrivateKey) } // If the platformPrivateKey is provided, then we should generate the token // signing function to be used when composing requests down to the platform. if platformPrivateKey != "" { log.Dev("startup", "Init", "Initializing Downstream Platform Auth") signer, err := auth.NewSigner(platformPrivateKey) if err != nil { log.Error("startup", "Init", err, "Initializing Downstream Platform Auth") os.Exit(1) } // Requests can now be signed with the given signer function which we will // save on the application wide context. In the event that a function // requires a call down to a downstream platform, we will include a signed // header using the signer function here. w.Ctx["signer"] = signer } if cors, err := cfg.Bool(cfgEnableCORS); err == nil && cors { log.Dev("startup", "Init", "Initializing CORS : CORS Enabled") w.Use(w.CORS()) } else { log.Dev("startup", "Init", "CORS Disabled") } // We need the URL for the services Sponged and Xeniad that needs to be running. spongedURL, err = cfg.String(cfgSpongedURL) if err != nil || spongedURL == "" { log.Error("startup", "Init", err, "Service Sponged needs to be setup.") os.Exit(1) } w.Ctx["spongedURL"] = cfg.MustURL(cfgSpongedURL).String() xeniadURL, err = cfg.String(cfgXeniadURL) if err != nil || xeniadURL == "" { log.Error("startup", "Init", err, "Service Xeniad needs to be setup.") os.Exit(1) } w.Ctx["xeniadURL "] = cfg.MustURL(cfgXeniadURL).String() log.Dev("startup", "Init", "Initalizing routes") routes(w) return w }