checks

var CommandMetrics = map[string]MetricInfo{
	"execution_time": {
		Unit: "ms",
	},
}

var DockerStatsMetrics = map[string]MetricInfo{}

var GlobalClient = http.Client{
	Timeout: time.Duration(10 * time.Second),
}

var GlobalSCollector map[Host]CurrentMetrics = make(map[Host]CurrentMetrics)

var NewCommand = func(config Config, logger *log.Logger) (Checker, error) {
	var commandConfig CommandConfig
	err := json.Unmarshal([]byte(config.Config), &commandConfig)
	if err != nil {
		return nil, err
	}
	if commandConfig.Command == "" {
		return nil, errors.New("command: command to run cannot be blank")
	}
	if commandConfig.Shell == "" {
		commandConfig.Shell = "sh"
	}
	if commandConfig.OutputType != "" && commandConfig.OutputType != "number" {
		return nil, errors.New("command: invalid output type")
	}
	if commandConfig.OutputType == "number" {
		CommandMetrics["output"] = MetricInfo{
			Unit: "unit",
		}
	}
	return Checker(&Command{
		commandConfig.Command,
		commandConfig.Shell,
		commandConfig.OutputType,
		logger}), nil
}

var NewDockerRemoteDocker = func(config Config, logger *log.Logger) (Checker, error) {

	var remoteDockerConfig RemoteDockerConfig
	err := json.Unmarshal([]byte(config.Config), &remoteDockerConfig)
	if err != nil {
		return nil, err
	}

	tool := utils.StringDefault(remoteDockerConfig.Tool, "nc")
	if !utils.FindStringInArray(tool, []string{"nc", "socat"}) {
		return nil, errors.New("checks: unknown tool in remote docker config")
	}

	if remoteDockerConfig.User == "" {
		return nil, errors.New("remote-docker: user cannot be blank")
	}

	if remoteDockerConfig.Host == "" {
		return nil, errors.New("remote-docker: host cannot be blank")
	}

	return Checker(&RemoteDocker{
		User:     remoteDockerConfig.User,
		Password: remoteDockerConfig.Password,
		Host:     remoteDockerConfig.Host,
		Key:      remoteDockerConfig.Key,
		Tool:     tool,
		log:      logger,
	}), nil
}

var NewDockerStats = func(config Config, logger *log.Logger) (Checker, error) {
	var commandConfig DockerStatsConfig
	err := json.Unmarshal([]byte(config.Config), &commandConfig)
	if err != nil {
		return nil, err
	}
	return Checker(&DockerStats{logger}), nil
}

var NewPostgres = func(config Config, logger *log.Logger) (Checker, error) {
	postgres := new(Postgres)
	err := json.Unmarshal([]byte(config.Config), postgres)
	if err != nil {
		return nil, err
	}
	if postgres.ConnectionURL == "" {
		return nil, errors.New("postgres: connection url cannot be blank")
	}
	if len(postgres.MetricQueries) == 0 {
		return nil, errors.New("postgres: no metrics to query")
	}
	postgres.log = logger
	return Checker(postgres), nil
}

var NewRemoteCommand = func(config Config, logger *log.Logger) (Checker, error) {
	var commandConfig RemoteCommandConfig
	err := json.Unmarshal([]byte(config.Config), &commandConfig)
	if err != nil {
		return nil, err
	}
	if commandConfig.Command == "" {
		return nil, errors.New("remote-command: command to run cannot be blank")
	}
	if commandConfig.OutputType != "" && commandConfig.OutputType != "number" {
		return nil, errors.New("remote-command: invalid output type")
	}
	if commandConfig.OutputType == "number" {
		RemoteCommandMetrics["output"] = MetricInfo{
			Unit: "unit",
		}
	}
	return Checker(&RemoteCommand{
		commandConfig.Command,
		commandConfig.OutputType,
		commandConfig.SSHAuthOptions,
		logger}), nil
}

var NewSCollector = func(config Config, logger *log.Logger) (Checker, error) {
	var sCollectorConfig SCollectorConfig
	err := json.Unmarshal([]byte(config.Config), &sCollectorConfig)
	if err != nil {
		return nil, err
	}
	if sCollectorConfig.Host == "" {
		return nil, errors.New("scollector: host to collect stats via scollector cannot be blank")
	}
	return Checker(&SCollector{sCollectorConfig.Host}), nil
}

var NewTCP = func(config Config, logger *log.Logger) (Checker, error) {
	var tcpConfig TCPConfig
	err := json.Unmarshal([]byte(config.Config), &tcpConfig)
	if err != nil {
		return nil, err
	}
	if tcpConfig.Host == "" {
		return nil, errors.New("tcp: host to connect to cannot be blank")
	}
	if tcpConfig.Port == 0 {
		return nil, errors.New("tcp: port to connect to cannot be zero")
	}
	return Checker(&TCP{tcpConfig.Host, tcpConfig.Port, logger}), nil
}

var NewTestReport = func(config Config, logger *log.Logger) (Checker, error) {
	var testReportConfig TestReportConfig
	err := json.Unmarshal([]byte(config.Config), &testReportConfig)
	if err != nil {
		return nil, err
	}
	if testReportConfig.Command == "" {
		return nil, errors.New("command: command to run cannot be blank")
	}
	if testReportConfig.Shell == "" {
		testReportConfig.Shell = "sh"
	}
	return Checker(&TestReport{
		testReportConfig.Command,
		testReportConfig.Shell,
		logger}), nil
}

var NewWebPinger = func(config Config, logger *log.Logger) (Checker, error) {
	var webPingerConfig WebPingerConfig
	err := json.Unmarshal([]byte(config.Config), &webPingerConfig)
	if err != nil {
		return nil, err
	}
	if webPingerConfig.Address == "" {
		return nil, errors.New("web-ping: address to ping cannot be blank")
	}
	return Checker(&WebPinger{config, webPingerConfig, logger}), nil
}

var RemoteCommandMetrics = map[string]MetricInfo{
	"execution_time": {
		Unit: "ms",
	},
}

var TCPMetrics = map[string]MetricInfo{
	"latency": {
		Unit: "ms",
	},
}

var TestReportMetrics = map[string]MetricInfo{
	"execution_time": {
		Unit: "ms",
	},
}

var WebPingerMetrics = map[string]MetricInfo{
	"latency": {
		Unit: "ms",
	},
}