client

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

type AsyncCommand struct {
	ID         int                  `json:"id"`
	Type       string               `json:"type"`
	EndpointID portainer.EndpointID `json:"endpointID"`
	Timestamp  time.Time            `json:"timestamp"`
	Operation  string               `json:"op"`
	Path       string               `json:"path"`
	Value      any                  `json:"value"`
}

type AsyncRequest struct {
	CommandTimestamp *time.Time           `json:"commandTimestamp,omitempty"`
	Snapshot         *snapshot            `json:"snapshot,omitempty"`
	EndpointId       portainer.EndpointID `json:"endpointId,omitempty"`
	MetaFields       *MetaFields          `json:"metaFields,omitempty"`
}

type AsyncResponse struct {
	PingInterval     time.Duration `json:"pingInterval"`
	SnapshotInterval time.Duration `json:"snapshotInterval"`
	CommandInterval  time.Duration `json:"commandInterval"`

	EndpointID       portainer.EndpointID `json:"endpointID"`
	Commands         []AsyncCommand       `json:"commands"`
	NeedFullSnapshot bool                 `json:"needFullSnapshot"`
}

type ContainerCommandData struct {
	ContainerName          string
	ContainerStartOptions  container.StartOptions
	ContainerRemoveOptions container.RemoveOptions
	ContainerOperation     string
}

type DockerSnapshotter func(edgeKey string) (*portainer.DockerSnapshot, error)

type EdgeConfig struct {
	ID         EdgeConfigID
	Name       string
	BaseDir    string
	DirEntries []filesystem.DirEntry
	Prev       *EdgeConfig
	Invalid    bool
}

type EdgeConfigID int

type EdgeConfigStateType int

type EdgeJobData struct {
	ID                portainer.EdgeJobID
	CollectLogs       bool
	LogsStatus        portainer.EdgeJobLogsStatus
	CronExpression    string
	ScriptFileContent string
	Version           int
}

type EdgeStackLog struct {
	EdgeStackID portainer.EdgeStackID `json:"edgeStackID,omitempty"`
	Logs        []EndpointLog         `json:"logs,omitempty"`
	Append      bool                  `json:"append,omitempty"`
}

type EndpointLog struct {
	DockerContainerID string `json:"dockerContainerID,omitempty"`
	StdOut            string `json:"stdOut,omitempty"`
	StdErr            string `json:"stdErr,omitempty"`
}

type HelmChartStatusPayload struct {
	Statuses []portainer.PolicyChartStatus `json:"chartStatuses"`
}

type ImageCommandData struct {
	ImageName          string
	ImageRemoveOptions image.RemoveOptions
	ImageOperation     string
}

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

type LogCommandData struct {
	EdgeStackID   portainer.EdgeStackID
	EdgeStackName string
	ContainerID   string
	Tail          int
	Since         string
	Until         string
}

type MetaFields struct {
	EdgeGroupsIDs      []int `json:"edgeGroupsIds"`
	TagsIDs            []int `json:"tagsIds"`
	EnvironmentGroupID int   `json:"environmentGroupId"`
}

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

type NormalStackCommandData struct {
	Name             string
	StackFileContent string
	StackOperation   string
	RemoveVolumes    bool
}

type Option func(*options)

type PollStatusResponse struct {
	Status               string                               `json:"status"`
	Port                 int                                  `json:"port"`
	Schedules            []agent.Schedule                     `json:"schedules"`
	CheckinInterval      float64                              `json:"checkin"`
	Credentials          string                               `json:"credentials"`
	Stacks               []StackStatus                        `json:"stacks"`
	EdgeConfigurations   map[EdgeConfigID]EdgeConfigStateType `json:"edge_configurations"`
	PolicyChartSummaries []portainer.PolicyChartSummary       `json:"policy_chart_summaries"`

	// Async mode only
	EndpointID       int            `json:"endpointID"`
	PingInterval     time.Duration  `json:"pingInterval"`
	SnapshotInterval time.Duration  `json:"snapshotInterval"`
	CommandInterval  time.Duration  `json:"commandInterval"`
	AsyncCommands    []AsyncCommand `json:"commands"`
}

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

type PortainerClient interface {
	GetEnvironmentID() (portainer.EndpointID, error)
	GetEnvironmentStatus(flags ...string) (*PollStatusResponse, error)
	GetEdgeStackConfig(edgeStackID int, version *int) (*edge.StackPayload, error)
	SetEdgeStackStatus(edgeStackID, version int, edgeStackStatus portainer.EdgeStackStatusType, rollbackTo *int, errMessage string) error
	SetEdgeJobStatus(edgeJobStatus agent.EdgeJobStatus) error
	GetEdgeConfig(id EdgeConfigID) (*EdgeConfig, error)
	SetEdgeConfigState(id EdgeConfigID, state EdgeConfigStateType) error
	SetTimeout(t time.Duration)
	SetLastCommandTimestamp(timestamp time.Time)
	EnqueueLogCollectionForStack(logCmd LogCommandData)
	GetCharts(chartNames []string) ([]portainer.PolicyChartBundle, portainer.RestoreSettingsBundle, error)
	UpdatePolicyChartStatuses(statuses []portainer.PolicyChartStatus) error
}

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

type StackStatus struct {
	ID               int
	Version          int
	Name             string // used in async mode
	CommandOperation string // used in async mode
	// ForceRedeploy is used to indicate that the stack should be redeployed
	// even if the version is the same this value is set by the server
	ForceRedeploy bool
	// RepullImage is used to indicate that the image should be re-pulled
	// during the next deployment of the stack
	RePullImage bool
}

type VolumeCommandData struct {
	VolumeName      string
	ForceRemove     bool
	VolumeOperation string
}