cadastre

type CadastreWebHandler struct {
	Handler func(http.ResponseWriter, *http.Request) error
	Server  *WebUI
}

type Configuration struct {
	// The list of MySQL hosts to check. A host is defined by a unique, internal name,
	// a display name (something more suitable than the internal name or hostname), an optional
	// category to allow for logical UI grouping and a DSN used to figure out how to connect to
	// the MySQL host.
	Servers []Server

	// A list of MySQL hosts to check, grouped by category.  This list contains the same servers
	// as the "Servers" list.
	ServerGroups []ServerGroup

	// The interval to check each server.
	FetchInterval time.Duration

	// The storage engine used to persist the host information to.
	Storage DataStore

	// The address for the web server to listen on.
	ListenAddress string

	// Where to load templates from.
	TemplateDirectory string

	// Where to serve static assets from.
	StaticAssetDirectory string

	// Whether or not we're in debug mode.
	DebugMode bool
}

type Count struct {
	Timestamp   int64 `json:"x"`
	ThreadCount int64 `json:"y"`
}

type Counts struct {
	Counts []Count `json:"counts"`
}

type DataStore interface {
	// Allows the storage engine time before serving requests to initialize itself, spin up any
	// background workers, etc.
	Initialize() error

	// Retrieve the snapshot for the given timestamp.  Returns nil if the snapshot for the given
	// timestamp can't be found, and an error if any errors were encountered.
	RetrieveSnapshot(identifier string, timestamp time.Time) (*Snapshot, error)

	// Retrieve the thread counts for snapshots taken within the given time period.  The time period
	// is calculated as anything on the same day as the given datestamp - only the date matters. Returns
	// nil if there are no counts for the given time period, and an error if any errors were encountered.
	RetrieveCounts(identifier string, datestamp time.Time) (*Counts, error)

	// Persists a snapshot for the given identifier to the underlying storage engine.
	Persist(identifier string, value *Snapshot) error
}

type Event struct {
	EventID      int64  `json:"id"`
	TimeElapsed  int64  `json:"timeElapsed"`
	Host         string `json:"host"`
	Database     string `json:"database"`
	User         string `json:"user"`
	Command      string `json:"command"`
	Status       string `json:"status"`
	SQL          string `json:"sql"`
	RowsSent     int64  `json:"rowsSent"`
	RowsExamined int64  `json:"rowsExamined"`
}

type Fetcher struct {
	Configuration *Configuration
	// contains filtered or unexported fields
}

type FileStore struct {
	DataDirectory string

	RetentionPeriod time.Duration
	// contains filtered or unexported fields
}

type Server struct {
	// The name of the server to show in the UI.
	DisplayName string `json:"displayName"`

	// The internal name of the server, which should be unique.  This is used when
	// persisting and retrieiving snapshots for the host from the storage engine.
	InternalName string `json:"internalName"`

	// The name of the group this server belongs to.
	GroupName string `json:"-"`

	// The canonical data source name for the given server.  This includes hostname,
	// port, username, password, SSL options, etc.
	DataSourceName string `json:"-"`
}

type ServerGroup struct {
	// The name of the group.
	GroupName string `json:"groupName"`

	// The servers that make up the group.
	Servers []Server `json:"servers"`
}

type Snapshot struct {
	Timestamp int64   `json:"timestamp"`
	Events    []Event `json:"events"`
}

type WebUI struct {
	Configuration *Configuration

	RequestsServed uint64
	RequestErrors  uint64
	CacheRequests  uint64
	CacheHits      uint64
	// contains filtered or unexported fields
}