instance

type ActorConfig struct {
	App              string            `json:"app,omitempty"`
	Children         naming.Relations  `json:"children,omitempty"`
	DRP              bool              `json:"drp,omitempty"`
	Env              string            `json:"env,omitempty"`
	MonitorAction    []MonitorAction   `json:"monitor_action,omitempty"`
	PreMonitorAction string            `json:"pre_monitor_action,omitempty"`
	Orchestrate      string            `json:"orchestrate"`
	Parents          naming.Relations  `json:"parents,omitempty"`
	PlacementPolicy  placement.Policy  `json:"placement_policy"`
	Resources        ResourceConfigs   `json:"resources"`
	Schedules        []schedule.Config `json:"schedules"`
	Stonith          bool              `json:"stonith"`
	Subsets          SubsetConfigs     `json:"subsets"`
	Topology         topology.T        `json:"topology,omitempty"`
	Flex             *FlexConfig       `json:"flex,omitempty"`

	// IsDisabled is true when DEFAULT.disable is true
	IsDisabled bool `json:"is_disabled"`
}

type Config struct {
	Path      naming.Path `json:"-"`
	Checksum  string      `json:"csum"`
	Priority  priority.T  `json:"priority"`
	Scope     []string    `json:"scope"`
	UpdatedAt time.Time   `json:"updated_at"`
	Labels    label.M     `json:"labels,omitempty"`

	*ActorConfig
	*VolConfig
}

type Data[T Dataer] struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

type DataElement[T Dataer] struct {
	Path  naming.Path
	Node  string
	Value *T
}

type Dataer interface {
	Status | Monitor | Config
}

type EncapMap map[string]EncapStatus

type EncapStatus struct {
	Status
	Hostname string `json:"hostname"`
}

type FlexConfig struct {
	Max    int `json:"max,omitempty"`
	Min    int `json:"min,omitempty"`
	Target int `json:"target,omitempty"`
}

type Instance struct {
	Config  *Config  `json:"config"`
	Monitor *Monitor `json:"monitor"`
	Status  *Status  `json:"status"`
}

type Monitor struct {
	GlobalExpect          MonitorGlobalExpect `json:"global_expect"`
	GlobalExpectUpdatedAt time.Time           `json:"global_expect_updated_at"`
	GlobalExpectOptions   any                 `json:"global_expect_options"`

	// IsLeader flags the instance as the one where to provision as leader.
	// The provisioning leader is responsible for preparing the shared resources.
	// There can be only one leader, whatever the topology.
	IsLeader bool `json:"is_leader"`

	// IsHALeader flags the instances to start automatically if orchestrate=ha
	// or when the admin posted a start orchestration.
	// There can be one leader on a failover object, or many leaders with a flex topology.
	IsHALeader bool `json:"is_ha_leader"`

	LocalExpect          MonitorLocalExpect `json:"local_expect"`
	LocalExpectUpdatedAt time.Time          `json:"local_expect_updated_at"`

	// OrchestrationID is the accepted orchestration id that will be unset
	// when orchestration is reached on local node
	OrchestrationID uuid.UUID `json:"orchestration_id"`

	// OrchestrationIsDone is set by the orchestration when it decides the instance state has reached its target.
	// It is used to clear orchestration and orchestration id up when all instance monitors have
	// OrchestrationIsDone set.
	OrchestrationIsDone bool `json:"orchestration_is_done"`

	SessionID               xsession.ID      `json:"session_id"`
	State                   MonitorState     `json:"state"`
	StateUpdatedAt          time.Time        `json:"state_updated_at"`
	MonitorActionExecutedAt time.Time        `json:"monitor_action_executed_at"`
	IsPreserved             bool             `json:"preserved"`
	Resources               ResourceMonitors `json:"resources,omitempty"`
	UpdatedAt               time.Time        `json:"updated_at"`

	Parents  map[string]status.T `json:"parents,omitempty"`
	Children map[string]status.T `json:"children,omitempty"`
}

type MonitorAction string

type MonitorGlobalExpect int

type MonitorGlobalExpectOptionsPlacedAt struct {
	Destination []string `json:"destination"`
	Live        bool     `json:"live"`
}

type MonitorGlobalExpectOptionsResized struct {
	ConfigUpdatedAt time.Time `json:"config_updated_at"`
}

type MonitorGlobalExpectOptionsRestarted struct {
	Force bool `json:"force"`
}

type MonitorLocalExpect int

type MonitorState int

type MonitorUpdate struct {
	GlobalExpect        *MonitorGlobalExpect `json:"global_expect"`
	GlobalExpectOptions any                  `json:"global_expect_options"`
	LocalExpect         *MonitorLocalExpect  `json:"local_expect"`
	State               *MonitorState        `json:"state"`

	// CandidateOrchestrationID is a candidate orchestration id for a new imon orchestration.
	CandidateOrchestrationID uuid.UUID `json:"orchestration_id"`
}

type Node struct {
	Name     string    `json:"name"`
	FrozenAt time.Time `json:"frozen_at,omitempty"`
}

type ResourceConfig struct {
	IsDisabled   bool           `json:"is_disabled"`
	IsMonitored  bool           `json:"is_monitored"`
	IsStandby    bool           `json:"is_standby"`
	Restart      int            `json:"restart,omitempty"`
	RestartDelay *time.Duration `json:"restart_delay,omitempty"`
}

type ResourceConfigs map[string]ResourceConfig

type ResourceMonitor struct {
	Restart *ResourceMonitorRestart `json:"restart,omitempty"`
}

type ResourceMonitorRestart struct {
	Remaining int       `json:"remaining,omitempty"`
	LastAt    time.Time `json:"last_at,omitempty"`
}

type ResourceMonitors map[string]ResourceMonitor

type ResourceOrder []resource.Status

type ResourceStatuses map[string]resource.Status

type States struct {
	Path    naming.Path `json:"path"`
	Node    Node        `json:"node,omitempty"`
	Config  Config      `json:"config,omitempty"`
	Status  Status      `json:"status,omitempty"`
	Monitor Monitor     `json:"monitor,omitempty"`
}

type StatesList []States

type Status struct {
	Avail         status.T                 `json:"avail"`
	Encap         EncapMap                 `json:"encap,omitempty"`
	FrozenAt      time.Time                `json:"frozen_at,omitempty"`
	LastStartedAt time.Time                `json:"last_started_at"`
	Optional      status.T                 `json:"optional,omitempty"`
	Overall       status.T                 `json:"overall"`
	Provisioned   provisioned.T            `json:"provisioned"`
	Resources     ResourceStatuses         `json:"resources,omitempty"`
	Running       resource.RunningInfoList `json:"running,omitempty"`
	UpdatedAt     time.Time                `json:"updated_at"`
}

type SubsetConfig struct {
	Parallel bool `json:"parallel,omitempty"`
}

type SubsetConfigs map[string]SubsetConfig

type VolConfig struct {
	Pool string `json:"pool"`
	Size int64  `json:"size"`

	// Charges is what the volume takes of pools other than the one that
	// served it, by pool name.
	//
	// A volume is counted against the claim its namespace holds on the
	// pool it was served by, which is what it was asked of that pool.
	// A volume whose resources take their storage elsewhere costs those
	// pools too, and nothing else says so: a volume served by a virtual
	// pool is a copy of a template, and what that template builds is
	// only known by reading what it built.
	Charges map[string]int64 `json:"charges,omitempty"`
}