func main() {
if err := cfg.Init(cfg.EnvProvider{Namespace: cfgNamespace}); err != nil {
kit.Println("Unable to initialize configuration")
os.Exit(1)
}
logLevel := func() int {
ll, err := cfg.Int(cfgLoggingLevel)
if err != nil {
return log.NONE
}
return ll
}
log.Init(os.Stderr, logLevel)
cfg := mongo.Config{
Host: cfg.MustString(cfgMongoHost),
AuthDB: cfg.MustString(cfgMongoAuthDB),
DB: cfg.MustString(cfgMongoDB),
User: cfg.MustString(cfgMongoUser),
Password: cfg.MustString(cfgMongoPassword),
}
if err := db.RegMasterSession("startup", cfg.DB, cfg); err != nil {
kit.Println("Unable to initialize MongoDB")
os.Exit(1)
}
kit.AddCommand(
cmdauth.GetCommands(cfg.DB),
cmddb.GetCommands(cfg.DB),
)
kit.Execute()
}
// ExampleDev shows how to use the config package.
func ExampleDev() {
// Set up some basic environment variables.
os.Setenv("DOCK_IP", "40.23.233.10")
os.Setenv("DOCK_PORT", "4044")
os.Setenv("DOCK_INIT_STAMP", time.Date(2009, time.November,
10, 15, 0, 0, 0, time.UTC).UTC().Format(time.UnixDate))
os.Setenv("DOCK_FLAG", "true")
// Init() must be called only once with the given namespace to load.
cfg.Init("DOCK")
// To get the ip.
fmt.Println(cfg.MustString("IP"))
// To get the port number.
fmt.Println(cfg.MustInt("PORT"))
// To get the timestamp.
fmt.Println(cfg.MustTime("INIT_STAMP"))
// To get the flag.
fmt.Println(cfg.MustBool("FLAG"))
// Output:
// 40.23.233.10
// 4044
// 2009-11-10 15:00:00 +0000 UTC
// true
}
// TestNotExists validates the ability to load configuration values
// using the OS-level environment variables and panic when something
// is missing.
func TestNotExists(t *testing.T) {
t.Log("Given the need to panic when environment variables are missing.")
{
os.Setenv("MYAPP_PROC_ID", "322")
os.Setenv("MYAPP_SOCKET", "./tmp/sockets.po")
os.Setenv("MYAPP_PORT", "4034")
os.Setenv("MYAPP_FLAG", "true")
cfg.Init("MYAPP")
t.Log("\tWhen given a namspace key to search for that does NOT exist.")
{
shouldPanic(t, "STAMP", func() {
cfg.MustTime("STAMP")
})
shouldPanic(t, "PID", func() {
cfg.MustInt("PID")
})
shouldPanic(t, "DEST", func() {
cfg.MustString("DEST")
})
shouldPanic(t, "ACTIVE", func() {
cfg.MustBool("ACTIVE")
})
shouldPanic(t, "SOCKET_DSN", func() {
cfg.MustURL("SOCKET_DSN")
})
}
}
}
// Init is called to initialize the application.
func Init(configKey string) {
// Init the configuration system.
if err := cfg.Init(cfg.EnvProvider{Namespace: configKey}); err != nil {
fmt.Println("Error initalizing configuration system", err)
os.Exit(1)
}
// Init the log system.
logLevel := func() int {
ll, err := cfg.Int(cfgLoggingLevel)
if err != nil {
return log.USER
}
return ll
}
log.Init(os.Stderr, logLevel)
// Log all the configuration options
log.User("startup", "Init", "\n\nConfig Settings: %s\n%s\n", configKey, cfg.Log())
// Load user defined custom headers. HEADERS should be key:value,key:value
if hs, err := cfg.String("HEADERS"); err == nil {
hdrs := strings.Split(hs, ",")
for _, hdr := range hdrs {
if kv := strings.Split(hdr, ":"); len(kv) == 2 {
log.User("startup", "Init", "User Headers : %s:%s", kv[0], kv[1])
app.userHeaders[kv[0]] = kv[1]
}
}
}
}
// ExampleDev shows how to use the config package.
func ExampleDev() {
// Init() must be called only once with the given namespace to load.
cfg.Init(cfg.MapProvider{
Map: map[string]string{
"IP": "40.23.233.10",
"PORT": "4044",
"INIT_STAMP": time.Date(2009, time.November,
10, 15, 0, 0, 0, time.UTC).UTC().Format(time.UnixDate),
"FLAG": "on",
},
})
// To get the ip.
fmt.Println(cfg.MustString("IP"))
// To get the port number.
fmt.Println(cfg.MustInt("PORT"))
// To get the timestamp.
fmt.Println(cfg.MustTime("INIT_STAMP"))
// To get the flag.
fmt.Println(cfg.MustBool("FLAG"))
// Output:
// 40.23.233.10
// 4044
// 2009-11-10 15:00:00 +0000 UTC
// true
}
func main() {
// Initialize the configuration
if err := cfg.Init(cfg.EnvProvider{Namespace: "SPONGE"}); err != nil {
sponge.Println("Unable to initialize configuration")
os.Exit(1)
}
// Initialize the logging
logLevel := func() int {
ll, err := cfg.Int(cfgLoggingLevel)
if err != nil {
return log.NONE
}
return ll
}
log.Init(os.Stderr, logLevel, log.Ldefault)
sponge.Println("Using log level", logLevel())
// Add the item commands to the CLI tool.
sponge.AddCommand(
cmditem.GetCommands(),
cmdpattern.GetCommands(),
)
// Execute the command.
sponge.Execute()
}
func init() {
// This is being added to showcase configuration.
os.Setenv("KIT_LOGGING_LEVEL", "1")
os.Setenv("KIT_MIN_ROUTINES", "1")
os.Setenv("KIT_MAX_ROUTINES", "10")
// Init the configuration system.
if err := cfg.Init(cfg.EnvProvider{Namespace: configKey}); err != nil {
fmt.Println("Error initalizing configuration system", err)
os.Exit(1)
}
// Init the log system.
logLevel := func() int {
ll, err := cfg.Int(cfgLoggingLevel)
if err != nil {
return log.USER
}
return ll
}
log.Init(os.Stderr, logLevel)
// Log all the configuration options
log.User("startup", "init", "\n\nConfig Settings: %s\n%s\n", configKey, cfg.Log())
}
// Init initializes the log package.
func Init(cfgKey string) {
cfg.Init(cfg.EnvProvider{Namespace: cfgKey})
logLevel := func() int {
ll, err := cfg.Int("LOGGING_LEVEL")
if err != nil {
return log.USER
}
return ll
}
log.Init(&logdash, logLevel)
}
// Init is called to initialize the application.
func Init(configKey string) {
// Init the configuration system.
if err := cfg.Init(cfg.EnvProvider{Namespace: configKey}); err != nil {
fmt.Println("Error initalizing configuration system", err)
os.Exit(1)
}
// Init the log system.
logLevel := func() int {
ll, err := cfg.Int(cfgLoggingLevel)
if err != nil {
return log.USER
}
return ll
}
log.Init(os.Stderr, logLevel)
// Log all the configuration options
log.User("startup", "Init", "\n\nConfig Settings: %s\n%s\n", configKey, cfg.Log())
// Init MongoDB if configured.
if _, err := cfg.String(cfgMongoHost); err == nil {
app.useMongo = true
cfg := mongo.Config{
Host: cfg.MustString(cfgMongoHost),
AuthDB: cfg.MustString(cfgMongoAuthDB),
DB: cfg.MustString(cfgMongoDB),
User: cfg.MustString(cfgMongoUser),
Password: cfg.MustString(cfgMongoPassword),
}
if err := mongo.Init(cfg); err != nil {
log.Error("startup", "Init", err, "Initializing MongoDB")
os.Exit(1)
}
}
// Load user defined custom headers. HEADERS should be key:value,key:value
if hs, err := cfg.String("HEADERS"); err == nil {
hdrs := strings.Split(hs, ",")
for _, hdr := range hdrs {
if kv := strings.Split(hdr, ":"); len(kv) == 2 {
log.User("startup", "Init", "User Headers : %s:%s", kv[0], kv[1])
app.userHeaders[kv[0]] = kv[1]
}
}
}
}
// Init sets up the configuration and logging systems.
func Init(p cfg.Provider) {
if err := cfg.Init(p); err != nil {
fmt.Println("Error initalizing configuration system", err)
os.Exit(1)
}
// Init the log system.
logLevel := func() int {
ll, err := cfg.Int(cfgLoggingLevel)
if err != nil {
return log.USER
}
return ll
}
log.Init(os.Stderr, logLevel, log.Ldefault)
}
// TestNotExists validates the ability to load configuration values
// using the OS-level environment variables and panic when something
// is missing.
func TestNotExists(t *testing.T) {
t.Log("Given the need to panic when environment variables are missing.")
{
cfg.Init(cfg.MapProvider{
Map: map[string]string{
"PROC_ID": "322",
"SOCKET": "./tmp/sockets.po",
"PORT": "4034",
"FLAG": "on",
},
})
t.Log("\tWhen given a namspace key to search for that does NOT exist.")
{
shouldPanic(t, "STAMP", func() {
cfg.MustTime("STAMP")
})
shouldPanic(t, "PID", func() {
cfg.MustInt("PID")
})
shouldPanic(t, "DEST", func() {
cfg.MustString("DEST")
})
shouldPanic(t, "ACTIVE", func() {
cfg.MustBool("ACTIVE")
})
shouldPanic(t, "SOCKET_DSN", func() {
cfg.MustURL("SOCKET_DSN")
})
}
}
}
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")
}
// Init initializes the log package.
func Init(cfgKey string) {
cfg.Init(cfgKey)
log.Init(&logdash, func() int { return log.DEV })
}
// TestExists validates the ability to load configuration values
// using the OS-level environment variables and read them back.
func TestExists(t *testing.T) {
t.Log("Given the need to read environment variables.")
{
uStr := "postgres://*****:*****@127.0.0.1:8080/postgres?sslmode=disable"
os.Setenv("MYAPP_PROC_ID", "322")
os.Setenv("MYAPP_SOCKET", "./tmp/sockets.po")
os.Setenv("MYAPP_PORT", "4034")
os.Setenv("MYAPP_FLAG", "true")
os.Setenv("MYAPP_DSN", uStr)
cfg.Init("MYAPP")
t.Log("\tWhen given a namspace key to search for that exists.")
{
proc, err := cfg.Int("PROC_ID")
if err != nil {
t.Errorf("\t\t%s Should not return error when valid key %q", failed, "PROC_ID")
} else {
t.Logf("\t\t%s Should not return error when valid key %q", succeed, "PROC_ID")
if proc != 322 {
t.Errorf("\t\t%s Should have key %q with value %d", failed, "PROC_ID", 322)
} else {
t.Logf("\t\t%s Should have key %q with value %d", succeed, "PROC_ID", 322)
}
}
socket, err := cfg.String("SOCKET")
if err != nil {
t.Errorf("\t\t%s Should not return error when valid key %q", failed, "SOCKET")
} else {
t.Logf("\t\t%s Should not return error when valid key %q", succeed, "SOCKET")
if socket != "./tmp/sockets.po" {
t.Errorf("\t\t%s Should have key %q with value %q", failed, "SOCKET", "./tmp/sockets.po")
} else {
t.Logf("\t\t%s Should have key %q with value %q", succeed, "SOCKET", "./tmp/sockets.po")
}
}
port, err := cfg.Int("PORT")
if err != nil {
t.Errorf("\t\t%s Should not return error when valid key %q", failed, "PORT")
} else {
t.Logf("\t\t%s Should not return error when valid key %q", succeed, "PORT")
if port != 4034 {
t.Errorf("\t\t%s Should have key %q with value %d", failed, "PORT", 4034)
} else {
t.Logf("\t\t%s Should have key %q with value %d", succeed, "PORT", 4034)
}
}
flag, err := cfg.Bool("FLAG")
if err != nil {
t.Errorf("\t\t%s Should not return error when valid key %q", failed, "FLAG")
} else {
t.Logf("\t\t%s Should not return error when valid key %q", succeed, "FLAG")
if flag == false {
t.Errorf("\t\t%s Should have key %q with value %v", failed, "FLAG", true)
} else {
t.Logf("\t\t%s Should have key %q with value %v", succeed, "FLAG", true)
}
}
u, err := cfg.URL("DSN")
if err != nil {
t.Errorf("\t\t%s Should not return error when valid key %q", failed, "DSN")
} else {
t.Logf("\t\t%s Should not return error when valid key %q", succeed, "DSN")
if u.String() != uStr {
t.Errorf("\t\t%s Should have key %q with value %v", failed, "DSN", true)
} else {
t.Logf("\t\t%s Should have key %q with value %v", succeed, "DSN", true)
}
}
}
}
}
func main() {
// Initialize the configuration
if err := cfg.Init(cfg.EnvProvider{Namespace: "WIRE"}); err != nil {
wire.Println("Unable to initialize configuration")
os.Exit(1)
}
// Initialize the logging
logLevel := func() int {
ll, err := cfg.Int(cfgLoggingLevel)
if err != nil {
return log.NONE
}
return ll
}
log.Init(os.Stderr, logLevel, log.Ldefault)
wire.Println("Using log level", logLevel())
// Pull options from the config.
var mgoDB *db.DB
var graphDB *cayley.Handle
// Configure MongoDB.
wire.Println("Configuring MongoDB")
mongoURI := cfg.MustURL(cfgMongoURI)
err := db.RegMasterSession("startup", mongoURI.Path, mongoURI.String(), 0)
if err != nil {
wire.Println("Unable to initialize MongoDB")
os.Exit(1)
}
mgoDB, err = db.NewMGO("startup", mongoURI.Path)
if err != nil {
wire.Println("Unable to get MongoDB session")
os.Exit(1)
}
defer mgoDB.CloseMGO("")
// Configure Cayley.
wire.Println("Configuring Cayley")
if err := mgoDB.NewCayley("startup", mongoURI.Path); err != nil {
wire.Println("Unable to get Cayley support")
}
graphDB, err = mgoDB.GraphHandle("startup")
if err != nil {
wire.Println("Unable to get Cayley handle")
os.Exit(1)
}
// Add the graph and view commands to the CLI tool.
wire.AddCommand(
cmdview.GetCommands(mgoDB, graphDB),
)
// Execute the command.
wire.Execute()
}
// TestSets validates the ability to manually set configuration values.
func TestSets(t *testing.T) {
t.Log("Given the need to manually set configuration values.")
{
/*
uStr := "postgres://*****:*****@127.0.0.1:8080/postgres?sslmode=disable"
Map: map[string]string{
"PROC_ID": "322",
"SOCKET": "./tmp/sockets.po",
"PORT": "4034",
"FLAG": "on",
"DSN": uStr,
},
*/
cfg.Init(cfg.MapProvider{
Map: map[string]string{},
})
t.Log("\tWhen setting values.")
{
key := "key1"
strVal := "bill"
cfg.SetString(key, strVal)
retStrVal, err := cfg.String(key)
if err != nil {
t.Errorf("\t\t%s Should find a value for the specified key %q.", failed, key)
} else {
t.Logf("\t\t%s Should find a value for the specified key %q.", success, key)
}
if strVal != retStrVal {
t.Log(strVal)
t.Log(retStrVal)
t.Errorf("\t\t%s Should return the string value %q that was set.", failed, strVal)
} else {
t.Logf("\t\t%s Should return the string value %q that was set.", success, strVal)
}
key = "key2"
intVal := 223
cfg.SetInt(key, intVal)
retIntVal, err := cfg.Int(key)
if err != nil {
t.Errorf("\t\t%s Should find a value for the specified key %q.", failed, key)
} else {
t.Logf("\t\t%s Should find a value for the specified key %q.", success, key)
}
if intVal != retIntVal {
t.Log(intVal)
t.Log(retIntVal)
t.Errorf("\t\t%s Should return the int value %d that was set.", failed, intVal)
} else {
t.Logf("\t\t%s Should return the int value %d that was set.", success, intVal)
}
key = "key3"
timeVal, _ := time.Parse(time.UnixDate, "Mon Oct 27 20:18:15 EST 2016")
cfg.SetTime(key, timeVal)
retTimeVal, err := cfg.Time(key)
if err != nil {
t.Errorf("\t\t%s Should find a value for the specified key %q.", failed, key)
} else {
t.Logf("\t\t%s Should find a value for the specified key %q.", success, key)
}
if timeVal != retTimeVal {
t.Log(timeVal)
t.Log(retTimeVal)
t.Errorf("\t\t%s Should return the time value %q that was set.", failed, timeVal)
} else {
t.Logf("\t\t%s Should return the time value %q that was set.", success, timeVal)
}
key = "key4"
boolVal := true
cfg.SetBool(key, boolVal)
retBoolVal, err := cfg.Bool(key)
if err != nil {
t.Errorf("\t\t%s Should find a value for the specified key %q.", failed, key)
} else {
t.Logf("\t\t%s Should find a value for the specified key %q.", success, key)
}
if boolVal != retBoolVal {
t.Log(boolVal)
t.Log(retBoolVal)
t.Errorf("\t\t%s Should return the bool value \"%v\" that was set.", failed, boolVal)
} else {
t.Logf("\t\t%s Should return the bool value \"%v\" that was set.", success, boolVal)
}
key = "key5"
urlVal, _ := url.Parse("postgres://*****:*****@127.0.0.1:8080/postgres?sslmode=disable")
cfg.SetURL(key, urlVal)
retURLVal, err := cfg.URL(key)
if err != nil {
t.Errorf("\t\t%s Should find a value for the specified key %q.", failed, key)
} else {
t.Logf("\t\t%s Should find a value for the specified key %q.", success, key)
}
if urlVal.String() != retURLVal.String() {
t.Log(urlVal)
t.Log(retURLVal)
t.Errorf("\t\t%s Should return the bool value \"%v\" that was set.", failed, urlVal)
} else {
t.Logf("\t\t%s Should return the bool value \"%v\" that was set.", success, urlVal)
}
}
}
}