import and export CLI command updates (added configs to export/import), modified Webhook notifier headers

cmd/cli.go

@@ -153,8 +153,10 @@ func onceCli() error {
 func importCli(args []string) error {
 	var err error
 	var data []byte
-	filename := args[1]
+	if len(args) < 1 {
-	if data, err = ioutil.ReadFile(filename); err != nil {
+		return errors.New("invalid command arguments")
+	}
+	if data, err = ioutil.ReadFile(args[0]); err != nil {
 		return err
 	}
 	var exportData ExportData
@@ -162,11 +164,40 @@ func importCli(args []string) error {
 		return err
 	}
 	log.Printf("=== %s ===\n", exportData.Core.Name)
-	log.Printf("Services:   %d\n", len(exportData.Services))
+	if exportData.Config != nil {
-	log.Printf("Checkins:   %d\n", len(exportData.Checkins))
+		log.Printf("Configs:     %s\n", exportData.Config.DbConn)
-	log.Printf("Groups:     %d\n", len(exportData.Groups))
+		if exportData.Config.DbUser != "" {
-	log.Printf("Messages:   %d\n", len(exportData.Messages))
+			log.Printf("   - Host:   %s\n", exportData.Config.DbHost)
-	log.Printf("Users:      %d\n", len(exportData.Users))
+			log.Printf("   - User:   %s\n", exportData.Config.DbUser)
+		}
+	}
+	if len(exportData.Services) > 0 {
+		log.Printf("Services:   %d\n", len(exportData.Services))
+	}
+	if len(exportData.Checkins) > 0 {
+		log.Printf("Checkins:   %d\n", len(exportData.Checkins))
+	}
+	if len(exportData.Groups) > 0 {
+		log.Printf("Groups:     %d\n", len(exportData.Groups))
+	}
+	if len(exportData.Messages) > 0 {
+		log.Printf("Messages:   %d\n", len(exportData.Messages))
+	}
+	if len(exportData.Users) > 0 {
+		log.Printf("Users:      %d\n", len(exportData.Users))
+	}
+
+	if exportData.Config != nil {
+		if ask("Create config.yml file from Configs?") {
+			log.Printf("Database User:   %d\n", exportData.Config.DbUser)
+			log.Printf("Database Password:   %d\n", exportData.Config.DbPass)
+			log.Printf("Database Host:   %d\n", exportData.Config.DbHost)
+			log.Printf("Database Port:   %d\n", exportData.Config.DbPort)
+			if err := exportData.Config.Save(utils.Directory); err != nil {
+				return err
+			}
+		}
+	}
 
 	config, err := configs.LoadConfigs(configFile)
 	if err != nil {
@@ -175,8 +206,10 @@ func importCli(args []string) error {
 	if err = configs.ConnectConfigs(config, false); err != nil {
 		return err
 	}
-	if data, err = ExportSettings(); err != nil {
+	if ask("Create database rows and sample data?") {
-		return fmt.Errorf("could not export settings: %v", err.Error())
+		if err := config.ResetCore(); err != nil {
+			return err
+		}
 	}
 
 	if ask("Import Core settings?") {
@@ -221,7 +254,7 @@ func importCli(args []string) error {
 		if ask(fmt.Sprintf("Import User '%s'?", s.Username)) {
 			s.Id = 0
 			if err := s.Create(); err != nil {
-				return err
+				log.Errorln(err)
 			}
 		}
 	}
@@ -376,6 +409,7 @@ type gitUploader struct {
 // ExportChartsJs renders the charts for the index page
 
 type ExportData struct {
+	Config    *configs.DbConfig   `json:"config"`
 	Core      *core.Core          `json:"core"`
 	Services  []services.Service  `json:"services"`
 	Messages  []*messages.Message `json:"messages"`
@@ -403,7 +437,14 @@ func ExportSettings() ([]byte, error) {
 		s.Failures = nil
 		srvs = append(srvs, s)
 	}
+
+	cfg, err := configs.LoadConfigs(configFile)
+	if err != nil {
+		return nil, err
+	}
+
 	data := ExportData{
+		Config:    cfg,
 		Core:      c,
 		Notifiers: core.App.Notifications,
 		Checkins:  checkins.All(),

cmd/main.go

@@ -96,39 +96,8 @@ func start() {
 		exit(err)
 	}
 
-	if !confgs.Db.HasTable("core") {
+	if err = confgs.ResetCore(); err != nil {
-		var srvs int64
+		exit(err)
-		if confgs.Db.HasTable(&services.Service{}) {
-			confgs.Db.Model(&services.Service{}).Count(&srvs)
-			if srvs > 0 {
-				exit(errors.Wrap(err, "there are already services setup."))
-				return
-			}
-		}
-
-		if err := confgs.DropDatabase(); err != nil {
-			exit(errors.Wrap(err, "error dropping database"))
-		}
-
-		if err := confgs.CreateDatabase(); err != nil {
-			exit(errors.Wrap(err, "error creating database"))
-		}
-
-		if err := configs.CreateAdminUser(confgs); err != nil {
-			exit(errors.Wrap(err, "error creating default admin user"))
-		}
-
-		if utils.Params.GetBool("SAMPLE_DATA") {
-			log.Infoln("Adding Sample Data")
-			if err := configs.TriggerSamples(); err != nil {
-				exit(errors.Wrap(err, "error adding sample data"))
-			}
-		} else {
-			if err := core.Samples(); err != nil {
-				exit(errors.Wrap(err, "error added core details"))
-			}
-		}
-
 	}
 
 	if err = confgs.DatabaseChanges(); err != nil {

notifiers/webhook.go

@@ -88,10 +88,15 @@ func (w *webhooker) sendHttpWebhook(body string) (*http.Response, error) {
 		return nil, err
 	}
 	if w.ApiSecret != "" {
-		splitArray := strings.Split(w.ApiSecret, ",")
+		keyVal := strings.SplitN(w.ApiSecret, "=", 2)
-		for _, a := range splitArray {
+		if len(keyVal) == 2 {
-			split := strings.Split(a, "=")
+			if keyVal[0] != "" && keyVal[1] != "" {
-			req.Header.Add(split[0], split[1])
+				if strings.ToLower(keyVal[0]) == "host" {
+					req.Host = strings.TrimSpace(keyVal[1])
+				} else {
+					req.Header.Set(keyVal[0], keyVal[1])
+				}
+			}
 		}
 	}
 	if w.ApiKey != "" {

types/configs/file.go

@@ -21,18 +21,6 @@ func ConnectConfigs(configs *DbConfig, retry bool) error {
 	return nil
 }
 
-func LoadConfigs(cfgFile string) (*DbConfig, error) {
-	writeAble, err := utils.DirWritable(utils.Directory)
-	if err != nil {
-		return nil, err
-	}
-	if !writeAble {
-		return nil, errors.Errorf("Directory %s is not writable!", utils.Directory)
-	}
-
-	return LoadConfigFile(cfgFile)
-}
-
 func findDbFile(configs *DbConfig) (string, error) {
 	location := utils.Directory + "/" + SqliteFilename
 	if configs == nil {

types/configs/load.go

@@ -1,21 +1,28 @@
 package configs
 
 import (
-	"github.com/statping/statping/types/errors"
+	"errors"
 	"github.com/statping/statping/utils"
 	"gopkg.in/yaml.v2"
 	"os"
 )
 
-func LoadConfigFile(configFile string) (*DbConfig, error) {
+func LoadConfigs(cfgFile string) (*DbConfig, error) {
+	writeAble, err := utils.DirWritable(utils.Directory)
+	if err != nil {
+		return nil, err
+	}
+	if !writeAble {
+		return nil, errors.New("Directory %s is not writable: " + utils.Directory)
+	}
 	p := utils.Params
-	log.Infof("Attempting to read config file at: %s", configFile)
+	log.Infof("Attempting to read config file at: %s", cfgFile)
-	p.SetConfigFile(configFile)
+	p.SetConfigFile(cfgFile)
 	p.SetConfigType("yaml")
 	p.ReadInConfig()
 
 	db := new(DbConfig)
-	content, err := utils.OpenFile(configFile)
+	content, err := utils.OpenFile(cfgFile)
 	if err == nil {
 		if err := yaml.Unmarshal([]byte(content), &db); err != nil {
 			return nil, err
@@ -74,7 +81,7 @@ func LoadConfigFile(configFile string) (*DbConfig, error) {
 		Language:    p.GetString("LANGUAGE"),
 		SendReports: p.GetBool("ALLOW_REPORTS"),
 	}
-	log.WithFields(utils.ToFields(configs)).Debugln("read config file: " + configFile)
+	log.WithFields(utils.ToFields(configs)).Debugln("read config file: " + cfgFile)
 
 	if configs.DbConn == "" {
 		return configs, errors.New("Starting in setup mode")

types/configs/migration.go

@@ -5,6 +5,7 @@ import (
 	_ "github.com/jinzhu/gorm/dialects/mysql"
 	_ "github.com/jinzhu/gorm/dialects/postgres"
 	_ "github.com/mattn/go-sqlite3"
+	"github.com/pkg/errors"
 	"github.com/statping/statping/source"
 	"github.com/statping/statping/types/notifications"
 	"github.com/statping/statping/utils"
@@ -20,6 +21,39 @@ import (
 	"github.com/statping/statping/types/users"
 )
 
+func (d *DbConfig) ResetCore() error {
+	if d.Db.HasTable("core") {
+		return nil
+	}
+	var srvs int64
+	if d.Db.HasTable(&services.Service{}) {
+		d.Db.Model(&services.Service{}).Count(&srvs)
+		if srvs > 0 {
+			return errors.New("there are already services setup.")
+		}
+	}
+	if err := d.DropDatabase(); err != nil {
+		return errors.Wrap(err, "error dropping database")
+	}
+	if err := d.CreateDatabase(); err != nil {
+		return errors.Wrap(err, "error creating database")
+	}
+	if err := CreateAdminUser(d); err != nil {
+		return errors.Wrap(err, "error creating default admin user")
+	}
+	if utils.Params.GetBool("SAMPLE_DATA") {
+		log.Infoln("Adding Sample Data")
+		if err := TriggerSamples(); err != nil {
+			return errors.Wrap(err, "error adding sample data")
+		}
+	} else {
+		if err := core.Samples(); err != nil {
+			return errors.Wrap(err, "error added core details")
+		}
+	}
+	return nil
+}
+
 func (d *DbConfig) DatabaseChanges() error {
 	var cr core.Core
 	d.Db.Model(&core.Core{}).Find(&cr)