package config import ( "encoding/json" "flag" "fmt" "github.com/emvi/logbuch" "github.com/gorilla/securecookie" "github.com/jinzhu/configor" "github.com/markbates/pkger" "github.com/muety/wakapi/models" migrate "github.com/rubenv/sql-migrate" "gorm.io/driver/mysql" "gorm.io/driver/postgres" "gorm.io/driver/sqlite" "gorm.io/gorm" "io/ioutil" "net/http" "os" "strings" ) const ( defaultConfigPath = "config.yml" defaultConfigPathLegacy = "config.ini" defaultEnvConfigPathLegacy = ".env" SQLDialectMysql = "mysql" SQLDialectPostgres = "postgres" SQLDialectSqlite = "sqlite3" KeyLatestTotalTime = "latest_total_time" KeyLatestTotalUsers = "latest_total_users" ) const ( WakatimeApiUrl = "https://wakatime.com/api/v1" WakatimeApiHeartbeatsEndpoint = "/users/current/heartbeats.bulk" WakatimeApiUserEndpoint = "/users/current" ) var cfg *Config var cFlag = flag.String("config", defaultConfigPath, "config file location") type appConfig struct { AggregationTime string `yaml:"aggregation_time" default:"02:15" env:"WAKAPI_AGGREGATION_TIME"` CountingTime string `yaml:"counting_time" default:"05:15" env:"WAKAPI_COUNTING_TIME"` CustomLanguages map[string]string `yaml:"custom_languages"` Colors map[string]map[string]string `yaml:"-"` } type securityConfig struct { // this is actually a pepper (https://en.wikipedia.org/wiki/Pepper_(cryptography)) PasswordSalt string `yaml:"password_salt" default:"" env:"WAKAPI_PASSWORD_SALT"` InsecureCookies bool `yaml:"insecure_cookies" default:"false" env:"WAKAPI_INSECURE_COOKIES"` CookieMaxAgeSec int `yaml:"cookie_max_age" default:"172800" env:"WAKAPI_COOKIE_MAX_AGE"` SecureCookie *securecookie.SecureCookie `yaml:"-"` } type dbConfig struct { Host string `env:"WAKAPI_DB_HOST"` Port uint `env:"WAKAPI_DB_PORT"` User string `env:"WAKAPI_DB_USER"` Password string `env:"WAKAPI_DB_PASSWORD"` Name string `default:"wakapi_db.db" env:"WAKAPI_DB_NAME"` Dialect string `yaml:"-"` Type string `yaml:"dialect" default:"sqlite3" env:"WAKAPI_DB_TYPE"` MaxConn uint `yaml:"max_conn" default:"2" env:"WAKAPI_DB_MAX_CONNECTIONS"` Ssl bool `default:"false" env:"WAKAPI_DB_SSL"` } type serverConfig struct { Port int `default:"3000" env:"WAKAPI_PORT"` ListenIpV4 string `yaml:"listen_ipv4" default:"127.0.0.1" env:"WAKAPI_LISTEN_IPV4"` ListenIpV6 string `yaml:"listen_ipv6" default:"::1" env:"WAKAPI_LISTEN_IPV6"` BasePath string `yaml:"base_path" default:"/" env:"WAKAPI_BASE_PATH"` TlsCertPath string `yaml:"tls_cert_path" default:"" env:"WAKAPI_TLS_CERT_PATH"` TlsKeyPath string `yaml:"tls_key_path" default:"" env:"WAKAPI_TLS_KEY_PATH"` } type Config struct { Env string `default:"dev" env:"ENVIRONMENT"` Version string `yaml:"-"` App appConfig Security securityConfig Db dbConfig Server serverConfig } func (c *Config) CreateCookie(name, value, path string) *http.Cookie { return c.createCookie(name, value, path, c.Security.CookieMaxAgeSec) } func (c *Config) GetClearCookie(name, path string) *http.Cookie { return c.createCookie(name, "", path, -1) } func (c *Config) createCookie(name, value, path string, maxAge int) *http.Cookie { return &http.Cookie{ Name: name, Value: value, Path: path, MaxAge: maxAge, Secure: !c.Security.InsecureCookies, HttpOnly: true, SameSite: http.SameSiteStrictMode, } } func (c *Config) IsDev() bool { return IsDev(c.Env) } func (c *Config) UseTLS() bool { return c.Server.TlsCertPath != "" && c.Server.TlsKeyPath != "" } func (c *Config) GetMigrationFunc(dbDialect string) models.MigrationFunc { switch dbDialect { default: return func(db *gorm.DB) error { db.AutoMigrate(&models.User{}) db.AutoMigrate(&models.KeyStringValue{}) db.AutoMigrate(&models.Alias{}) db.AutoMigrate(&models.Heartbeat{}) db.AutoMigrate(&models.Summary{}) db.AutoMigrate(&models.SummaryItem{}) db.AutoMigrate(&models.LanguageMapping{}) return nil } } } func (c *Config) GetFixturesFunc(dbDialect string) models.MigrationFunc { return func(db *gorm.DB) error { migrations := &migrate.HttpFileSystemMigrationSource{ FileSystem: pkger.Dir("/migrations"), } migrate.SetIgnoreUnknown(true) sqlDb, _ := db.DB() n, err := migrate.Exec(sqlDb, dbDialect, migrations, migrate.Up) if err != nil { return err } logbuch.Info("applied %d fixtures", n) return nil } } func (c *dbConfig) GetDialector() gorm.Dialector { switch c.Dialect { case SQLDialectMysql: return mysql.New(mysql.Config{ DriverName: c.Dialect, DSN: mysqlConnectionString(c), }) case SQLDialectPostgres: return postgres.New(postgres.Config{ DSN: postgresConnectionString(c), }) case SQLDialectSqlite: return sqlite.Open(sqliteConnectionString(c)) } return nil } func mysqlConnectionString(config *dbConfig) string { //location, _ := time.LoadLocation("Local") return fmt.Sprintf("%s:%s@tcp(%s:%d)/%s?charset=utf8&parseTime=true&loc=%s&sql_mode=ANSI_QUOTES", config.User, config.Password, config.Host, config.Port, config.Name, "Local", ) } func postgresConnectionString(config *dbConfig) string { sslmode := "disable" if config.Ssl { sslmode = "require" } return fmt.Sprintf("host=%s port=%d user=%s dbname=%s password=%s sslmode=%s", config.Host, config.Port, config.User, config.Name, config.Password, sslmode, ) } func sqliteConnectionString(config *dbConfig) string { return config.Name } func (c *appConfig) GetCustomLanguages() map[string]string { return cloneStringMap(c.CustomLanguages, false) } func (c *appConfig) GetLanguageColors() map[string]string { return cloneStringMap(c.Colors["languages"], true) } func (c *appConfig) GetEditorColors() map[string]string { return cloneStringMap(c.Colors["editors"], true) } func (c *appConfig) GetOSColors() map[string]string { return cloneStringMap(c.Colors["operating_systems"], true) } func IsDev(env string) bool { return env == "dev" || env == "development" } func readVersion() string { file, err := pkger.Open("/version.txt") if err != nil { logbuch.Fatal(err.Error()) } defer file.Close() bytes, err := ioutil.ReadAll(file) if err != nil { logbuch.Fatal(err.Error()) } return strings.TrimSpace(string(bytes)) } func readColors() map[string]map[string]string { // Read language colors // Source: // – https://raw.githubusercontent.com/ozh/github-colors/master/colors.json // – https://wakatime.com/colors/operating_systems // - https://wakatime.com/colors/editors // Extracted from Wakatime website with XPath (see below) and did a bit of regex magic after. // – $x('//span[@class="editor-icon tip"]/@data-original-title').map(e => e.nodeValue) // – $x('//span[@class="editor-icon tip"]/div[1]/text()').map(e => e.nodeValue) var colors = make(map[string]map[string]string) file, err := pkger.Open("/data/colors.json") if err != nil { logbuch.Fatal(err.Error()) } defer file.Close() bytes, err := ioutil.ReadAll(file) if err != nil { logbuch.Fatal(err.Error()) } if err := json.Unmarshal(bytes, &colors); err != nil { logbuch.Fatal(err.Error()) } return colors } func mustReadConfigLocation() string { if _, err := os.Stat(*cFlag); err != nil { logbuch.Fatal("failed to find config file at '%s'", *cFlag) } return *cFlag } func resolveDbDialect(dbType string) string { if dbType == "cockroach" { return "postgres" } return dbType } func Set(config *Config) { cfg = config } func Get() *Config { return cfg } func Load() *Config { config := &Config{} flag.Parse() maybeMigrateLegacyConfig() if err := configor.New(&configor.Config{}).Load(config, mustReadConfigLocation()); err != nil { logbuch.Fatal("failed to read config: %v", err) } config.Version = readVersion() config.App.Colors = readColors() config.Db.Dialect = resolveDbDialect(config.Db.Type) config.Security.SecureCookie = securecookie.New( securecookie.GenerateRandomKey(64), securecookie.GenerateRandomKey(32), ) if strings.HasSuffix(config.Server.BasePath, "/") { config.Server.BasePath = config.Server.BasePath[:len(config.Server.BasePath)-1] } for k, v := range config.App.CustomLanguages { if v == "" { config.App.CustomLanguages[k] = "unknown" } } if config.Server.ListenIpV4 == "" && config.Server.ListenIpV6 == "" { logbuch.Fatal("either of listen_ipv4 or listen_ipv6 must be set") } Set(config) return Get() }