func newConfig() *Conf {
c := new(Conf)
c.ldapViper = viper.New()
c.ldapConfig = &LdapConfig{}
c.notificationConfigs = []NotificationServiceConfig{}
viper.SetConfigName("indispenso")
viper.SetEnvPrefix("ind")
// Defaults
viper.SetDefault("Token", "")
viper.SetDefault("Hostname", getDefaultHostName())
viper.SetDefault("UseAutoTag", true)
viper.SetDefault("ServerEnabled", false)
viper.SetDefault("Home", defaultHomePath)
viper.SetDefault("Debug", false)
viper.SetDefault("ServerPort", 897)
viper.SetDefault("EndpointURI", "")
viper.SetDefault("SslCertFile", "cert.pem")
viper.SetDefault("SslPrivateKeyFile", "key.pem")
viper.SetDefault("AutoGenerateCert", true)
viper.SetDefault("ClientPort", 898)
viper.SetDefault("EnableLdap", false)
viper.SetDefault("LdapConfigFile", "")
//Flags
c.confFlags = pflag.NewFlagSet(os.Args[0], pflag.ExitOnError)
configFile := c.confFlags.StringP("config", "c", "", "Config file location default is /etc/indispenso/indispenso.{json,toml,yaml,yml,properties,props,prop}")
c.confFlags.BoolP("serverEnabled", "s", false, "Define if server module should be started or not")
c.confFlags.BoolP("debug", "d", false, "Enable debug mode")
c.confFlags.StringP("home", "p", defaultHomePath, "Home directory where all config files are located")
c.confFlags.StringP("endpointUri", "e", "", "URI of server interface, used by client")
c.confFlags.StringP("token", "t", "", "Secret token")
c.confFlags.StringP("hostname", "i", getDefaultHostName(), "Hostname that is use to identify itself")
c.confFlags.BoolP("enableLdap", "l", false, "Enable LDAP authentication")
c.confFlags.BoolP("help", "h", false, "Print help message")
c.confFlags.Parse(os.Args[1:])
if len(*configFile) > 2 {
viper.SetConfigFile(*configFile)
} else {
legacyConfigFile := "/etc/indispenso/indispenso.conf"
if _, err := os.Stat(legacyConfigFile); err == nil {
viper.SetConfigFile(legacyConfigFile)
viper.SetConfigType("yaml")
}
}
viper.BindPFlags(c.confFlags)
viper.AutomaticEnv()
viper.ReadInConfig()
c.setupHome(nil, viper.GetString("Home"))
c.setupHome(c.ldapViper, viper.GetString("Home"))
c.SetupNotificationConfig("slack", &SlackNotifyConfig{})
c.Update()
return c
}
func init() {
//Begin cobra configuration
RootCommand.PersistentFlags().StringVarP(&server, "server", "s", "localhost", "Server to connect to, separate multiple servers with a \",\"")
RootCommand.PersistentFlags().StringVarP(&keyspace, "keyspace", "k", "cassfs", "Keyspace to use for cassandra")
RootCommand.PersistentFlags().StringVar(&statedir, "statedir", "/var/run/cassfs", "Directory to use for state")
RootCommand.PersistentFlags().IntVarP(&owner, "owner", "o", 1, "Owner ID")
RootCommand.PersistentFlags().StringVarP(&environment, "environment", "e", "production", "Environment to mount")
RootCommand.PersistentFlags().Bool("debug", false, "Enable debugging")
//Begin viper configuration
viper.SetEnvPrefix("CASSFS")
viper.AutomaticEnv()
//End viper configuration
//Read from a config file
viper.SetConfigName("cassfs")
viper.SetConfigType("yaml")
viper.AddConfigPath("/etc/cassfs")
viper.AddConfigPath("$HOME/.cassfs")
viper.AddConfigPath(".")
//Begin viper/cobra integration
viper.BindPFlag("server", RootCommand.PersistentFlags().Lookup("server"))
viper.BindPFlag("statedir", RootCommand.PersistentFlags().Lookup("statedir"))
viper.BindPFlag("keyspace", RootCommand.PersistentFlags().Lookup("keyspace"))
viper.BindPFlag("owner", RootCommand.PersistentFlags().Lookup("owner"))
viper.BindPFlag("environment", RootCommand.PersistentFlags().Lookup("environment"))
viper.BindPFlag("debug", RootCommand.PersistentFlags().Lookup("debug"))
}
func main() {
viper.SetEnvPrefix("SENSOR")
viper.SetDefault("listen_address", ss.DefaultPubWSAddr)
viper.SetDefault("temperature_address", "localhost"+ss.DefaultTempWSAddr)
viper.SetDefault("radiation_address", "localhost"+ss.DefaultRadWSAddr)
viper.SetDefault("aggregator_address", "localhost"+ss.DefaultAggWSAddr)
viper.AutomaticEnv()
reading := &types.SensorSuiteReading{}
sensorExit := make(chan bool)
go sensorUpdateRoutine(reading, sensorExit)
publishExit := make(chan bool)
go publishData(reading, publishExit)
for {
select {
case <-sensorExit:
log.Fatal("Unable to connect to one or more sensors")
case <-publishExit:
log.Fatal("Unrecoverable error writing to aggregator")
}
}
}
// Start entry point for chaincodes bootstrap.
func Start(cc Chaincode) error {
viper.SetEnvPrefix("CORE")
viper.AutomaticEnv()
replacer := strings.NewReplacer(".", "_")
viper.SetEnvKeyReplacer(replacer)
flag.StringVar(&peerAddress, "peer.address", "", "peer address")
flag.Parse()
chaincodeLogger.Debug("Peer address: %s", getPeerAddress())
// Establish connection with validating peer
clientConn, err := newPeerClientConnection()
if err != nil {
chaincodeLogger.Error(fmt.Sprintf("Error trying to connect to local peer: %s", err))
return fmt.Errorf("Error trying to connect to local peer: %s", err)
}
chaincodeLogger.Debug("os.Args returns: %s", os.Args)
chaincodeSupportClient := pb.NewChaincodeSupportClient(clientConn)
// Establish stream with validating peer
stream, err := chaincodeSupportClient.Register(context.Background())
if err != nil {
return fmt.Errorf("Error chatting with leader at address=%s: %s", getPeerAddress(), err)
}
chaincodename := viper.GetString("chaincode.id.name")
err = chatWithPeer(chaincodename, stream, cc)
return err
}
func init() {
viper.SetEnvPrefix("vk")
viper.BindEnv("token")
viper.BindEnv("id")
viper.BindEnv("mongo")
viper.BindEnv("db")
}
func InitConfig() {
viper.SetConfigName("scds")
viper.SetConfigType("yaml")
viper.SetEnvPrefix("scds")
viper.AutomaticEnv()
// Replaces underscores with periods when mapping environment variables.
viper.SetEnvKeyReplacer(strings.NewReplacer(".", "_"))
// Set non-zero defaults. Nested options take a lower precedence than
// dot-delimited ones, so namespaced options are defined here as maps.
viper.SetDefault("mongo", map[string]interface{}{
"uri": "localhost/scds",
})
viper.SetDefault("http", map[string]interface{}{
"host": "localhost",
"port": 5000,
})
viper.SetDefault("smtp", map[string]interface{}{
"host": "localhost",
"port": 25,
})
// Read the default config file from the working directory.
dir, err := os.Getwd()
if err != nil {
log.Fatal(err)
}
viper.AddConfigPath(dir)
}
func init() {
// default values
// If no config is found, use the default(s)
viper.SetDefault("port", 80)
viper.SetDefault("crate_rest_api", "")
viper.SetDefault("crate", false)
// environment variable
viper.SetEnvPrefix("fci") // will be uppercased automatically
viper.BindEnv("port")
viper.BindEnv("crate")
viper.BindEnv("crate_rest_api")
// config file
viper.AddConfigPath("./")
viper.SetConfigName("config")
err := viper.ReadInConfig()
// check if configfile is available
if err != nil {
fmt.Println("No configuration file loaded")
// os.Exit(1)
}
}
func processVars() {
flag.String("targetDirs", "", "Local directories to back up.")
flag.String("s3Host", "", "S3 host.")
flag.String("s3AccessKey", "", "S3 access key.")
flag.String("s3SecretKey", "", "S3 secret key.")
flag.String("s3BucketName", "", "S3 Bucket Name.")
flag.Int("remoteWorkerCount", 5, "Number of workers performing actions against S3 host.")
flag.Bool("dryRun", false, "Flag to indicate that this should be a dry run.")
flag.Parse()
viper.BindPFlag("targetDirs", flag.CommandLine.Lookup("targetDirs"))
viper.BindPFlag("s3Host", flag.CommandLine.Lookup("s3Host"))
viper.BindPFlag("s3AccessKey", flag.CommandLine.Lookup("s3AccessKey"))
viper.BindPFlag("s3SecretKey", flag.CommandLine.Lookup("s3SecretKey"))
viper.BindPFlag("s3BucketName", flag.CommandLine.Lookup("s3BucketName"))
viper.BindPFlag("remoteWorkerCount", flag.CommandLine.Lookup("remoteWorkerCount"))
viper.BindPFlag("dryRun", flag.CommandLine.Lookup("dryRun"))
viper.AutomaticEnv()
viper.SetEnvPrefix("PERSONAL_BACKUP")
viper.BindEnv("targetDirs")
viper.BindEnv("s3Host")
viper.BindEnv("s3AccessKey")
viper.BindEnv("s3SecretKey")
viper.BindEnv("s3BucketName")
viper.BindEnv("remoteWorkerCount")
viper.SetDefault("remoteWorkerCount", 5)
}
// Start entry point for chaincodes bootstrap.
func Start(cc Chaincode) error {
viper.SetEnvPrefix("OPENCHAIN")
viper.AutomaticEnv()
replacer := strings.NewReplacer(".", "_")
viper.SetEnvKeyReplacer(replacer)
/*
viper.SetConfigName("openchain") // name of config file (without extension)
viper.AddConfigPath("./../../../") // path to look for the config file in
err := viper.ReadInConfig() // Find and read the config file
if err != nil { // Handle errors reading the config file
panic(fmt.Errorf("Fatal error config file: %s \n", err))
}
*/
fmt.Printf("peer.address: %s\n", getPeerAddress())
// Establish connection with validating peer
clientConn, err := newPeerClientConnection()
if err != nil {
return fmt.Errorf("Error trying to connect to local peer: %s", err)
}
fmt.Printf("os.Args returns: %s\n", os.Args)
chaincodeSupportClient := pb.NewChaincodeSupportClient(clientConn)
//err = c.Run(chaincodeSupportClient)
//if err != nil {
//}
// Handle message exchange with validating peer
err = chatWithPeer(chaincodeSupportClient, cc)
return err
}
func main() {
viper.SetEnvPrefix("SENSOR")
viper.SetDefault("listen_address", ss.DefaultFlareWSAddr)
viper.AutomaticEnv()
rand.Seed(time.Now().UTC().UnixNano())
reading := &types.FlareReading{
SolarFlare: ss.InitSolarFlare,
}
go solarFlareRoutine(reading)
addr := viper.GetString("listen_address")
blaster := wsblaster.GetBlaster(&addr, false)
go blaster.Run()
ticker := time.NewTicker(1 * time.Second)
for {
select {
case <-ticker.C:
reading.RLock()
m, _ := json.Marshal(reading)
reading.RUnlock()
blaster.Write(m)
}
}
}
// Start entry point for chaincodes bootstrap.
func Start(cc Chaincode) error {
viper.SetEnvPrefix("OPENCHAIN")
viper.AutomaticEnv()
replacer := strings.NewReplacer(".", "_")
viper.SetEnvKeyReplacer(replacer)
flag.StringVar(&peerAddress, "peer.address", "", "peer address")
flag.Parse()
chaincodeLogger.Debug("Peer address: %s", getPeerAddress())
// Establish connection with validating peer
clientConn, err := newPeerClientConnection()
if err != nil {
chaincodeLogger.Error(fmt.Sprintf("Error trying to connect to local peer: %s", err))
return fmt.Errorf("Error trying to connect to local peer: %s", err)
}
chaincodeLogger.Debug("os.Args returns: %s", os.Args)
chaincodeSupportClient := pb.NewChaincodeSupportClient(clientConn)
err = chatWithPeer(chaincodeSupportClient, cc)
return err
}
func main() {
viper.SetEnvPrefix("SENSOR")
viper.SetDefault("listen_address", ss.DefaultRadWSAddr)
viper.SetDefault("flare_address", "localhost"+ss.DefaultFlareWSAddr)
viper.AutomaticEnv()
rand.Seed(time.Now().UTC().UnixNano())
reading := &types.RadiationReading{
Radiation: ss.InitRadiation,
}
flareExit := make(chan bool)
flareAddr := viper.GetString("flare_address")
go types.FlareUpdateRoutine(reading, &flareAddr, flareExit)
go radiationRoutine(reading)
addr := viper.GetString("listen_address")
blaster := wsblaster.GetBlaster(&addr, false)
go blaster.Run()
ticker := time.NewTicker(1 * time.Second)
for {
select {
case <-ticker.C:
reading.RLock()
m, _ := json.Marshal(reading)
reading.RUnlock()
blaster.Write(m)
case <-flareExit:
log.Fatal("Unable to connect to Solar Flare source")
}
}
}
// LoadGlobalConfig loads Hugo configuration into the global Viper.
func LoadGlobalConfig(relativeSourcePath, configFilename string) error {
if relativeSourcePath == "" {
relativeSourcePath = "."
}
viper.AutomaticEnv()
viper.SetEnvPrefix("hugo")
viper.SetConfigFile(configFilename)
// See https://github.com/spf13/viper/issues/73#issuecomment-126970794
if relativeSourcePath == "" {
viper.AddConfigPath(".")
} else {
viper.AddConfigPath(relativeSourcePath)
}
err := viper.ReadInConfig()
if err != nil {
if _, ok := err.(viper.ConfigParseError); ok {
return err
}
return fmt.Errorf("Unable to locate Config file. Perhaps you need to create a new site.\n Run `hugo help new` for details. (%s)\n", err)
}
viper.RegisterAlias("indexes", "taxonomies")
loadDefaultSettings()
return nil
}
// Setup sets up defaults for viper configuration options and
// overrides these values with the values from the given configuration file
// if it is not empty. Those values again are overwritten by environment
// variables.
func Setup(configFilePath string) error {
viper.Reset()
// Expect environment variables to be prefix with "ALMIGHTY_".
viper.SetEnvPrefix("ALMIGHTY")
// Automatically map environment variables to viper values
viper.AutomaticEnv()
// To override nested variables through environment variables, we
// need to make sure that we don't have to use dots (".") inside the
// environment variable names.
// To override foo.bar you need to set ALM_FOO_BAR
viper.SetEnvKeyReplacer(strings.NewReplacer(".", "_"))
viper.SetTypeByDefaultValue(true)
setConfigDefaults()
// Read the config
// Explicitly specify which file to load config from
if configFilePath != "" {
viper.SetConfigFile(configFilePath)
viper.SetConfigType("yaml")
err := viper.ReadInConfig() // Find and read the config file
if err != nil { // Handle errors reading the config file
return fmt.Errorf("Fatal error config file: %s \n", err)
}
}
return nil
}
func configInit() {
viper.SetEnvPrefix("srb")
var configPath string
flag.StringVar(&configPath, "config", "", "Path of configuration file without name (name must be config.yml)")
flag.Parse()
if len(configPath) > 0 {
viper.AddConfigPath(configPath)
}
configPath = os.Getenv("SRB_CONFIG")
if len(configPath) > 0 {
viper.AddConfigPath(configPath)
}
viper.AddConfigPath("/etc/slack-redmine-bot/")
viper.AddConfigPath(".")
viper.SetConfigName("config")
viper.SetConfigType("yaml")
err := viper.ReadInConfig()
if err != nil {
panic(fmt.Errorf("Error in config file. %s \n", err))
}
}
func main() {
mainCmd.AddCommand(versionCmd)
mainCmd.AddCommand(generateCmd)
mainCmd.AddCommand(transactCmd)
mainCmd.AddCommand(logCmd)
mainCmd.AddCommand(httpCmd)
mainCmd.AddCommand(domainsCmd)
viper.SetEnvPrefix("ORIGINS")
viper.AutomaticEnv()
// Default locations for the origins config file.
viper.SetConfigName("origins")
// Directory the program is being called from
dir, err := filepath.Abs(filepath.Dir(os.Args[0]))
if err == nil {
viper.AddConfigPath(dir)
}
flags := mainCmd.PersistentFlags()
flags.String("log", "info", "Level of log messages to emit. Choices are: debug, info, warn, error, fatal, panic.")
flags.String("config", "", "Path to config file. Defaults to a origins.{json,yml,yaml} in the current working directory.")
viper.BindPFlag("log", flags.Lookup("log"))
viper.BindPFlag("config", flags.Lookup("config"))
// If the target subcommand is generate, remove the generator
// arguments to prevent flag parsing errors.
args := parseGenerateArgs(os.Args[1:])
// Set explicit arguments and parse the flags to setup
// the config file and logging.
mainCmd.SetArgs(args)
mainCmd.ParseFlags(args)
config := viper.GetString("config")
if config != "" {
viper.SetConfigFile(config)
}
// Read configuration file if present.
viper.ReadInConfig()
// Turn on debugging for all commands.
level, err := logrus.ParseLevel(viper.GetString("log"))
if err != nil {
fmt.Println("Invalid log level choice.")
mainCmd.Help()
}
logrus.SetLevel(level)
mainCmd.Execute()
}
func setupViper() {
viper.SetEnvPrefix(constants.MiniShiftEnvPrefix)
viper.AutomaticEnv()
viper.SetDefault(config.WantUpdateNotification, true)
viper.SetDefault(config.ReminderWaitPeriodInHours, 24)
setFlagsUsingViper()
}
func init() {
viper.SetConfigName("dkron") // name of config file (without extension)
viper.AddConfigPath("/etc/dkron") // call multiple times to add many search paths
viper.AddConfigPath("$HOME/.dkron") // call multiple times to add many search paths
viper.AddConfigPath("./config") // call multiple times to add many search paths
viper.SetEnvPrefix("dkron") // will be uppercased automatically
viper.AutomaticEnv()
}
func readConfig() {
viper.SetEnvPrefix("chat")
viper.SetDefault("database_url", "postgres:///chat_development?sslmode=disable")
viper.SetDefault("bind_address", "localhost:8080")
viper.AutomaticEnv()
viper.BindEnv("database_url")
viper.BindEnv("bind_address")
}
func main() {
// For environment variables.
viper.SetEnvPrefix(cmdRoot)
viper.AutomaticEnv()
replacer := strings.NewReplacer(".", "_")
viper.SetEnvKeyReplacer(replacer)
// Define command-line flags that are valid for all peer commands and
// subcommands.
mainFlags := mainCmd.PersistentFlags()
mainFlags.BoolVarP(&versionFlag, "version", "v", false, "Display current version of fabric peer server")
mainFlags.String("logging-level", "", "Default logging level and overrides, see core.yaml for full syntax")
viper.BindPFlag("logging_level", mainFlags.Lookup("logging-level"))
testCoverProfile := ""
mainFlags.StringVarP(&testCoverProfile, "test.coverprofile", "", "coverage.cov", "Done")
var alternativeCfgPath = os.Getenv("PEER_CFG_PATH")
if alternativeCfgPath != "" {
logger.Infof("User defined config file path: %s", alternativeCfgPath)
viper.AddConfigPath(alternativeCfgPath) // Path to look for the config file in
} else {
viper.AddConfigPath("./") // Path to look for the config file in
// Path to look for the config file in based on GOPATH
gopath := os.Getenv("GOPATH")
for _, p := range filepath.SplitList(gopath) {
peerpath := filepath.Join(p, "src/github.com/hyperledger/fabric/peer")
viper.AddConfigPath(peerpath)
}
}
// Now set the configuration file.
viper.SetConfigName(cmdRoot) // Name of config file (without extension)
err := viper.ReadInConfig() // Find and read the config file
if err != nil { // Handle errors reading the config file
panic(fmt.Errorf("Fatal error when reading %s config file: %s\n", cmdRoot, err))
}
mainCmd.AddCommand(version.Cmd())
mainCmd.AddCommand(node.Cmd())
mainCmd.AddCommand(network.Cmd())
mainCmd.AddCommand(chaincode.Cmd())
runtime.GOMAXPROCS(viper.GetInt("peer.gomaxprocs"))
// Init the crypto layer
if err := crypto.Init(); err != nil {
panic(fmt.Errorf("Failed to initialize the crypto layer: %s", err))
}
// On failure Cobra prints the usage message and error string, so we only
// need to exit with a non-0 status
if mainCmd.Execute() != nil {
os.Exit(1)
}
logger.Info("Exiting.....")
}
func init() {
envReplacer = strings.NewReplacer(".", "_")
// Configure Viper to search for all configurations
// in the system environment variables
viper.SetEnvPrefix(envPrefix)
viper.AutomaticEnv()
viper.SetEnvKeyReplacer(envReplacer)
}
func init() {
viper.SetDefault("docroot", "/srv/docroot")
viper.SetEnvPrefix("wodby")
viper.BindEnv("app_type")
viper.BindEnv("app_version")
viper.BindEnv("environment_type")
viper.BindEnv("environment_name")
viper.BindEnv("namespace")
}
func initConfig() {
if cfgFile != "" {
viper.SetConfigFile(cfgFile)
}
viper.SetConfigName(".sman")
viper.AddConfigPath("$HOME")
viper.AutomaticEnv()
viper.SetEnvPrefix("sman")
_ = viper.ReadInConfig()
}
func setupViper() {
viper.SetEnvPrefix(constants.MinikubeEnvPrefix)
// Replaces '-' in flags with '_' in env variables
// e.g. show-libmachine-logs => $ENVPREFIX_SHOW_LIBMACHINE_LOGS
viper.SetEnvKeyReplacer(strings.NewReplacer("-", "_"))
viper.AutomaticEnv()
viper.SetDefault(config.WantUpdateNotification, true)
viper.SetDefault(config.ReminderWaitPeriodInHours, 24)
setFlagsUsingViper()
}
// SetupCoreYAMLConfig sets up configurations for testing
func SetupCoreYAMLConfig(coreYamlPath string) {
viper.SetConfigName("core")
viper.SetEnvPrefix("CORE")
viper.AddConfigPath(coreYamlPath)
viper.SetEnvKeyReplacer(strings.NewReplacer(".", "_"))
viper.AutomaticEnv()
err := viper.ReadInConfig()
if err != nil { // Handle errors reading the config file
panic(fmt.Errorf("Fatal error config file: %s \n", err))
}
}
func init() {
viper.SetEnvPrefix("pdfgen")
viper.BindEnv("port")
viper.SetDefault("port", "8888")
viper.BindEnv("addr")
viper.SetDefault("addr", "0.0.0.0")
viper.BindEnv("templates")
viper.SetDefault("templates", "./templates")
}
func init() {
// set default log level to Error
viper.SetDefault("logging", map[string]interface{}{"level": 2})
viper.SetEnvPrefix(_EnvPrefix)
viper.BindEnv(_DefaultAliasEnv)
viper.BindEnv(_PINCode)
// Setup flags
flag.StringVar(&configFile, "config", "", "Path to configuration file")
flag.BoolVar(&debug, "debug", false, "show the version and exit")
}
func init() {
viper.SetEnvPrefix("snake")
viper.BindEnv("target")
viper.SetConfigName("config")
viper.AddConfigPath("/etc/snake/")
viper.AddConfigPath("$HOME/.snake")
viper.AddConfigPath(".")
err := viper.ReadInConfig() // Find and read the config file
if err != nil { // Handle errors reading the config file
panic(fmt.Errorf("Fatal error config file: %s \n", err))
}
}
// InitializeConfig prepares the flag environment
func InitializeConfig(subCmdVs ...*cobra.Command) error {
viper.AutomaticEnv()
viper.SetEnvPrefix("dgabloom")
loadDefaultSettings()
if databasePath != "" {
viper.Set("DatabasePath", os.ExpandEnv(databasePath))
}
return nil
}
func init() {
// set default log level to Error
viper.SetDefault("logging", map[string]interface{}{"level": 2})
viper.SetEnvPrefix(envPrefix)
viper.SetEnvKeyReplacer(strings.NewReplacer(".", "_"))
viper.AutomaticEnv()
// Setup flags
flag.StringVar(&configFile, "config", "", "Path to configuration file")
flag.BoolVar(&debug, "debug", false, "show the version and exit")
}