common

type AresServerConfig struct {
	// HTTP port for serving.
	Port int `yaml:"port"`

	// HTTP port for debugging.
	DebugPort int `yaml:"debug_port"`

	// Directory path that stores the data and schema on local disk.
	RootPath string `yaml:"root_path"`

	// Total memory size ares can use.
	TotalMemorySize int64 `yaml:"total_memory_size"`

	// Whether to turn off scheduler.
	SchedulerOff bool `yaml:"scheduler_off"`

	// Build version of the server currently running
	Version string `yaml:"version"`

	// environment
	Env string `yaml:"env"`

	Query         QueryConfig     `yaml:"query"`
	DiskStore     DiskStoreConfig `yaml:"disk_store"`
	HTTP          HTTPConfig      `yaml:"http"`
	RedoLogConfig RedoLogConfig   `yaml:"redolog"`

	// Cluster determines the cluster mode configuration of aresdb
	Cluster ClusterConfig `yaml:"cluster"`
}

type ClusterConfig struct {
	// Enable controls whether to start in cluster mode
	Enable bool `yaml:"enable"`

	// Enable distributed mode
	Distributed bool `yaml:"distributed"`

	// Namespace is the cluster namespace to join
	Namespace string `yaml:"namespace"`

	// InstanceID is the cluster wide unique name to identify current instance
	// it can be static configured in yaml, or dynamically set on start up
	InstanceID string `yaml:"instance_id"`

	// controller config
	Controller *ControllerConfig `yaml:"controller,omitempty"`

	// etcd client required config
	Etcd etcd.Configuration `yaml:"etcd"`

	// heartbeat config
	HeartbeatConfig HeartbeatConfig `yaml:"heartbeat"`
}

type ControllerConfig struct {
	Address    string      `yaml:"address"`
	Headers    http.Header `yaml:"headers"`
	TimeoutSec int         `yaml:"timeout"`
}

type DiskRedoLogConfig struct {
	// disable local disk redolog, default will be enabled
	Disabled bool `yaml:"disabled"`
}

type DiskStoreConfig struct {
	WriteSync bool `yaml:"write_sync"`
}

type HTTPConfig struct {
	MaxConnections        int `yaml:"max_connections"`
	ReadTimeOutInSeconds  int `yaml:"read_time_out_in_seconds"`
	WriteTimeOutInSeconds int `yaml:"write_time_out_in_seconds"`
}

type HeartbeatConfig struct {
	// heartbeat timeout value
	Timeout int `yaml:"timeout"`
	// heartbeat interval value
	Interval int `yaml:"interval"`
}

type KafkaRedoLogConfig struct {
	// enable redolog from kafka, default will be disabled
	Enabled bool `yaml:"enabled"`
	// kafka brokers
	Brokers []string `yaml:"brokers"`
	// topic name suffix
	TopicSuffix string `yaml:"suffix"`
}

type Logger interface {
	// Log at debug level
	Debug(args ...interface{})

	// Log at debug level with fmt.Printf-like formatting
	Debugf(format string, args ...interface{})

	// Log at info level
	Info(args ...interface{})

	// Log at info level with fmt.Printf-like formatting
	Infof(format string, args ...interface{})

	// Log at warning level
	Warn(args ...interface{})

	// Log at warning level with fmt.Printf-like formatting
	Warnf(format string, args ...interface{})

	// Log at error level
	Error(args ...interface{})

	// Log at error level with fmt.Printf-like formatting
	Errorf(format string, args ...interface{})

	// Log at fatal level, then terminate process (irrecoverable)
	Fatal(args ...interface{})

	// Log at fatal level with fmt.Printf-like formatting, then terminate process (irrecoverable)
	Fatalf(format string, args ...interface{})

	// Log at panic level, then panic (recoverable)
	Panic(args ...interface{})

	// Log at panic level with fmt.Printf-like formatting, then panic (recoverable)
	Panicf(format string, args ...interface{})

	// Return a logger with the specified key-value pair set, to be logged in a subsequent normal logging call
	With(args ...interface{}) Logger
}

type LoggerFactory interface {
	// GetDefaultLogger returns the default logger.
	GetDefaultLogger() Logger
	// GetLogger returns logger given the logger name.
	GetLogger(name string) Logger
}

type Metrics interface {
	NewRootScope() (tally.Scope, io.Closer, error)
}

type NoopLogger struct{}

type QueryConfig struct {
	// how much portion of the device memory we are allowed use
	DeviceMemoryUtilization float32 `yaml:"device_memory_utilization"`
	// timeout in seconds for choosing device
	DeviceChoosingTimeout int            `yaml:"device_choosing_timeout"`
	TimezoneTable         TimezoneConfig `yaml:"timezone_table"`
	EnableHashReduction   bool           `yaml:"enable_hash_reduction"`
}

type RedoLogConfig struct {
	// Disk redolog config
	DiskConfig DiskRedoLogConfig `yaml:"disk"`
	// Kafka redolog config
	KafkaConfig KafkaRedoLogConfig `yaml:"kafka"`
	// Disk only redolog for unsharded tables
	DiskOnlyForUnsharded bool `yaml:"diskOnlyForUnsharded"`
}

type TimezoneConfig struct {
	// table to lookup timezone columns
	TableName string `yaml:"table_name"`
}

type ZapLogger struct {
	// contains filtered or unexported fields
}

type ZapLoggerFactory struct {
	// contains filtered or unexported fields
}