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"`

	// Claims is what the object claims of each compute type of its
	// namespace, cluster-wide: thousandths of a cpu, and bytes of memory,
	// -1 for a type its processes are not capped on.
	//
	// It is published with the configuration because that is where a
	// claim reads what a namespace holds, and a claim is weighed when a
	// configuration is written, before anything runs.
	Claims map[string]int64 `json:"claims,omitempty"`

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

	// WaitSyncsTimeout is how long a stop or a switch waits for the
	// syncs running on the instance to end: DEFAULT.wait_syncs_timeout.
	WaitSyncsTimeout time.Duration `json:"wait_syncs_timeout,omitempty"`
}

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 MonitorGlobalExpectOptionsCapped struct {
	ConfigUpdatedAt time.Time `json:"config_updated_at"`
}

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

	// InterruptSyncs has the instance stopped interrupt the syncs
	// running on it, instead of waiting for them to end.
	InterruptSyncs bool `json:"interrupt_syncs,omitempty"`
}

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

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

type MonitorGlobalExpectOptionsStopped struct {
	InterruptSyncs bool `json:"interrupt_syncs,omitempty"`
}

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 ReferenceStatus struct {
	RID      string
	Status   status.T
	Optional bool
}

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"`

	// StoppedAt is when the instance was stopped on purpose, and zero
	// when it was not. It says the daemon must not start the instance
	// back on its own, and is cleared when the object is wanted up
	// again. It is what a stop uses instead of freezing, so the frozen
	// flag keeps saying what the operator decided, and only that.
	StoppedAt time.Time `json:"stopped_at,omitempty"`

	// FrozenScope is "object" when the instance was frozen by a freeze
	// of the object, "instance" when it was frozen alone, and empty
	// when it is not frozen.
	FrozenScope freeze.Scope `json:"frozen_scope,omitempty"`

	UpdatedAt time.Time `json:"updated_at"`

	// OutdatedAt is the earliest OutdatedAt of the resources: when
	// the status changes with no event to tell, for the daemon to
	// evaluate it again then. Zero if it does not.
	OutdatedAt time.Time `json:"outdated_at,omitzero"`

	// RPOBreachedAt is the earliest RPOBreachedAt of the resources:
	// past it, this node taking over would lose more data than one
	// of the resources allows. Each resource has its own contract,
	// so the instance breaches when any of them does. Zero when no
	// resource keeps a copy here.
	RPOBreachedAt time.Time `json:"rpo_breached_at,omitzero"`
}

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"`
}