api

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

type ChiServerOptions struct {
	BaseURL          string
	BaseRouter       chi.Router
	Middlewares      []MiddlewareFunc
	ErrorHandlerFunc func(w http.ResponseWriter, r *http.Request, err error)
}

type CollapseResult struct {
	// AlreadyHuge Chunks MADV_COLLAPSE accepted but were already hugepages (no work)
	AlreadyHuge *int `json:"alreadyHuge,omitempty"`

	// Chunks 2 MiB chunks attempted
	Chunks *int `json:"chunks,omitempty"`

	// Collapsed Chunks whose base pages were actually migrated into a new hugepage (real work)
	Collapsed *int `json:"collapsed,omitempty"`

	// ElapsedMs Wall-clock time spent collapsing, in milliseconds
	ElapsedMs *int64 `json:"elapsedMs,omitempty"`

	// Regions Anonymous read-write regions scanned
	Regions *int `json:"regions,omitempty"`

	// Skipped Chunks that could not be collapsed (empty or ineligible)
	Skipped *int `json:"skipped,omitempty"`
}

type ComposeRequest struct {
	// Destination Destination file path for the composed file
	Destination string `json:"destination"`

	// SourcePaths Ordered list of source file paths to concatenate
	SourcePaths []string `json:"source_paths"`

	// Username User for setting ownership and resolving relative paths
	Username *string `json:"username,omitempty"`
}

type DefaultMMDSClient struct{}

type EntryInfo struct {
	// Metadata User-defined metadata stored as extended attributes on the file.
	Metadata *map[string]string `json:"metadata,omitempty"`

	// Name Name of the file
	Name string `json:"name"`

	// Path Path to the file
	Path string `json:"path"`

	// Type Type of the file
	Type EntryInfoType `json:"type"`
}

type EntryInfoType string

type EnvVars map[string]string

type Error struct {
	// Code Error code
	Code int `json:"code"`

	// Message Error message
	Message string `json:"message"`
}

type FileNotFound = Error

type FilePath = string

type FreezeResult struct {
	// Allowlisted Cgroups skipped because the resume path depends on them (systemd, journald, envd's port forwarding). Reported because the allowlist is expected to grow, and a distro that routes journald differently changes this count
	Allowlisted *int `json:"allowlisted,omitempty"`

	// Failed Cgroups whose freeze write or state read errored (expected for a threaded cgroup, and for one removed mid-sweep)
	Failed *int `json:"failed,omitempty"`

	// Frozen Cgroups that read back "frozen 1" from cgroup.events within the budget; their tasks have stopped
	Frozen *int `json:"frozen,omitempty"`

	// Mode Which sweep actually ran. Echoed back rather than inferred from the flag, so a caller can tell that envd honoured what it asked for
	Mode *FreezeResultMode `json:"mode,omitempty"`

	// NotFrozen Cgroups still reading "frozen 0" when the budget expired; their tasks may still be running, so a snapshot taken now can capture a live workload
	NotFrozen *int `json:"notFrozen,omitempty"`

	// PreFrozen Cgroups the guest itself had already frozen before the sweep ran (docker pause writes cgroup.freeze). Not written to and deliberately left frozen by the resume thaw, so the guest's own suspension survives the snapshot
	PreFrozen *int `json:"preFrozen,omitempty"`

	// Requested Cgroups this call wrote cgroup.freeze to
	Requested *int `json:"requested,omitempty"`

	// SweepMs Time spent issuing the freeze writes, in milliseconds (scales with cgroup count)
	SweepMs *int64 `json:"sweepMs,omitempty"`

	// Truncated True when the walk stopped because it hit the bound rather than because it ran out of tree, so coverage is incomplete
	Truncated *bool `json:"truncated,omitempty"`

	// Unobservable Cgroups whose freeze state cannot be read because this guest has no cgroup manager; the write was accepted but nothing can be read back, so these are neither frozen nor notFrozen
	Unobservable *int `json:"unobservable,omitempty"`

	// Visited Cgroups the walk examined, whether or not it froze them. The input for sizing the bound; meaningless in legacy mode
	Visited *int `json:"visited,omitempty"`

	// WaitMs Time spent polling cgroup.events, in milliseconds (scales with how deep in I/O the guest tasks were). Outcome neutral - the wait ends either because everything stopped or because the budget ran out
	WaitMs *int64 `json:"waitMs,omitempty"`
}

type FreezeResultMode string

