Esempio n. 1
0
func main() {
	var opts tunnelproxy.ServerOptions

	mc := multiconfig.New()
	mc.Loader = multiconfig.MultiLoader(
		&multiconfig.TagLoader{},
		&multiconfig.EnvironmentLoader{},
		&multiconfig.EnvironmentLoader{Prefix: "KONFIG_TUNNELSERVER"},
		&multiconfig.FlagLoader{},
	)

	mc.MustLoad(&opts)

	server, err := tunnelproxy.NewServer(&opts)
	if err != nil {
		die(err)
	}

	k, err := tunnelproxy.NewServerKite(server, Name, Version)
	if err != nil {
		die(err)
	}

	k.Run()
}
Esempio n. 2
0
func init() {
	rawCfg := MustAsset("config.json")

	loaders := []multiconfig.Loader{
		&multiconfig.JSONLoader{Reader: bytes.NewReader(rawCfg)},
		&multiconfig.EnvironmentLoader{Prefix: "KONFIG_GOKODING"},
	}

	d := &multiconfig.DefaultLoader{
		Loader:    multiconfig.MultiLoader(loaders...),
		Validator: &multiconfig.RequiredValidator{},
	}

	Builtin = &Config{}

	d.MustLoad(Builtin)
	d.MustValidate(Builtin)

	// set global compile time environment.
	environment = Builtin.Environment

	// Check if routes values are correct.
	for route, host := range Builtin.Routes {
		if host == "" {
			panic("empty host for route: " + route)
		}
	}
}
Esempio n. 3
0
func init() {
	config.Loader = multiconfig.MultiLoader(
		&multiconfig.TagLoader{},
		&multiconfig.EnvironmentLoader{},
		&multiconfig.EnvironmentLoader{Prefix: "KONFIG_KLOUD"},
		&multiconfig.FlagLoader{},
	)

	log.SetFlags(log.LstdFlags | log.Lshortfile)
}
Esempio n. 4
0
func init() {
	var m multiconfig.Loader
	var l multiconfig.Loader
	var found = true
	if _, err := os.Stat(".uplay.toml"); err == nil {
		l = &multiconfig.TOMLLoader{Path: ".uplay.toml"}
	} else if _, err := os.Stat(".uplay.json"); err == nil {
		l = &multiconfig.JSONLoader{Path: ".uplay.json"}
	} else if _, err := os.Stat(fmt.Sprintf("%s/.uplay.toml", os.Getenv("HOME"))); err == nil {
		l = &multiconfig.TOMLLoader{Path: fmt.Sprintf("%s/.uplay.toml", os.Getenv("HOME"))}
	} else if _, err := os.Stat(fmt.Sprintf("%s/.uplay.json", os.Getenv("HOME"))); err == nil {
		l = &multiconfig.JSONLoader{Path: fmt.Sprintf("%s/.uplay.json", os.Getenv("HOME"))}
	} else {
		found = false
	}
	if found {
		m = multiconfig.MultiLoader(l, &multiconfig.FlagLoader{}, &multiconfig.EnvironmentLoader{})
	} else {
		m = multiconfig.MultiLoader(&multiconfig.FlagLoader{}, &multiconfig.EnvironmentLoader{})
	}
	m.Load(config)
}
Esempio n. 5
0
func main() {
	conf := &terraformer.Config{}

	mc := multiconfig.New()
	mc.Loader = multiconfig.MultiLoader(
		&multiconfig.TagLoader{},
		&multiconfig.EnvironmentLoader{},
		&multiconfig.EnvironmentLoader{Prefix: "KONFIG_TERRAFORMER"},
		&multiconfig.FlagLoader{},
	)

	mc.MustLoad(conf)

	if !conf.TerraformDebug {
		// hashicorp.terraform outputs many logs, discard them
		log.SetOutput(ioutil.Discard)
	}

	log := logging.NewCustom(terraformer.Name, conf.Debug)

	// init terraformer
	t, err := terraformer.New(conf, log)
	if err != nil {
		log.Fatal(err.Error())
	}

	k, err := terraformer.NewKite(t, conf)
	if err != nil {
		log.Fatal(err.Error())
	}

	if err := k.RegisterForever(k.RegisterURL(true)); err != nil {
		log.Fatal(err.Error())
	}

	go k.Run()
	<-k.ServerReadyNotify()
	log.Debug("Kite Started Listening")

	// terraformer can only be closed with signals, wait for any signal
	if err := t.Wait(); err != nil {
		log.Error("Err after waiting terraformer %s", err)
	}

	k.Close()
}
Esempio n. 6
0
// ParseFlags uses multiconfig to fill the given v with matching
// flag values read from tags, environment and command line.
func ParseFlags(v interface{}) error {
	type parentFlags interface {
		Underlying() *Flags
	}

	envPrefix := "keygen"

	// Try to read the EnvPrefix from the v, so it is possible
	// to set different flags for different tests when
	// run at once e.g. with:
	//
	//   go test ./...
	//
	switch f := v.(type) {
	case *Flags:
		if f.EnvPrefix != "" {
			envPrefix = f.EnvPrefix
		}
	case parentFlags:
		if f := f.Underlying(); f.EnvPrefix != "" {
			envPrefix = f.EnvPrefix
		}
	}

	args := make([]string, 0) // non-nil to force FlagLoader to not read test flags

	for i, arg := range os.Args {
		if arg == "--" {
			args = os.Args[i+1:]
			break
		}
	}

	mc := multiconfig.New()
	mc.Loader = multiconfig.MultiLoader(
		&multiconfig.TagLoader{},
		&multiconfig.EnvironmentLoader{
			Prefix: strings.ToUpper(envPrefix),
		},
		&multiconfig.FlagLoader{
			Args: args,
		},
	)

	return mc.Load(v)
}
Esempio n. 7
0
func main() {
	c := &Conf{}
	mc := multiconfig.New()
	mc.Loader = multiconfig.MultiLoader(
		&multiconfig.TagLoader{},
		&multiconfig.EnvironmentLoader{},
		&multiconfig.EnvironmentLoader{Prefix: "ASGD"},
		&multiconfig.FlagLoader{},
	)
	mc.MustLoad(c)

	conf := &asgd.Config{
		Name:            c.Name,
		AccessKeyID:     c.AccessKeyID,
		SecretAccessKey: c.SecretAccessKey,
		Region:          c.Region,
		AutoScalingName: c.AutoScalingName,
		Debug:           c.Debug,
	}

	session, err := asgd.Configure(conf)
	if err != nil {
		log.Fatal("Reading config failed: ", err.Error())
	}

	log := logging.NewCustom("asgd", conf.Debug)
	// remove formatting from call stack and output correct line
	log.SetCallDepth(1)

	// create lifecycle
	l := asgd.NewLifeCycle(session, log, conf.AutoScalingName)

	// configure lifecycle with system name
	if err := l.Configure(conf.Name); err != nil {
		log.Fatal(err.Error())
	}

	done := registerSignalHandler(l, log)
	// listen to lifecycle events
	if err := l.Listen(process(c.Execute)); err != nil {
		log.Fatal(err.Error())
	}

	<-done
}
Esempio n. 8
0
func main() {
	conf := &Config{}

	loader := multiconfig.MultiLoader(
		&multiconfig.TagLoader{},  // assign default values
		&multiconfig.FlagLoader{}, // read flag params
		&multiconfig.EnvironmentLoader{},
	)

	if err := loader.Load(conf); err != nil {
		log.Fatalf("config read err: %s", err.Error())
	}

	if err := (&multiconfig.RequiredValidator{}).Validate(conf); err != nil {
		log.Fatalf("validation err: %s", err.Error())
	}

	c := common.NewContext()
	c.Config.Schema = conf.Schema
	c.Config.Target = conf.Target

	s, err := common.Read(c.Config.Schema)
	if err != nil {
		log.Fatalf("schema read err: %s", err.Error())
	}

	s = s.Resolve(s)

	req := &common.Req{
		Schema:  s,
		Context: c,
	}
	res := &common.Res{}
	err = conf.DDL.Generate(req, res)
	if err != nil {
		log.Fatal("geneddl err: %s", err.Error())
	}

	if err := common.WriteOutput(res.Output); err != nil {
		log.Fatal("output write err: %s", err.Error())
	}

	log.Println("module created with success")
}
Esempio n. 9
0
func NewPostgres(conf *PostgresConfig, log kite.Logger) *Postgres {
	if conf == nil {
		conf = new(PostgresConfig)

		envLoader := &multiconfig.EnvironmentLoader{Prefix: "kontrol_postgres"}
		configLoader := multiconfig.MultiLoader(
			&multiconfig.TagLoader{}, envLoader,
		)

		if err := configLoader.Load(conf); err != nil {
			fmt.Println("Valid environment variables are: ")
			envLoader.PrintEnvs(conf)
			panic(err)
		}

		err := multiconfig.MultiValidator(&multiconfig.RequiredValidator{}).Validate(conf)
		if err != nil {
			fmt.Println("Valid environment variables are: ")
			envLoader.PrintEnvs(conf)
			panic(err)
		}
	}

	connString := fmt.Sprintf(
		"host=%s port=%d dbname=%s user=%s password=%s sslmode=disable connect_timeout=%d",
		conf.Host, conf.Port, conf.DBName, conf.Username, conf.Password, conf.ConnectTimeout,
	)

	db, err := sql.Open("postgres", connString)
	if err != nil {
		panic(err)
	}

	p := &Postgres{
		DB:  db,
		Log: log,
	}

	cleanInterval := 120 * time.Second // clean every 120 second
	go p.RunCleaner(cleanInterval, KeyTTL)

	return p
}
Esempio n. 10
0
File: hero.go Progetto: gernest/hero
func getConfig(path string) (*hero.Config, error) {
	if path == "" {
		path = configName
	}
	loader := multiconfig.MultiLoader(
		&multiconfig.TagLoader{},
		&multiconfig.EnvironmentLoader{},
		&multiconfig.JSONLoader{Path: path},
	)
	d := &multiconfig.DefaultLoader{}
	d.Loader = loader
	d.Validator = multiconfig.MultiValidator(&multiconfig.RequiredValidator{})

	cfg := &hero.Config{}

	err := d.Load(cfg)
	if err != nil {
		return nil, err
	}
	return cfg, nil
}
Esempio n. 11
0
func configure() (*tunnelproxymanager.Config, error) {
	c := &tunnelproxymanager.Config{}
	mc := multiconfig.New()
	mc.Loader = multiconfig.MultiLoader(
		&multiconfig.TagLoader{},
		&multiconfig.EnvironmentLoader{},
		&multiconfig.EnvironmentLoader{Prefix: "KONFIG_TUNNELPROXYMANAGER"},
		&multiconfig.FlagLoader{},
	)

	mc.MustLoad(c)

	// decide on eb env name
	ebEnvName, err := getEBEnvName(c)
	if err != nil {
		return nil, err
	}

	c.EBEnvName = ebEnvName
	return c, nil
}
Esempio n. 12
0
func TestMain(m *testing.M) {
	rand.Seed(time.Now().UnixNano() + int64(os.Getpid()))
	argsTesting, argsConfig := splitArgs()
	flag.CommandLine.Parse(argsTesting)

	l := multiconfig.MultiLoader(
		&multiconfig.EnvironmentLoader{
			Prefix: "e2etest",
		},
		&multiconfig.FlagLoader{
			EnvPrefix: "e2etest",
			Args:      argsConfig,
		},
	)

	if err := l.Load(&Test); err != nil {
		die("unable to load configuration", err)
	}

	Test.Log = logging.NewCustom("test", Test.Debug)
	Test.setDefaults()

	if Test.Debug {
		fmt.Printf("e2etest.Test = %s\n", &Test)
	}

	ktrl := NewKontrol()
	ktrl.Start()

	exit := m.Run()

	if !Test.NoClean {
		Test.cleanupRoute53()
	}

	ktrl.Close()

	os.Exit(exit)
}
Esempio n. 13
0
func main() {
	loader := multiconfig.MultiLoader(
		&multiconfig.TagLoader{},
		&multiconfig.EnvironmentLoader{Prefix: "kontrol"},
		&multiconfig.EnvironmentLoader{Prefix: "KONFIG_KONTROL"},
		&multiconfig.FlagLoader{EnvPrefix: "kontrol"},
	)

	conf := new(kontrol.Config)

	// Load the config, it's reads from the file, environment variables and
	// lastly from flags in order
	if err := loader.Load(conf); err != nil {
		panic(err)
	}

	if err := multiconfig.MultiValidator(&multiconfig.RequiredValidator{}).Validate(conf); err != nil {
		panic(err)
	}

	fmt.Printf("Kontrol loaded with following variables: %+v\n", conf)

	k := kontrol.New(conf)

	k.Kite.HandleHTTPFunc("/healthCheck", artifact.HealthCheckHandler(Name))
	k.Kite.HandleHTTPFunc("/version", artifact.VersionHandler())

	if conf.Debug {
		k.Kite.SetLogLevel(kite.DEBUG)
	}

	go func() {
		// Kloud runs on 6060, so we choose 6061 for kontrol
		err := http.ListenAndServe("0.0.0.0:6061", nil)
		k.Kite.Log.Error(err.Error())
	}()

	k.Run()
}
Esempio n. 14
0
// MustRead takes a relative file path
// and tries to open and read it into Config struct
// If file is not there or file is not given, it panics
// If the given file is not formatted well, panics
func MustRead(path string) *Config {
	conf = &Config{}

	loaders := []multiconfig.Loader{}

	if path != "" {
		tomlLoader := &multiconfig.TOMLLoader{Path: path}
		loaders = append(loaders, tomlLoader)
	}

	envLoader := &multiconfig.EnvironmentLoader{Prefix: "KONFIG_SOCIALAPI"}
	loaders = append(loaders, envLoader)

	d := &multiconfig.DefaultLoader{
		Loader: multiconfig.MultiLoader(loaders...),
	}

	if err := d.Load(conf); err != nil {
		panic(err)
	}

	return conf
}
Esempio n. 15
0
func main() {
	conf := &Config{}

	loader := multiconfig.MultiLoader(
		&multiconfig.TagLoader{},  // assign default values
		&multiconfig.FlagLoader{}, // read flag params
		&multiconfig.EnvironmentLoader{},
	)

	if err := loader.Load(conf); err != nil {
		log.Fatalf("config read err: %s", err.Error())
	}

	if err := (&multiconfig.RequiredValidator{}).Validate(conf); err != nil {
		log.Fatalf("validation err: %s", err.Error())
	}

	c := common.NewContext()
	c.Config.Schema = conf.Schema
	c.Config.Target = conf.Target

	s, err := common.Read(conf.Schema)
	if err != nil {
		log.Fatalf("schema read err: %s", err.Error())
	}

	output, err := conf.Struct.Generate(c, s)
	if err != nil {
		log.Fatal("genestruct err: %s", err.Error())
	}

	if err := common.WriteOutput(output); err != nil {
		log.Fatal("output write err: %s", err.Error())
	}

	log.Println("module created with success")
}
Esempio n. 16
0
// Load loads the given config to the rules of images CLI
func Load(conf interface{}, args []string) error {
	configArgs := FilterArgs(conf, args)

	loaders := []multiconfig.Loader{}

	// check for any files
	path, ext, err := discoverConfigPath(DefaultConfigName)
	if err == nil {
		// Choose what while is passed
		switch ext {
		case "json":
			// .imagesrc.json
			loaders = append(loaders, &multiconfig.JSONLoader{Path: path})
		case "toml":
			fallthrough
		default:
			// .imagesrc or .imagesrc.toml
			loaders = append(loaders, &multiconfig.TOMLLoader{Path: path})
		}
	}

	e := &multiconfig.EnvironmentLoader{
		Prefix:    "IMAGES",
		CamelCase: true,
	}
	f := &multiconfig.FlagLoader{
		Args:      configArgs,
		Flatten:   true,
		CamelCase: true,
		EnvPrefix: "IMAGES",
	}
	loaders = append(loaders, e, f)

	l := multiconfig.MultiLoader(loaders...)
	return l.Load(conf)
}
Esempio n. 17
0
func main() {
	conf := &Config{}

	loader := multiconfig.MultiLoader(
		&multiconfig.TagLoader{},  // assign default values
		&multiconfig.FlagLoader{}, // read flag params
	)

	if err := loader.Load(conf); err != nil {
		log.Fatalf("config read err:", err.Error())
	}

	if err := (&multiconfig.RequiredValidator{}).Validate(conf); err != nil {
		log.Fatalf("validation err: %s", err.Error())
	}

	c := common.NewContext()
	c.Config.Schema = conf.Schema
	c.Config.Target = conf.Target
	c.FieldNameFunc = geneddl.GetFieldNameFunc(conf.DDL.FieldNameCase)

	s, err := common.Read(c.Config.Schema)
	if err != nil {
		log.Fatalf("schema read err: %s", err.Error())
	}

	s.Resolve(s)

	//
	// generate sql definitions
	//
	c.Config.Target = conf.Target + "db" + "/"
	output, err := conf.DDL.Generate(c, s)
	if err != nil {
		log.Fatal("geneddl err: %s", err.Error())
	}

	if err := common.WriteOutput(output); err != nil {
		log.Fatal("output write err: %s", err.Error())
	}

	//
	// generate models
	//
	c.Config.Target = conf.Target + "models" + "/"
	output, err = conf.Models.Generate(c, s)
	if err != nil {
		log.Fatalf("err while generating models", err.Error())
	}

	if err := common.WriteOutput(output); err != nil {
		log.Fatal("output write err: %s", err.Error())
	}

	//
	// generate rowsscanner
	//
	c.Config.Target = conf.Target + "models" + "/"
	output, err = conf.Rows.Generate(c, s)
	if err != nil {
		log.Fatalf("err while generating rows", err.Error())
	}

	if err := common.WriteOutput(output); err != nil {
		log.Fatal("output write err: %s", err.Error())
	}

	//
	// generate crud statements
	//
	c.Config.Target = conf.Target + "models" + "/"
	output, err = conf.Statements.Generate(c, s)
	if err != nil {
		log.Fatalf("err while generating crud statements", err.Error())
	}

	if err := common.WriteOutput(output); err != nil {
		log.Fatal("output write err: %s", err.Error())
	}

	//
	// generate errors
	//
	c.Config.Target = conf.Target + "errors" + "/"
	output, err = conf.Errors.Generate(c, s)
	if err != nil {
		log.Fatalf("err while generating errors", err.Error())
	}

	if err := common.WriteOutput(output); err != nil {
		log.Fatal("output write err: %s", err.Error())
	}

	//
	// generate main file
	//
	c.Config.Target = conf.Target + "cmd" + "/"
	output, err = conf.Mainfile.Generate(c, s)
	if err != nil {
		log.Fatalf("err while generating main file", err.Error())
	}

	if err := common.WriteOutput(output); err != nil {
		log.Fatal("output write err: %s", err.Error())
	}

	//
	// generate clients
	//
	c.Config.Target = conf.Target + "workers" + "/"
	output, err = conf.Clients.Generate(c, s)
	if err != nil {
		log.Fatalf("err while generating clients", err.Error())
	}

	if err := common.WriteOutput(output); err != nil {
		log.Fatal("output write err: %s", err.Error())
	}

	//
	// generate exported functions
	//
	c.Config.Target = conf.Target + "workers" + "/"
	output, err = conf.Functions.Generate(c, s)
	if err != nil {
		log.Fatalf("err while generating clients", err.Error())
	}

	if err := common.WriteOutput(output); err != nil {
		log.Fatal("output write err: %s", err.Error())
	}

	log.Println("module created with success")
}