Beispiel #1
0
func loadConfig() API {
	log.Debug("server.config::loadConfig")
	var api API
	var plugins map[string]map[string]interface{}
	if err := viper.ReadInConfig(); err != nil {
		log.Fatal("Failed loading server.json ", err)
	}
	if err := viper.MarshalKey("api", &api); err != nil {
		log.Fatal("Malformed api section in server.json ", err)
	}
	if err := viper.MarshalKey("plugins", &plugins); err != nil {
		log.Fatal("Malformed plugins section in server.json ", err)
	}
	api.plugins = plugins
	return api
}
Beispiel #2
0
func main() {
	viper.SetDefault("ConfigFile", "$HOME/.krb.jira.json")
	viper.SetConfigName(".krb.jira")
	viper.SetConfigType("json")
	//viper.AddConfigPath("$HOME")
	viper.AddConfigPath(".")
	viper.ReadInConfig()

	fmt.Printf("host:%s\n", viper.GetString("host"))
	fmt.Printf("port:%d\n", viper.GetInt("port"))
	fmt.Printf("user:%s\n", viper.GetString("user"))
	fmt.Printf("pass:%s\n", viper.GetString("pass"))

	apiInfo := &JiraApiInfo{}
	viper.MarshalKey("apiInfo", &apiInfo)
	fmt.Printf("apiInfo:%q\n", apiInfo)

	// NB: marshaling this whole struct doesn't seem to work?
	/*
		config := &ConfigInfo{}
		err := viper.Marshal(&config)
		if err != nil {
			panic(err)
		}
		fmt.Printf("config:%q\n", config)
	*/
}
Beispiel #3
0
func (cfg *viperProvider) initLogging() {
	var C logger.LoggerConfig
	err := viper.MarshalKey("logger", &C)
	if err != nil {
		panic(fmt.Errorf("Can't parse: %s \n", err))
	}

	logger.InitLog(C)

	cfg.log = logger.Log("config")
}
Beispiel #4
0
func getGlobalProject(v *viper.Viper) (*libcentrifugo.Project, bool) {
	p := &libcentrifugo.Project{}

	// TODO: the same as for structureFromConfig function
	if v == nil {
		if !viper.IsSet("project_name") || viper.GetString("project_name") == "" {
			return nil, false
		}
		p.Name = libcentrifugo.ProjectKey(viper.GetString("project_name"))
		p.Secret = viper.GetString("project_secret")
		p.ConnLifetime = int64(viper.GetInt("project_connection_lifetime"))
		p.Anonymous = viper.GetBool("project_anonymous")
		p.Watch = viper.GetBool("project_watch")
		p.Publish = viper.GetBool("project_publish")
		p.JoinLeave = viper.GetBool("project_join_leave")
		p.Presence = viper.GetBool("project_presence")
		p.HistorySize = int64(viper.GetInt("project_history_size"))
		p.HistoryLifetime = int64(viper.GetInt("project_history_lifetime"))
	} else {
		if !v.IsSet("project_name") || v.GetString("project_name") == "" {
			return nil, false
		}
		p.Name = libcentrifugo.ProjectKey(v.GetString("project_name"))
		p.Secret = v.GetString("project_secret")
		p.ConnLifetime = int64(v.GetInt("project_connection_lifetime"))
		p.Anonymous = v.GetBool("project_anonymous")
		p.Watch = v.GetBool("project_watch")
		p.Publish = v.GetBool("project_publish")
		p.JoinLeave = v.GetBool("project_join_leave")
		p.Presence = v.GetBool("project_presence")
		p.HistorySize = int64(v.GetInt("project_history_size"))
		p.HistoryLifetime = int64(v.GetInt("project_history_lifetime"))
	}

	var nl []libcentrifugo.Namespace
	if v == nil {
		viper.MarshalKey("project_namespaces", &nl)
	} else {
		v.MarshalKey("project_namespaces", &nl)
	}
	p.Namespaces = nl

	return p, true
}
Beispiel #5
0
func (cfg *viperProvider) initValues() {
	cfg.configValues = make(map[string]interface{})
	for _, key := range viper.AllKeys() {
		configType, present := cfg.configTypes[key]
		if !present {
			continue
		}

		config := reflect.New(configType).Interface()
		err := viper.MarshalKey(key, config)
		if err != nil {
			cfg.log.Fatalf("Can't parse section %s, got: %v", key, err)
		}

		cfg.substituteEnvVars(config)

		cfg.configValues[key] = config
	}
}
Beispiel #6
0
func structureFromConfig(v *viper.Viper) *libcentrifugo.Structure {
	// TODO: as viper does not have exported global config instance
	// we need to use nil when application wants to use global viper
	// config - this must be improved using our own global viper instance

	var pl []libcentrifugo.Project

	if v == nil {
		viper.MarshalKey("projects", &pl)
	} else {
		v.MarshalKey("projects", &pl)
	}

	// top level project configuration
	p, exists := getGlobalProject(v)
	if exists {
		// add global project to project list
		pl = append([]libcentrifugo.Project{*p}, pl...)
	}

	s := libcentrifugo.NewStructure(pl)

	return s
}