type GetFilesParams struct {
	// Path Path to the file, URL encoded. Can be relative to the user's home directory (e.g. "file.txt" resolves to ~/file.txt).
	Path *FilePath `form:"path,omitempty" json:"path,omitempty"`

	// Username User for setting file ownership and resolving relative paths. Defaults to the sandbox's default user.
	Username *User `form:"username,omitempty" json:"username,omitempty"`

	// Signature Signature used for file access permission verification.
	Signature *Signature `form:"signature,omitempty" json:"signature,omitempty"`

	// SignatureExpiration Unix timestamp (seconds) after which the signature expires. Only used with the signature parameter.
	SignatureExpiration *SignatureExpiration `form:"signature_expiration,omitempty" json:"signature_expiration,omitempty"`
}

type InternalServerError = Error

type InvalidParamFormatError struct {
	ParamName string
	Err       error
}

type InvalidPath = Error

type InvalidUser = Error

type MMDSClient interface {
	GetAccessTokenHash(ctx context.Context) (string, error)
}

type Metrics struct {
	// CpuCount Number of CPU cores
	CpuCount *int `json:"cpu_count,omitempty"`

	// CpuUsedPct CPU usage percentage
	CpuUsedPct *float32 `json:"cpu_used_pct,omitempty"`

	// DiskTotal Total disk space in bytes
	DiskTotal *int `json:"disk_total,omitempty"`

	// DiskUsed Used disk space in bytes
	DiskUsed *int `json:"disk_used,omitempty"`

	// MemCache Cached memory (page cache) in bytes
	MemCache *int `json:"mem_cache,omitempty"`

	// MemTotal Total virtual memory in bytes
	MemTotal *int `json:"mem_total,omitempty"`

	// MemTotalMib Total virtual memory in MiB
	MemTotalMib *int `json:"mem_total_mib,omitempty"`

	// MemUsed Used virtual memory in bytes
	MemUsed *int `json:"mem_used,omitempty"`

	// MemUsedMib Used virtual memory in MiB
	MemUsedMib *int `json:"mem_used_mib,omitempty"`

	// Ts Unix timestamp in UTC for current sandbox time
	Ts *int64 `json:"ts,omitempty"`
}

type MiddlewareFunc func(http.Handler) http.Handler

type NotAcceptable = Error

type NotEnoughDiskSpace = Error

type PostFilesComposeJSONRequestBody = ComposeRequest

type PostFilesMultipartBody struct {
	File *openapi_types.File `json:"file,omitempty"`
}

type PostFilesMultipartRequestBody PostFilesMultipartBody

type PostFilesParams struct {
	// Path Path to the file, URL encoded. Can be relative to the user's home directory (e.g. "file.txt" resolves to ~/file.txt).
	Path *FilePath `form:"path,omitempty" json:"path,omitempty"`

	// Username User for setting file ownership and resolving relative paths. Defaults to the sandbox's default user.
	Username *User `form:"username,omitempty" json:"username,omitempty"`

	// Signature Signature used for file access permission verification.
	Signature *Signature `form:"signature,omitempty" json:"signature,omitempty"`

	// SignatureExpiration Unix timestamp (seconds) after which the signature expires. Only used with the signature parameter.
	SignatureExpiration *SignatureExpiration `form:"signature_expiration,omitempty" json:"signature_expiration,omitempty"`
}

type PostFreezeParams struct {
	// Mode Which cgroups to freeze. "hierarchy" freezes the complement of envd's own
	// ancestor chain, so cgroups the customer created anywhere in the tree are
	// covered; "legacy" freezes only the user and pty cgroups envd itself creates.
	// Omitted means legacy, which is what an orchestrator predating this parameter
	// gets.
	//
	// The mode is chosen by the caller because the feature flag that selects it is
	// evaluated there — envd has no access to it. FreezeResult echoes the mode back
	// so the caller can confirm envd honoured the request rather than inferring it
	// from the flag's value: an envd too old to know about modes reports legacy
	// while the flag reads on.
	Mode *PostFreezeParamsMode `form:"mode,omitempty" json:"mode,omitempty"`

	// MaxCgroups Bounds how many cgroups a hierarchy sweep may visit. A safety guard against a
	// pathological or hostile hierarchy rather than a performance knob — the guest is
	// the threat model. Omitted or non-positive means envd's own default. Ignored in
	// legacy mode.
	MaxCgroups *int `form:"maxCgroups,omitempty" json:"maxCgroups,omitempty"`

	// MaxWaitMs How long to wait for the cgroups to read back frozen, in milliseconds. The
	// caller owns this budget because it also owns the request timeout, and a wait
	// longer than that timeout cannot be observed.
	//
	// Supplying it also selects the response: with it, the call waits and answers 200
	// with a FreezeResult; omitted or non-positive, the call does not wait at all and
	// answers 204, which is the contract callers older than this parameter expect.
	MaxWaitMs *int64 `form:"maxWaitMs,omitempty" json:"maxWaitMs,omitempty"`
}

type PostFreezeParamsMode string

