// loadConfiguration loads the configuration of application
func loadConfiguration(app *AppConfig, rdis *RedisConfig, nats *NatsConfig) {
err := envconfig.Process(ServiceName, app)
if err != nil {
log.Panicln(err)
}
err = envconfig.Process("redis", rdis)
if err != nil {
log.Panicln(err)
}
err = envconfig.Process("nats", nats)
if err != nil {
log.Panicln(err)
}
if len(os.Getenv(KeyLogly)) > 0 {
log.Printf("Loading logly token %s \n", os.Getenv(KeyLogly))
hook := logrusly.NewLogglyHook(os.Getenv(KeyLogly),
app.Host,
log.InfoLevel,
app.Name)
log.AddHook(hook)
}
log.Println("#### LOADED CONFIG #####")
log.Printf("REDIS_URI: %s \n", rdis.URI)
log.Printf("NATS_ENDPOINT: %s \n", nats.Endpoint)
}
// LoadConfig will load the configuration file from filePath, if it can't open
// the file for reading, it assumes there is no configuration file and will try to create
// one on the default path (tyk.conf in the local directory)
func loadConfig(filePath string, configStruct *Config) {
configuration, err := ioutil.ReadFile(filePath)
if err != nil {
log.Error("Couldn't load configuration file")
log.Error(err)
log.Info("Writing a default file to ./tyk.conf")
WriteDefaultConf(configStruct)
log.Info("Loading default configuration...")
loadConfig("tyk.conf", configStruct)
} else {
if err := json.Unmarshal(configuration, &configStruct); err != nil {
log.Error("Couldn't unmarshal configuration")
log.Error(err)
}
overrideErr := envconfig.Process(ENV_PREVIX, configStruct)
if overrideErr != nil {
log.Error("Failed to process environment variables after file load: ", overrideErr)
}
}
if configStruct.SlaveOptions.CallTimeout == 0 {
configStruct.SlaveOptions.CallTimeout = 30
}
if configStruct.SlaveOptions.PingTimeout == 0 {
configStruct.SlaveOptions.PingTimeout = 60
}
GlobalRPCPingTimeout = time.Second * time.Duration(configStruct.SlaveOptions.PingTimeout)
GlobalRPCCallTimeout = time.Second * time.Duration(configStruct.SlaveOptions.CallTimeout)
configStruct.EventTriggers = InitGenericEventHandlers(configStruct.EventHandlers)
}
// WriteDefaultConf will create a default configuration file and set the storage type to "memory"
func WriteDefaultConf(configStruct *Config) {
configStruct.ListenAddress = ""
configStruct.ListenPort = 8080
configStruct.Secret = "352d20ee67be67f6340b4c0605b044b7"
configStruct.TemplatePath = "./templates"
configStruct.TykJSPath = "./js/tyk.js"
configStruct.MiddlewarePath = "./middleware"
configStruct.Storage.Type = "redis"
configStruct.AppPath = "./apps/"
configStruct.Storage.Host = "localhost"
configStruct.Storage.Username = ""
configStruct.Storage.Password = ""
configStruct.Storage.Database = 0
configStruct.Storage.MaxIdle = 100
configStruct.Storage.Port = 6379
configStruct.EnableAnalytics = false
configStruct.HealthCheck.EnableHealthChecks = true
configStruct.HealthCheck.HealthCheckValueTimeout = 60
configStruct.AnalyticsConfig.IgnoredIPs = make([]string, 0)
configStruct.UseAsyncSessionWrite = false
configStruct.HideGeneratorHeader = false
configStruct.OauthRedirectUriSeparator = ""
newConfig, err := json.MarshalIndent(configStruct, "", " ")
overrideErr := envconfig.Process(ENV_PREVIX, &configStruct)
if overrideErr != nil {
log.Error("Failed to process environment variables: ", overrideErr)
}
if err != nil {
log.Error("Problem marshalling default configuration!")
log.Error(err)
} else {
ioutil.WriteFile("tyk.conf", newConfig, 0644)
}
}
//environment variables must be in following format
//SETTINGS_URL_CHANNEL_API
//SETTINGS_QUEUE_HOST
func (settings *envSettings) readEnvironmentVariables() error {
err := envconfig.Process("settings", settings)
if err != nil {
return err
}
return nil
}
func init() {
// Pull in the configuration
err := envconfig.Process("buoy", &Config)
if err != nil {
tracelog.COMPLETED_ERROR(err, helper.MAIN_GO_ROUTINE, "Init")
}
}
func NewApp(name string) (AppCtx, error) {
specs := Specs{}
err := envconfig.Process(name, &specs)
if err != nil {
return AppCtx{}, err
}
url := fmt.Sprintf("%v:%v@tcp(%v:%v)/%v",
specs.DBUser,
specs.DBPass,
specs.DBHost,
specs.DBPort,
specs.DBName,
)
db, err := sql.Open("mysql", url)
if err != nil {
return AppCtx{}, err
}
ctx := AppCtx{
Specs: specs,
DB: db,
}
return ctx, nil
}
func LoadConfig() (*Config, error) {
var config Config
err := envconfig.Process(configPrefix, &config)
if err != nil {
return nil, errors.Wrap(err, "Failed to load config from envs.")
}
if _, err := os.Stat(configFilePath); err != nil {
return &config, nil
}
configFromFile, err := loadConfigFromFile(configFilePath)
if err != nil {
return nil, err
}
for _, configName := range configNames {
if configName == "MaxAppDeploy" {
n, err := strconv.ParseInt(configFromFile[configName], 10, 64)
if err != nil {
return nil, errors.Wrapf(err, "Failed to parse %s as integer. value: %s", configName, configFromFile[configName])
}
reflect.ValueOf(&config).Elem().FieldByName(configName).SetInt(n)
} else {
reflect.ValueOf(&config).Elem().FieldByName(configName).SetString(configFromFile[configName])
}
}
return &config, nil
}
func configure() {
err := envconfig.Process(appName, &config)
if err != nil {
log.Println("Errof: %v\n", err.Error())
}
log.Println("Initial generation of static files...")
generateStaticFiles()
log.Println("Initializing image watchdog...")
watcher, err = fsnotify.NewWatcher()
if err != nil {
log.Printf("Error: %v\n", err.Error())
}
err = watcher.Watch("src/assets/photos")
if err != nil {
log.Printf("Error: %v\n", err.Error())
}
go func() {
for {
select {
case ev := <-watcher.Event:
if ev.IsCreate() {
log.Println("Regenerating static files...")
generateStaticFiles()
}
}
}
}()
log.Println("Configuration complete...")
}
func (pureInfoService) Host() (server.HostResponse, error) {
var errResp string
var hostSpec HostSpec
err := envconfig.Process("infosvc", &hostSpec)
if err != nil {
errResp = err.Error()
}
var ips []string
addrs, _ := net.InterfaceAddrs()
for _, addr := range addrs {
if ipnet, ok := addr.(*net.IPNet); ok && !ipnet.IP.IsLoopback() {
if ipnet.IP.To4() != nil {
ips = append(ips, ipnet.IP.String())
}
}
}
myHostName, err := os.Hostname()
if err != nil {
errResp = err.Error()
}
var myOS = fmt.Sprintf("%s %s", hostSpec.OS, hostSpec.Arch)
return server.HostResponse{Name: myHostName, OS: myOS, Addrs: ips, Err: errResp}, nil
}
// Startup brings the manager to a running state.
func Startup(sessionID string) error {
// If the system has already been started ignore the call.
if singleton.sessions != nil {
return nil
}
log.Started(sessionID, "Startup")
// Pull in the configuration.
var config mongoConfiguration
if err := envconfig.Process("mgo", &config); err != nil {
log.CompletedError(err, sessionID, "Startup")
return err
}
// Create the Mongo Manager.
singleton = mongoManager{
sessions: make(map[string]mongoSession),
}
// Create the strong session.
if err := CreateSession(sessionID, "strong", MasterSession, config.Url); err != nil {
log.CompletedError(err, sessionID, "Startup")
return err
}
// Create the monotonic session.
if err := CreateSession(sessionID, "monotonic", MonotonicSession, config.Url); err != nil {
log.CompletedError(err, sessionID, "Startup")
return err
}
log.Completed(sessionID, "Startup")
return nil
}
func main() {
log = log15.New()
log.Info("starting server...")
envconfig.Process("", &settings)
schema, err := graphql.NewSchema(makeSchema())
if err != nil {
log.Info("error creating schema", "err", err)
return
}
h := handler.New(&handler.Config{
Schema: &schema,
Pretty: false,
})
mux := http.NewServeMux()
mux.Handle("/graphql", h)
mux.Handle("/", http.FileServer(http.Dir("dist")))
log.Info("Listening at " + settings.Port + "...")
graceful.Run(":"+settings.Port, 1*time.Second, mux)
log.Info("Exiting...")
}
func init() {
var c Config
envconfig.Process("proxym_mesos_master", &c)
if c.Enabled {
err := sanitizeConfig(&c)
if err != nil {
log.ErrorLog.Critical("Not initializing module Mesos Master: '%s'", err)
return
}
lr := &leaderRegistry{
mutex: &sync.Mutex{},
}
n, err := NewMesosNotifier(&c, lr)
if err != nil {
log.ErrorLog.Fatal(err)
}
manager.AddNotifier(n)
sg := &MesosMasterServiceGenerator{
config: &c,
leaderRegistry: lr,
}
manager.AddServiceGenerator(sg)
}
}
func Get() (*Config, error) {
var ret Config
if err := envconfig.Process(AppName, &ret); err != nil {
return nil, err
}
return &ret, nil
}
// InitContex initializes the app context
func InitContex() *Context {
if _context != nil {
panic("Context already exists")
}
_context = new(Context)
if err := envconfig.Process("api", &_context.Params); err != nil {
panic(err)
}
// Setup database
session, err := mgo.Dial(_context.Params.MongoURI)
if err != nil {
fmt.Println("Cannot start mongo")
panic(err)
}
_context.Session = session
_context.Session.SetMode(mgo.Monotonic, true)
_context.DB = session.DB("")
// LogEntries
if _context.Params.LogEntriesToken != "" {
_context.LogEntries, err = le_go.Connect(_context.Params.LogEntriesToken)
if err != nil {
panic(err)
}
}
return _context
}
// Read the configuration from the environment
// Defaults will be set for unset fields
func (config *Configuration) Read() error {
err := envconfig.Process("", config)
if err != nil {
log.Fatal("Failed to load configuration, error is - " + err.Error())
return err
}
if config.DownloadListFile == "" {
config.DownloadListFile = "./list.json"
}
if config.WWWRoot == "" {
config.WWWRoot = "/www"
}
if config.Port == 0 {
config.Port = 80
}
if config.MaximumNumberRetry == 0 {
config.MaximumNumberRetry = 3
}
if config.MaximumParallelDownloads == 0 {
config.MaximumParallelDownloads = 5
}
log.Printf("Staging UI configuration: %+v", config)
return nil
}
// Load configuration settings from the environment, apply defaults, and validate them.
func (c *Context) Load() error {
if err := envconfig.Process("PIPE", &c.Settings); err != nil {
return err
}
if c.Port == 0 {
c.Port = 8000
}
if c.LogLevel == "" {
c.LogLevel = "info"
}
if c.MongoURL == "" {
c.MongoURL = "mongo"
}
if c.Poll == 0 {
c.Poll = 500
}
if c.DockerHost == "" {
if host := os.Getenv("DOCKER_HOST"); host != "" {
c.DockerHost = host
} else {
c.DockerHost = "unix:///var/run/docker.sock"
}
}
certRoot := os.Getenv("DOCKER_CERT_PATH")
if certRoot == "" {
certRoot = "/certificates"
}
if c.CACert == "" {
c.CACert = path.Join(certRoot, "ca.pem")
}
if c.Cert == "" {
c.Cert = path.Join(certRoot, "cloudpipe-cert.pem")
}
if c.Key == "" {
c.Key = path.Join(certRoot, "cloudpipe-key.pem")
}
if c.DefaultImage == "" {
c.DefaultImage = "cloudpipe/runner-py2"
}
if c.Settings.AuthService == "" {
c.Settings.AuthService = "https://authstore:9001/v1"
}
if _, err := log.ParseLevel(c.LogLevel); err != nil {
return err
}
return nil
}
// LoadBot creates a new BotAPI instance using environmental variables.
// It also makes the maps needed for the bot to run, and loads admins.
func LoadBot() *tgbotapi.BotAPI {
var cfg Config
err := envconfig.Process("TELEGRAM", &cfg)
if err != nil {
log.Fatal(err)
}
tg, err := tgbotapi.NewBotAPI(cfg.APIToken)
if cfg.APIDebug {
tg.Debug = true
}
if err != nil {
log.Panic(err)
}
bot.Users = make(map[int]tgbotapi.User)
bot.Admins = make(map[int]bool)
for _, id := range strings.Split(cfg.Admins, ",") {
i, err := strconv.Atoi(id)
if err != nil {
log.Panic("Admin IDs must be numbers!")
}
bot.Admins[i] = true
}
return tg
}
// GetConfig uses envconfig to populate and return a Config struct. Returns all envconfig errors if they occurred
func GetConfig() (*Config, error) {
conf := new(Config)
if err := envconfig.Process(AppName, conf); err != nil {
return nil, err
}
return conf, nil
}
// Main entry point that starts the messaging bridge, visit service, and web
// server.
func main() {
var s Specification
var port string
// Load environment variables.
if err := envconfig.Process("icra", &s); err != nil {
log.Fatalf("Could not read environment variables: %s", err.Error())
}
if port = os.Getenv("VCAP_APP_PORT"); len(port) == 0 {
log.Printf("Warning, VCAP_APP_PORT not set. Defaulting to %+v\n", s.Port)
port = s.Port
}
// Generate a client identifier.
id := fmt.Sprintf("icra-client-%d", os.Getpid())
// Configure the visit service and messaging bridge.
vs := NewVisitService(s.BufferSize, s.CacheSize)
mb := NewMessagingBridge([]string{s.Topic}, vs)
// Start the visit service.
go vs.Serve()
// Connect to the message broker.
mb.Connect(s.Broker, id)
// Configure the web server.
http.Handle("/ws/browsing", vs.MakeHandler())
http.Handle("/", http.FileServer(http.Dir("static")))
// Launch the web server.
http.ListenAndServe(":"+port, nil)
}
// GetGit gets the Git config using envconfig
func GetGit(appName string) (*Git, error) {
conf := new(Git)
if err := envconfig.Process(appName, conf); err != nil {
return nil, err
}
return conf, nil
}
func consumerServer(cmd *cobra.Command, args []string) {
var config consumerapi.Config
if err := envconfig.Process("CONSUMER", &config); err != nil {
log.Fatal("Error occurred during startup:", err.Error())
}
log.Print(`. . .
_ . . (
(_) . . .
. ____.--^.
. /: / | + . .
/: '--=--' . .
/: __[\=='-.___ * .
/__|\ _~~~~~~ ~~--..__ . .
\ \|::::|-----.....___|~--. .
\ _\_~~~~~-----:|:::______//---...___
. [\ \ __ -- \ ~ \_ ~~~===------==-...____
[============================================================-
/ __/__ -- /__ -- /____....----''''~~~~ .
* / / == ____....=---='''~~~~ .
. /____....--=-''':~~~~ . .
. ~--~
. .
. . .`)
log.Printf("[+] Started Consumer API on: %s:%d, with MaxWokers: %d and MaxJobs: %d\n", config.Interface, config.Port, config.MaxWorker, config.MaxJobQueue)
consumerAPIService := consumerapi.NewService(&config)
if err := consumerAPIService.Start(); err != nil {
log.Fatal("Error occurred during startup:", err.Error())
}
}
func init() {
// Pull in the configuration
err := envconfig.Process("buoy", &Config)
if err != nil {
tracelog.CompletedError(err, helper.MAIN_GO_ROUTINE, "Init")
}
}
func init() {
err := envconfig.Process("HELEN", &Constants)
if err != nil {
logrus.Fatal(err)
}
if Constants.SteamDevAPIKey == "" {
logrus.Warning("Steam api key not provided, setting SteamApiMockUp to true")
}
if Constants.PublicAddress == "" {
Constants.PublicAddress = "http://" + Constants.ListenAddress
}
if Constants.MockupAuth {
logrus.Warning("Mockup authentication enabled.")
}
_, err = url.Parse(Constants.PublicAddress)
if err != nil {
logrus.Fatal("Couldn't parse HELEN_PUBLIC_ADDR - ", err)
}
_, err = url.Parse(Constants.LoginRedirectPath)
if err != nil {
logrus.Fatal("Couldn't parse HELEN_SERVER_REDIRECT_PATH - ", err)
}
if Constants.GeoIP {
logrus.Info("GeoIP support enabled")
}
}
// GetServer gets the Server config using envconfig
func GetServer(appName string) (*Server, error) {
conf := new(Server)
if err := envconfig.Process(appName, conf); err != nil {
return nil, err
}
return conf, nil
}
// Creates and returns a new Manager.
func New() *Manager {
refreshChannel := make(chan string, 10)
quitChannel := make(chan int)
refreshCounter := prometheus.NewCounterVec(prometheus.CounterOpts{
Namespace: "proxym",
Subsystem: "refresh",
Name: "count",
Help: "Number of refreshes triggered",
}, []string{"result"})
prometheus.MustRegister(refreshCounter)
var c Config
envconfig.Process("proxym", &c)
m := &Manager{
Config: &c,
httpRouter: pat.New(),
refresh: refreshChannel,
refreshCounter: refreshCounter,
quit: quitChannel,
}
m.httpRouter.Get("/metrics", prometheus.Handler())
return m
}
func Parse() (*Conf, error) {
appConf := &Conf{}
err := envconfig.Process("bbsgo", appConf)
if err != nil {
panic(err)
}
return appConf, nil
}
func main() {
// Load the configuration.
err := envconfig.Process("elwinar", &configuration)
if err != nil {
log.Fatalln("unable to read the configuration from env:", err)
}
// Open the database connection.
database, err = sqlx.Connect("sqlite3", configuration.Database)
if err != nil {
log.Fatalln("unable to open the database:", err)
}
// Initialize the router.
router := httprouter.New()
// Add the front-office handlers.
router.GET("/", Index)
router.GET("/read", List)
router.GET("/article/:slug", View)
router.GET("/fortune", Fortune)
router.GET("/sitemap.xml", Sitemap)
// Add the back-office handlers.
router.GET("/login", Login)
router.POST("/login", Authenticate)
router.GET("/logout", Logout)
router.GET("/write", Write)
router.POST("/write", Create)
router.GET("/article/:slug/edit", Edit)
router.POST("/article/:slug/edit", Update)
router.GET("/article/:slug/delete", Delete)
router.GET("/article/:slug/publish", Publish)
router.GET("/article/:slug/unpublish", Unpublish)
// Initialize the server middleware stack.
stack := negroni.New()
stack.Use(gzip.Gzip(gzip.DefaultCompression))
stack.Use(negroni.NewRecovery())
stack.Use(negroni.NewStatic(http.Dir(configuration.Public)))
stack.Use(sessions.Sessions("elwinar", cookiestore.New([]byte(configuration.Secret))))
stack.UseHandler(router)
// Initialize the HTTP server.
server := &graceful.Server{
Timeout: 1 * time.Second,
Server: &http.Server{
Addr: fmt.Sprintf(":%d", configuration.Port),
Handler: stack,
},
}
// Run the server.
err = server.ListenAndServe()
if err != nil {
log.Fatalln("unable to run the server:", err)
}
}
// LoadEnv loads all configuration from the environment
func LoadEnv() (*Config, error) {
cfg := &Config{}
err := envconfig.Process("newrelic", cfg)
if err != nil {
return nil, err
}
return cfg, nil
}
func init() {
// set up error logger
errlog = log.New(os.Stderr, "[ERROR]", log.Lshortfile|log.LstdFlags)
// set standard logger to stdout
log.SetOutput(os.Stdout)
err := envconfig.Process("sentinel-manager", &config)
if err != nil {
log.Fatal(err)
}
}
func main() {
log.SetLevel(log.InfoLevel)
var configfile string
flag.StringVar(&configfile, "config", "./broker.json", "Broker JSON config file")
flag.Parse()
file, err := ioutil.ReadFile(configfile)
if err != nil {
log.Fatal("could not read config file: " + err.Error())
}
f := ConfigData{}
err = json.Unmarshal(file, &f)
if err != nil {
log.Fatal("could not parse config file: " + err.Error())
}
var c config
err = envconfig.Process("broker", &c)
if err != nil {
log.Fatal(err.Error())
}
// defaults to INFO
if c.LogLevel == "DEBUG" {
log.SetLevel(log.DebugLevel)
}
if c.LogLevel == "WARN" {
log.SetLevel(log.WarnLevel)
}
if c.LogLevel == "ERROR" {
log.SetLevel(log.ErrorLevel)
}
if c.LogLevel == "FATAL" {
log.SetLevel(log.FatalLevel)
}
pubsocket, _ := zmq.NewSocket(zmq.PUB)
repsocket, _ := zmq.NewSocket(zmq.REP)
defer pubsocket.Close()
defer repsocket.Close()
pubsocket.Bind(f.PubSocket)
repsocket.Bind(f.RepSocket)
log.Info("listening on ZMQ sockets")
var e envelope
for {
msg, _ := repsocket.Recv(0)
json.Unmarshal([]byte(msg), &e)
pubsocket.Send(e.Address, zmq.SNDMORE)
pubsocket.Send(e.Content, 0)
repsocket.Send("published", 0)
log.Debug("published message")
}
}
