bottin-ag/config/config.go

/*
Package config provides types and methods for managing this application's
config options and flags
*/
package config

import (
	"github.com/spf13/cobra"
	"github.com/spf13/viper"
)

type Config struct {
	API    APIConfig
	Bottin BottinConfig
	DB     DBConfig
	Web    WebConfig
}

type APIConfig struct {
	Key  string
	Port int
}

type BottinConfig struct {
	API struct {
		Host     string
		Key      string
		Port     int
		Protocol string
	}
}

type DBConfig struct {
	Database string
	Host     string
	Password string
	Port     int
	User     string
	UseSSL   bool `mapstructure:"use_ssl"`
}

type WebConfig struct {
	API struct {
		Host     string
		Key      string
		Port     int
		Protocol string
	}
	Password string
	Port     int
	User     string
}

func UnmarshalConfig() (cfg Config, err error) {
	return cfg, viper.Unmarshal(&cfg)
}

// RegisterBool registers a new cobra bool flag and associated viper config option
func RegisterBool(cmd *cobra.Command, isPersistent bool, viperName, cobraName, cobraDescription string, cobraDefault bool) error {
	if isPersistent {
		cmd.PersistentFlags().Bool(cobraName, cobraDefault, cobraDescription)
		return viper.BindPFlag(viperName, cmd.PersistentFlags().Lookup(cobraName))
	} else {
		cmd.Flags().Bool(cobraName, cobraDefault, cobraDescription)
		return viper.BindPFlag(viperName, cmd.Flags().Lookup(cobraName))
	}
}

// RegisterInt registers a new cobra int flag and associated viper config option
func RegisterInt(cmd *cobra.Command, isPersistent bool, viperName, cobraName, cobraDescription string, cobraDefault int) error {
	if isPersistent {
		cmd.PersistentFlags().Int(cobraName, cobraDefault, cobraDescription)
		return viper.BindPFlag(viperName, cmd.PersistentFlags().Lookup(cobraName))
	} else {
		cmd.Flags().Int(cobraName, cobraDefault, cobraDescription)
		return viper.BindPFlag(viperName, cmd.Flags().Lookup(cobraName))
	}
}

// RegisterString registers a new cobra string flag and associated viper config option
func RegisterString(cmd *cobra.Command, isPersistent bool, viperName, cobraName, cobraDescription string, cobraDefault string) error {
	if isPersistent {
		cmd.PersistentFlags().String(cobraName, cobraDefault, cobraDescription)
		return viper.BindPFlag(viperName, cmd.PersistentFlags().Lookup(cobraName))
	} else {
		cmd.Flags().String(cobraName, cobraDefault, cobraDescription)
		return viper.BindPFlag(viperName, cmd.Flags().Lookup(cobraName))
	}
}

// RegisterFlags adds persistent flags necessary to the application to the specified *cobra.Command
func RegisterFlags(cmd *cobra.Command) error {
	// api.port ; --api-port
	cmd.PersistentFlags().Int("api-port", 3182, "API server port")
	if err := viper.BindPFlag("api.port", cmd.PersistentFlags().Lookup("api-port")); err != nil {
		return err
	}

	// api.key ; --api-key
	if err := RegisterString(cmd, true,
		"api.key", "api-key", "API server key", "bottinag"); err != nil {
		return err
	}

	// bottin.api.host
	if err := RegisterString(cmd, true,
		"bottin.api.host", "bottin-api-host", "Bottin API server host", "localhost"); err != nil {
		return err
	}

	// bottin.api.key
	if err := RegisterString(cmd, true,
		"bottin.api.key", "bottin-api-key", "Bottin API server key", "bottin"); err != nil {
		return err
	}

	// bottin.api.port
	if err := RegisterInt(cmd, true,
		"bottin.api.port", "bottin-api-port", "Bottin API server port", 1312); err != nil {
		return err
	}

	// bottin.api.protocol
	if err := RegisterString(cmd, true,
		"bottin.api.protocol", "bottin-api-protocol", "Bottin API server protocol", "http"); err != nil {
		return err
	}

	// db.database
	if err := RegisterString(cmd, true,
		"db.database", "db-database", "PostgreSQL database", "bottinag"); err != nil {
		return err
	}

	// db.host
	if err := RegisterString(cmd, true,
		"db.host", "db-host", "PostgreSQL host", "db"); err != nil {
		return err
	}

	// db.password
	if err := RegisterString(cmd, true,
		"db.password", "db-password", "PostgreSQL password", "bottinag"); err != nil {
		return err
	}

	// db.port
	if err := RegisterInt(cmd, true,
		"db.port", "db-port", "PostgreSQL port", 5432); err != nil {
		return err
	}

	// db.user
	if err := RegisterString(cmd, true,
		"db.user", "db-user", "PostgreSQL user", "bottinag"); err != nil {
		return err
	}

	// db.use_ssl
	if err := RegisterBool(cmd, true,
		"db.use_ssl", "db-use-ssl", "PostgreSQL use_ssl", false); err != nil {
		return err
	}

	// web.api.host
	if err := RegisterString(cmd, true,
		"web.api.host", "web-api-host", "Webserver API client host", "localhost"); err != nil {
		return err
	}

	// web.api.key
	if err := RegisterString(cmd, true,
		"web.api.key", "web-api-key", "Webserver API client key", "bottinag"); err != nil {
		return err
	}

	// web.api.port
	if err := RegisterInt(cmd, true,
		"web.api.port", "web-api-port", "Webserver API client port", 3182); err != nil {
		return err
	}

	// web.api.protocol
	if err := RegisterString(cmd, true,
		"web.api.protocol", "web-api-protocol", "Webserver API client protocol", "http"); err != nil {
		return err
	}

	// web.password ; --web-password
	if err := RegisterString(cmd, true,
		"web.password", "web-password", "Webserver basic auth password", "bottinag"); err != nil {
		return err
	}

	// web.port ; --web-port
	cmd.PersistentFlags().Int("web-port", 3183, "Webserver port")
	if err := viper.BindPFlag("web.port", cmd.PersistentFlags().Lookup("web-port")); err != nil {
		return err
	}

	// web.user ; --web-user
	if err := RegisterString(cmd, true,
		"web.user", "web-user", "Webserver basic auth username", "bottinag"); err != nil {
		return err
	}

	return nil
}