types

type Annotations = map[string]string

type Bus interface {
	// Subscribe returns a new subscription to the bus.
	Subscribe() *Subscription
	// Unsubscribe removes a subscription from the bus.
	Unsubscribe(*Subscription) error
	// Publish sends an event to the bus.
	Publish(event Event)
}

type Creator[Model any] interface {
	// Create creates a new record in the database. It may modify the input Model
	// along the way (e.g. to set the ID). It returns an error if there was a
	// problem creating the record.
	Create(ctx context.Context, it *Model) error
}

type Deleter[ID comparable] interface {
	// Delete deletes a record from the database by ID. It returns an error if
	// there was a problem deleting the record.
	Delete(ctx context.Context, id ID) error
}

type Event = partybus.Event

type File interface {
	io.ReadWriteCloser

	// a unique identifier for the file
	UniqueID() string

	// location of the file
	Location() (string, error)

	// change the name / location of the file in the environment
	Rename(new string) error

	// get the size of the file in bytes
	Size() (int64, error)
}

type FileChanged struct {
	Name string
}

type FileCreated struct {
	Name string
}

type FileDeleted struct {
	Name string
}

type FileRenamed struct {
	Name string
}

type InputData struct {
	TimeSeries []TimeSeries `json:"timeseries"` //nolint:tagliatelle // "time_series" might be right; does this need to match something else?
}

type Label struct {
	Name  string `json:"name"`
	Value string `json:"value"`
}

type Labels = map[string]string

type Metric struct {
	ID             uuid.UUID
	ClusterName    string
	CloudAccountID string
	MetricName     string
	NodeName       string
	CreatedAt      time.Time
	TimeStamp      time.Time
	Labels         map[string]string
	Value          string
}

type MetricRange struct {
	Metrics []Metric `json:"metrics"`
	Next    *string  `json:"next,omitempty"`
}

type ParquetMetric struct {
	ClusterName    string `parquet:"cluster_name"`
	CloudAccountID string `parquet:"cloud_account_id"`
	Year           string `parquet:"year"`
	Month          string `parquet:"month"`
	Day            string `parquet:"day"`
	Hour           string `parquet:"hour"`
	MetricName     string `parquet:"metric_name"`
	NodeName       string `parquet:"node_name"`
	CreatedAt      int64  `parquet:"created_at,timestamp"`
	TimeStamp      int64  `parquet:"timestamp,timestamp"`
	Labels         string `parquet:"labels"`
	Value          string `parquet:"value"`
}

type ReadableStore interface {
	StoreMonitor

	// GetFiles returns the list of files in the store. `paths` can be used to add a specific location
	GetFiles(paths ...string) ([]string, error)

	// ListFiles gives a list of `[]os.DirEntry` for a given store. `paths` can be used to add a specific location
	ListFiles(paths ...string) ([]os.DirEntry, error)

	// Walk runs a `proccess` on the file loc of the implementation store
	Walk(loc string, process filepath.WalkFunc) error
}

type Reader[Model any, ID comparable] interface {
	// Get retrieves a record from the database by ID. It returns an error if there
	// was a problem retrieving the record.
	Get(ctx context.Context, id ID) (*Model, error)
}

type RemoteWriteHistory struct {
	LastRemoteWriteTime time.Time
}

type ResourceStore interface {
	StorageCommon
	Storage[ResourceTags, string]

	// FindFirstBy returns the first resource tag that matches the given conditions.
	FindFirstBy(ctx context.Context, conds ...interface{}) (*ResourceTags, error)
	// FindAllBy returns all resource tags that match the given conditions.
	FindAllBy(ctx context.Context, conds ...interface{}) ([]*ResourceTags, error)
}

type ResourceTags struct {
	ID            string                  `gorm:"unique;autoIncrement"`
	Type          config.ResourceType     `gorm:"primaryKey"`      // Type of k8s resource; deployment, statefulset, pod, node, namespace
	Name          string                  `gorm:"primaryKey"`      // Name of the resource
	Namespace     *string                 `gorm:"primaryKey"`      // Namspace of the resource, if applicable
	MetricLabels  *config.MetricLabels    `gorm:"serializer:json"` // Metric labels of the resource; nullable
	Labels        *config.MetricLabelTags `gorm:"serializer:json"` // Labels of the resource; nullable
	Annotations   *config.MetricLabelTags `gorm:"serializer:json"` // Annotations of the resource; nullable
	RecordCreated time.Time               // Creation time of the record
	RecordUpdated time.Time               // Time that the record was updated, if the k8s object was updated with different labels
	SentAt        *time.Time              // Time that the record was sent to the cloudzero API, or null if not sent yet
	Size          int                     `` // Size of the record in bytes
	/* 174-byte string literal not displayed */
}

type Runnable interface {
	// Run starts the runnable.
	Run() error
	// IsRunning returns true if the runnable is running.
	IsRunning() bool
	// Shutdown shuts down the runnable.
	Shutdown() error
}

type Sample struct {
	Value     *float64 `json:"value"`
	Timestamp string   `json:"timestamp"`
}

type Set[T comparable] struct {
	// contains filtered or unexported fields
}

type Storage[Model any, ID comparable] interface {
	Creator[Model]
	Reader[Model, ID]
	Updater[Model]
	Deleter[ID]
}

type StorageCommon interface {
	// Tx runs block in a transaction.
	Tx(ctx context.Context, block func(ctxTx context.Context) error) error
	// Count returns the number of records.
	Count(ctx context.Context) (int, error)
	// DeleteAll deletes all records.
	DeleteAll(ctx context.Context) error
}

type Store interface {
	WritableStore
	ReadableStore
}

type StoreMonitor interface {
	// GetUsage returns a complete snapshot of the store usage.
	// optional `paths` can be defined which will be used as `filepath.Join(paths...)`
	GetUsage(limit uint64, paths ...string) (*StoreUsage, error)
}

type StoreUsage struct {
	Total       uint64  `json:"total"`       // Total storage in bytes
	Available   uint64  `json:"available"`   // Available storage in bytes
	Used        uint64  `json:"used"`        // Computed as Total - Available
	PercentUsed float64 `json:"percentUsed"` // Computed as (Used / Total) * 100
	BlockSize   uint32  `json:"blockSize"`   // Underlying block size
}

type StoreWarning int

type Subscription = partybus.Subscription

type TimeProvider interface {
	// GetCurrentTime returns the current time.
	GetCurrentTime() time.Time
}

type TimeSeries struct {
	Labels  []Label  `json:"labels"`
	Samples []Sample `json:"samples"`
}

type Updater[Model any] interface {
	// Update updates an existing record in the database. It may modify the input
	// Model along the way (e.g. to set the updated_at timestamp). It returns an
	// error if there was a problem updating the record.
	Update(ctx context.Context, it *Model) error
}

type WritableStore interface {
	// All retrieves all metrics. It takes a context and an optional string pointer as parameters.
	// Returns a MetricRange and an error.
	All(context.Context, string) (MetricRange, error)

	// Put appends one or more metrics to the storage, handling buffering internally.
	Put(context.Context, ...Metric) error

	// Flush writes all buffered data to persistent storage.
	// This can be used to force a write without reaching the row limit.
	Flush() error

	// Pending returns the number of rows currently buffered and not yet written to disk.
	// This can be used to monitor when a flush may be needed.
	Pending() int
}