entityservice

type Adapter interface {
	GetAll() ([]EntityService, error)

	GetEnabled() ([]EntityService, error)

	GetValid() ([]EntityService, error)

	GetByID(id string) (*EntityService, error)

	AddDepends(id string, depends []string) (bool, error)

	RemoveDepends(id string, depends []string) (bool, error)

	RemoveDependByQuery(query interface{}, depend string) ([]string, error)

	// UpdateCounters saves service counters to storage.
	UpdateCounters(string, AlarmCounters) error

	// UpdateBulk bulk update
	UpdateBulk(ctx context.Context, writeModels []mongodriver.WriteModel) error

	// GetCounters calculates service counters base on dependencies alarms state.
	GetCounters(ctx context.Context, serviceID string) (mongo.Cursor, error)
}

type AlarmCounters struct {
	// All is count of unresolved
	All int64 `bson:"all"`
	// Alarms is count of unresolved and active (by pbehavior)
	Alarms int64         `bson:"active"`
	State  StateCounters `bson:"state"`
	// Acknowledged is count of unresolved and acked and active (by pbehavior)
	Acknowledged int64 `bson:"acked"`
	// NotAcknowledged is count of unresolved and unacked and active (by pbehavior)
	NotAcknowledged int64 `bson:"unacked"`
	// PbehaviorCounters contains counters for each pbehavior type.
	PbehaviorCounters map[string]int64 `bson:"pbehavior"`
}

type ChangeEntityMessage struct {
	ID string
	// IsToggled is true if entity is disabled or enabled.
	IsToggled bool
	IsService bool
	// IsPatternChanged defines should service's context graph and state be recomputed.
	IsServicePatternChanged bool
	// ServiceAlarm is required on entity service delete because alarm is removed from
	// storage but alarm state is required by engine-service.
	ServiceAlarm *types.Alarm
}

type CountersCache interface {
	Update(context.Context, map[string]AlarmCounters) (map[string]AlarmCounters, error)

	Replace(context.Context, string, AlarmCounters) error

	Remove(context.Context, string) error

	RemoveAndGet(context.Context, string) (*AlarmCounters, error)

	ClearAll(context.Context) error

	KeepOnly(ctx context.Context, ids []string) error
}

type EntityService struct {
	types.Entity   `bson:",inline"`
	EntityPatterns pattern.EntityPatternList `bson:"entity_patterns" json:"entity_patterns"`
	OutputTemplate string                    `bson:"output_template" json:"output_template"`
}

type EventPublisher interface {
	Publish(ctx context.Context, ch <-chan ChangeEntityMessage)
}

type Manager interface {
	// LoadServices loads services from storage.
	LoadServices(ctx context.Context) error
	// UpdateServices adds or removes entities.
	UpdateServices(ctx context.Context, entities []types.Entity) (addedTo map[string][]string, removedFrom map[string][]string, err error)
	// UpdateService adds service to matched entities impacts and updates its depends.
	UpdateService(ctx context.Context, serviceID string) (isUpdated bool, removedFrom []string, err error)
	// ReloadService loads service from storage to cache.
	ReloadService(ctx context.Context, serviceID string) error
	// HasEntityServiceByComponentInfos returns true of at least one entity service patterns
	// contains component infos condition.
	HasEntityServiceByComponentInfos(ctx context.Context) (bool, error)
}

type Service interface {
	// Process updates the services impacted by the event and alarmChange
	// This method should be called on each event published by the axe engine
	// and context graph update by the che engine,
	// so that the services' states are updated in real time.
	Process(ctx context.Context, event types.Event) error

	ProcessRpc(ctx context.Context, event types.Event) error

	// UpdateService updates the state of a service given its ID.
	UpdateService(ctx context.Context, event types.Event) error

	// ReloadService loads service from storage to cache.
	ReloadService(ctx context.Context, serviceID string) error

	// ComputeAllServices updates the states of all services.
	ComputeAllServices(ctx context.Context) error

	RecomputeIdleSince(parentCtx context.Context) error

	// ClearCache clears all counters of entity services from cache.
	ClearCache(ctx context.Context) error
}

type ServiceData struct {
	ID             string                    `json:"_id"`
	OutputTemplate string                    `json:"output_template,omitempty"`
	EntityPatterns pattern.EntityPatternList `json:"entity_patterns"`
	Impacts        []string                  `json:"impacts"`
}

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

type StateCounters struct {
	Critical int64 `bson:"critical"`
	Major    int64 `bson:"major"`
	Minor    int64 `bson:"minor"`
	Info     int64 `bson:"info"`
}

type Storage interface {
	SaveAll(ctx context.Context, data []ServiceData) error
	Save(ctx context.Context, data ServiceData) error
	Load(ctx context.Context) ([]ServiceData, error)
	Get(ctx context.Context, id string) (*ServiceData, error)
	Delete(ctx context.Context, id string) error
}