type PostInitJSONBody struct {
	// AccessToken Access token for secure access to envd service
	AccessToken *SecureToken `json:"accessToken,omitempty"`

	// CaBundle PEM-encoded CA certificates to install into the system trust store (may contain multiple concatenated PEM blocks)
	CaBundle *string `json:"caBundle,omitempty"`

	// DefaultUser The default user to use for operations
	DefaultUser *string `json:"defaultUser,omitempty"`

	// DefaultWorkdir The default working directory to use for operations
	DefaultWorkdir *string `json:"defaultWorkdir,omitempty"`

	// EnvVars Environment variables to set
	EnvVars *EnvVars `json:"envVars,omitempty"`

	// HyperloopIP IP address of the hyperloop server to connect to
	HyperloopIP *string `json:"hyperloopIP,omitempty"`

	// LifecycleID Lifecycle ID of the sandbox
	LifecycleID *string `json:"lifecycleID,omitempty"`

	// Timestamp The current timestamp in RFC3339 format
	Timestamp    *time.Time     `json:"timestamp,omitempty"`
	VolumeMounts *[]VolumeMount `json:"volumeMounts,omitempty"`
}

type PostInitJSONRequestBody PostInitJSONBody

type RequiredHeaderError struct {
	ParamName string
	Err       error
}

type RequiredParamError struct {
	ParamName string
}

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

type ServerInterface interface {
	// PostCollapse Collapse envd's own anonymous heap into 2 MiB transparent hugepages before pause, so on resume envd touches fewer distinct guest-physical frames (each a cold fault). Best-effort.
	// (POST /collapse)
	PostCollapse(w http.ResponseWriter, r *http.Request)
	// GetEnvs Environment variables
	// (GET /envs)
	GetEnvs(w http.ResponseWriter, r *http.Request)
	// GetFiles Download a file
	// (GET /files)
	GetFiles(w http.ResponseWriter, r *http.Request, params GetFilesParams)
	// PostFiles Upload a file and ensure the parent directories exist. If the file exists, it will be overwritten.
	// (POST /files)
	PostFiles(w http.ResponseWriter, r *http.Request, params PostFilesParams)
	// PostFilesCompose Compose multiple files into a single file using zero-copy concatenation. Source files are deleted after successful composition.
	// (POST /files/compose)
	PostFilesCompose(w http.ResponseWriter, r *http.Request)
	// PostFreeze Freeze user/pty cgroups before pause and wait for them to stop. Written directly by envd to avoid Process.Start / shell overhead under load.
	// (POST /freeze)
	PostFreeze(w http.ResponseWriter, r *http.Request, params PostFreezeParams)
	// PostFsfreeze Freeze the guest rootfs (FIFREEZE) before a filesystem-only pause so it is flushed to a consistent on-disk state, closing the sync->pause race. Idempotent. On a successful filesystem-only pause the VM is rebooted, so no thaw is needed; the orchestrator thaws only on the pause-failure path.
	// (POST /fsfreeze)
	PostFsfreeze(w http.ResponseWriter, r *http.Request)
	// PostFsthaw Thaw the guest rootfs (FITHAW). Intended ONLY for the orchestrator's pause-failure rollback path, so a frozen filesystem cannot leave the live VM deadlocked. Idempotent.
	// (POST /fsthaw)
	PostFsthaw(w http.ResponseWriter, r *http.Request)
	// GetHealth Check the health of the service
	// (GET /health)
	GetHealth(w http.ResponseWriter, r *http.Request)
	// PostInit Set initial vars, ensure the time and metadata is synced with the host
	// (POST /init)
	PostInit(w http.ResponseWriter, r *http.Request)
	// GetMetrics Service stats
	// (GET /metrics)
	GetMetrics(w http.ResponseWriter, r *http.Request)
	// PostUnfreeze Unfreeze user/pty cgroups. Intended ONLY for the orchestrator's pause-failure rollback path; the normal resume thaw happens via /init's deferred unfreeze, not here.
	// (POST /unfreeze)
	PostUnfreeze(w http.ResponseWriter, r *http.Request)
}

type ServerInterfaceWrapper struct {
	Handler            ServerInterface
	HandlerMiddlewares []MiddlewareFunc
	ErrorHandlerFunc   func(w http.ResponseWriter, r *http.Request, err error)
}

type Signature = string

type SignatureExpiration = int

type TooManyValuesForParamError struct {
	ParamName string
	Count     int
}

type UnescapedCookieParamError struct {
	ParamName string
	Err       error
}

type Unimplemented struct{}

type UnmarshalingParamError struct {
	ParamName string
	Err       error
}

type UploadSuccess = []EntryInfo

type User = string

type VolumeMount struct {
	// NfsTarget Server target address
	NfsTarget string `json:"nfs_target"`

	// Path Mount path inside the sandbox
	Path string `json:"path"`
}