ateletpb

type ActorMetadataDataSource struct {

	// items must not project the same field twice.
	//
	// +k8s:required
	// +k8s:minItems=1
	// +k8s:maxItems=8 # matches the template's items bound
	// +k8s:listType=atomic
	// +k8s:unique=map
	// +k8s:listMapKey=field
	Items []*ActorMetadataItem `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"`
	// contains filtered or unexported fields
}

type ActorMetadataField int32

type ActorMetadataItem struct {

	// +k8s:required
	// +k8s:minimum=1
	// +k8s:maximum=3 # keep this in sync with the ActorMetadataField enum
	Field ActorMetadataField `protobuf:"varint,1,opt,name=field,proto3,enum=atelet.ActorMetadataField" json:"field,omitempty"`
	// path must be a clean relative Unix path; the rule is shared with the
	// control plane through internal/resources.
	//
	// +k8s:required
	// +k8s:minLength=1
	// +k8s:maxLength=255
	// +k8s:customValidation # clean relative path
	Path string `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"`
	// contains filtered or unexported fields
}

type ActorSnapshotState struct {

	// The snapshot atelet restores the actor from locally. Unset when the
	// latest checkpoint kept no local copy, and once a detach has made the
	// snapshot durable and begun deleting it. Either way, latest_durable is
	// then the actor's latest snapshot.
	LatestLocal *SnapshotReport `protobuf:"bytes,1,opt,name=latest_local,json=latestLocal,proto3" json:"latest_local,omitempty"`
	// The snapshot an in-flight upload is reading, if any. If it is
	// latest_local, its local copy stays after the upload. If it is an older
	// snapshot, whose upload began before latest_local was taken, atelet
	// deletes its local copy once the upload ends.
	Uploading *SnapshotReport `protobuf:"bytes,2,opt,name=uploading,proto3" json:"uploading,omitempty"`
	// The newest snapshot atelet knows is durable, whether or not the control
	// plane has recorded it: one atelet uploaded since it started, or one a
	// PromoteSnapshot found already uploaded. Unset if there is none, which says
	// nothing about older durable snapshots.
	LatestDurable *SnapshotReport `protobuf:"bytes,3,opt,name=latest_durable,json=latestDurable,proto3" json:"latest_durable,omitempty"`
	// When atelet next plans to trigger a background upload, which will upload
	// whichever snapshot is latest_local at the time of triggering. Unset when
	// there is no latest_local, or it is already durable or being uploaded.
	// Advisory: a promote or detach can upload it sooner, and an older
	// snapshot's upload can delay it.
	UploadDueTime *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=upload_due_time,json=uploadDueTime,proto3" json:"upload_due_time,omitempty"`
	// contains filtered or unexported fields
}

type ArchAssets struct {

	// +k8s:required
	// +k8s:maxProperties=16
	// +k8s:eachKey=+k8s:maxLength=64
	Files map[string]*AssetFile `` // asset name -> file
	/* 137-byte string literal not displayed */
	// contains filtered or unexported fields
}

type AssetFile struct {

	// URL to download the asset from. atelet fetches every URL through the
	// node's object-store plugin, and reads a gs:// URL anonymously only when
	// the plugin cannot serve it.
	// Masked in logged requests, since a signed URL carries its credential in
	// the query.
	//
	// +k8s:required
	// +k8s:maxLength=2048 # matches the SandboxConfig asset url's bound
	Url string `protobuf:"bytes,1,opt,name=url,proto3" json:"url,omitempty"`
	// Lower-case hex SHA256; names the cached file and verifies its integrity.
	//
	// +k8s:required
	// +k8s:maxLength=64
	// +k8s:customValidation # 64 hex characters
	Sha256 string `protobuf:"bytes,2,opt,name=sha256,proto3" json:"sha256,omitempty"`
	// contains filtered or unexported fields
}

type AteomHerderClient interface {
	// Run tells atelet to create a new containerized workload from scratch on an
	// ateom.
	Run(ctx context.Context, in *RunRequest, opts ...grpc.CallOption) (*RunResponse, error)
	// Checkpoint saves the workload's state as a new snapshot of the actor and
	// returns the ateom to a blank state. upload_config says when the snapshot
	// becomes durable. Once ateom has captured the workload, and before the new
	// snapshot is uploaded or stored locally, atelet deletes the actor's older
	// local snapshots, except one still being uploaded, which it deletes when
	// that upload ends. A Checkpoint that then fails to upload or store the new
	// snapshot leaves the actor with no local snapshot.
	Checkpoint(ctx context.Context, in *CheckpointRequest, opts ...grpc.CallOption) (*CheckpointResponse, error)
	// Restore restores a workload from a snapshot onto an ateom.
	Restore(ctx context.Context, in *RestoreRequest, opts ...grpc.CallOption) (*RestoreResponse, error)
	// PromoteSnapshot makes `snapshot` durable in object storage while keeping
	// its local copy on this node. Used when a snapshot needs to be in object
	// storage (e.g. for tagging) without evicting the paused actor from the
	// node. Waits for an in-flight detach, and fails for an actor running on
	// this node.
	//
	// Idempotent: once the snapshot is durable, atelet answers from the
	// manifest at `snapshot.object`, and fails if there is none.
	//
	// TODO: Temporarily, this deletes all of the actor's local snapshots after
	// the upload and does not check whether the actor is running. Its only
	// caller, the suspend of a paused actor, relies on the deletion.
	PromoteSnapshot(ctx context.Context, in *PromoteSnapshotRequest, opts ...grpc.CallOption) (*PromoteSnapshotResponse, error)
	// Terminate tells atelet to terminate/kill any running workload for an actor,
	// unmount its volumes, and clean up actor state on the node.
	Terminate(ctx context.Context, in *TerminateRequest, opts ...grpc.CallOption) (*TerminateResponse, error)
}

type AteomHerderServer interface {
	// Run tells atelet to create a new containerized workload from scratch on an
	// ateom.
	Run(context.Context, *RunRequest) (*RunResponse, error)
	// Checkpoint saves the workload's state as a new snapshot of the actor and
	// returns the ateom to a blank state. upload_config says when the snapshot
	// becomes durable. Once ateom has captured the workload, and before the new
	// snapshot is uploaded or stored locally, atelet deletes the actor's older
	// local snapshots, except one still being uploaded, which it deletes when
	// that upload ends. A Checkpoint that then fails to upload or store the new
	// snapshot leaves the actor with no local snapshot.
	Checkpoint(context.Context, *CheckpointRequest) (*CheckpointResponse, error)
	// Restore restores a workload from a snapshot onto an ateom.
	Restore(context.Context, *RestoreRequest) (*RestoreResponse, error)
	// PromoteSnapshot makes `snapshot` durable in object storage while keeping
	// its local copy on this node. Used when a snapshot needs to be in object
	// storage (e.g. for tagging) without evicting the paused actor from the
	// node. Waits for an in-flight detach, and fails for an actor running on
	// this node.
	//
	// Idempotent: once the snapshot is durable, atelet answers from the
	// manifest at `snapshot.object`, and fails if there is none.
	//
	// TODO: Temporarily, this deletes all of the actor's local snapshots after
	// the upload and does not check whether the actor is running. Its only
	// caller, the suspend of a paused actor, relies on the deletion.
	PromoteSnapshot(context.Context, *PromoteSnapshotRequest) (*PromoteSnapshotResponse, error)
	// Terminate tells atelet to terminate/kill any running workload for an actor,
	// unmount its volumes, and clean up actor state on the node.
	Terminate(context.Context, *TerminateRequest) (*TerminateResponse, error)
	// contains filtered or unexported methods
}

type AteomSupportClient interface {
	// Request an atunnel certificate for the given actor.
	//
	// TODO(identity): Rename to MintAtunnelCertificate, as distinct from
	// MintActorCertificate (which would be used for certificates projected into
	// the actor filesystem, when/if we support those).
	MintActorCertificate(ctx context.Context, in *MintActorCertificateRequest, opts ...grpc.CallOption) (*MintActorCertificateResponse, error)
	// Register capacity and supported sandbox runtimes for this worker with atelet.
	RegisterWorker(ctx context.Context, in *RegisterWorkerRequest, opts ...grpc.CallOption) (*RegisterWorkerResponse, error)
	// RequestActorSuspend asks that the actor this worker hosts be suspended,
	// for atelet to forward to the control plane's WorkerService, which this
	// mirrors.
	//
	// Success means the control plane ran the suspend; an error is its refusal,
	// passed through as it was given, so a worker can tell a decision from a
	// failure to ask. Callers must not hold a lock the resulting Checkpoint
	// would need: the control plane answers this by driving a suspend back
	// through atelet into the calling ateom.
	RequestActorSuspend(ctx context.Context, in *RequestActorSuspendRequest, opts ...grpc.CallOption) (*RequestActorSuspendResponse, error)
	// GetActorEgressPolicy returns the egress policy of the actor this
	// worker hosts, which atelet reads from the control plane's
	// Control.GetActorEgressPolicy. An error is the control plane's, passed
	// through as it was given.
	GetActorEgressPolicy(ctx context.Context, in *GetActorEgressPolicyRequest, opts ...grpc.CallOption) (*GetActorEgressPolicyResponse, error)
}

type AteomSupportServer interface {
	// Request an atunnel certificate for the given actor.
	//
	// TODO(identity): Rename to MintAtunnelCertificate, as distinct from
	// MintActorCertificate (which would be used for certificates projected into
	// the actor filesystem, when/if we support those).
	MintActorCertificate(context.Context, *MintActorCertificateRequest) (*MintActorCertificateResponse, error)
	// Register capacity and supported sandbox runtimes for this worker with atelet.
	RegisterWorker(context.Context, *RegisterWorkerRequest) (*RegisterWorkerResponse, error)
	// RequestActorSuspend asks that the actor this worker hosts be suspended,
	// for atelet to forward to the control plane's WorkerService, which this
	// mirrors.
	//
	// Success means the control plane ran the suspend; an error is its refusal,
	// passed through as it was given, so a worker can tell a decision from a
	// failure to ask. Callers must not hold a lock the resulting Checkpoint
	// would need: the control plane answers this by driving a suspend back
	// through atelet into the calling ateom.
	RequestActorSuspend(context.Context, *RequestActorSuspendRequest) (*RequestActorSuspendResponse, error)
	// GetActorEgressPolicy returns the egress policy of the actor this
	// worker hosts, which atelet reads from the control plane's
	// Control.GetActorEgressPolicy. An error is the control plane's, passed
	// through as it was given.
	GetActorEgressPolicy(context.Context, *GetActorEgressPolicyRequest) (*GetActorEgressPolicyResponse, error)
	// contains filtered or unexported methods
}

type AttributeEntry struct {

	// Attribute name (e.g. "architecture", "cpu_features", "gvisor_asset_hash").
	//
	// +k8s:required
	// +k8s:maxLength=128
	Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	// Attribute value corresponding to key.
	//
	// +k8s:required
	// +k8s:maxLength=256
	Value string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	// contains filtered or unexported fields
}

type Capabilities struct {

	// +k8s:optional
	// +k8s:maxItems=64
	// +k8s:listType=set
	// +k8s:customValidation # capability grammar; "ALL" not accepted
	Add []string `protobuf:"bytes,1,rep,name=add,proto3" json:"add,omitempty"`
	// +k8s:optional
	// +k8s:maxItems=64
	// +k8s:listType=set
	// +k8s:customValidation # capability grammar
	Drop []string `protobuf:"bytes,2,rep,name=drop,proto3" json:"drop,omitempty"`
	// contains filtered or unexported fields
}

type CheckpointRequest struct {

	// The UID of the worker pod whose ateom hosts the actor.
	//
	// +k8s:required
	// +k8s:format=k8s-uuid
	WorkerPodUid string `protobuf:"bytes,1,opt,name=worker_pod_uid,json=workerPodUid,proto3" json:"worker_pod_uid,omitempty"`
	// +k8s:required
	// +k8s:format=k8s-short-name
	Atespace string `protobuf:"bytes,2,opt,name=atespace,proto3" json:"atespace,omitempty"`
	// +k8s:required
	// +k8s:format=k8s-short-name
	ActorName string `protobuf:"bytes,3,opt,name=actor_name,json=actorName,proto3" json:"actor_name,omitempty"`
	// +k8s:required
	// +k8s:format=k8s-uuid
	ActorUid string `protobuf:"bytes,4,opt,name=actor_uid,json=actorUid,proto3" json:"actor_uid,omitempty"`
	// The template identity is carried for metrics attribution.
	//
	// +k8s:optional
	// +k8s:format=k8s-short-name
	ActorTemplateAtespace string `` /* 126-byte string literal not displayed */
	// +k8s:optional
	// +k8s:format=k8s-short-name
	ActorTemplateName string `protobuf:"bytes,6,opt,name=actor_template_name,json=actorTemplateName,proto3" json:"actor_template_name,omitempty"`
	// Sandbox binary config is not sent on checkpoint: atelet uses the version the
	// actor is currently running (recorded with the actor's on-node state at
	// Run/Restore) and records it into the snapshot manifest.
	//
	// +k8s:required
	Spec *WorkloadSpec `protobuf:"bytes,7,opt,name=spec,proto3" json:"spec,omitempty"`
	// The snapshot to take, and where it is uploaded. atelet may upload it long
	// after Checkpoint returns, without asking the control plane. A request at
	// atelet's newest generation for the actor, with the same snapshot_uuid,
	// is a retry: atelet returns the actor's current state without
	// checkpointing again.
	//
	// TODO: Temporarily, atelet does not recognize retries. A retry runs the
	// checkpoint again, which fails once an earlier attempt has removed the
	// workload.
	//
	// +k8s:required
	Snapshot *Snapshot `protobuf:"bytes,8,opt,name=snapshot,proto3" json:"snapshot,omitempty"`
	// When the snapshot becomes durable.
	//
	// +k8s:required
	UploadConfig *UploadConfig `protobuf:"bytes,9,opt,name=upload_config,json=uploadConfig,proto3" json:"upload_config,omitempty"`
	// contains filtered or unexported fields
}

type CheckpointResponse struct {

	// The actor's state once the checkpoint is taken: latest_local is the new
	// snapshot, unless UPLOAD_MODE_IMMEDIATE kept no local copy. The control
	// plane can drop its entries for any local-only generation not named here:
	// atelet has deleted it, and will never upload it.
	//
	// TODO: Temporarily, atelet leaves this unset. An unset state says nothing
	// about which snapshots atelet holds.
	State *ActorSnapshotState `protobuf:"bytes,1,opt,name=state,proto3" json:"state,omitempty"`
	// contains filtered or unexported fields
}

type Container struct {

	// +k8s:required
	// +k8s:format=k8s-short-name
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// +k8s:required
	// +k8s:maxLength=512 # matches the template Container.image's bound
	// +k8s:customValidation # must be a well-formed image reference, pinned by digest
	Image string `protobuf:"bytes,2,opt,name=image,proto3" json:"image,omitempty"`
	// +k8s:optional
	// +k8s:maxItems=64
	// +k8s:listType=atomic
	// +k8s:eachVal=+k8s:maxLength=4096 # argv strings; guardrail, not a contract
	Command []string `protobuf:"bytes,3,rep,name=command,proto3" json:"command,omitempty"`
	// +k8s:optional
	// +k8s:maxItems=64
	// +k8s:listType=atomic
	// +k8s:eachVal=+k8s:maxLength=4096 # argv strings; guardrail, not a contract
	Args []string `protobuf:"bytes,7,rep,name=args,proto3" json:"args,omitempty"`
	// +k8s:optional
	// +k8s:maxItems=32 # matches the template's env bound
	// +k8s:listType=map # each variable is set at most once
	// +k8s:listMapKey=name
	Env []*EnvEntry `protobuf:"bytes,4,rep,name=env,proto3" json:"env,omitempty"`
	// +k8s:optional
	WakeupProbe *WakeupProbe `protobuf:"bytes,5,opt,name=wakeup_probe,json=wakeupProbe,proto3" json:"wakeup_probe,omitempty"`
	// Keyed by mount_path: each path hosts exactly one mount, while a volume
	// may be mounted at multiple paths.
	//
	// +k8s:optional
	// +k8s:maxItems=32 # matches the template's volume_mounts bound
	// +k8s:listType=map
	// +k8s:listMapKey=mount_path
	// +k8s:customValidation # mounts must not nest
	VolumeMounts []*VolumeMount `protobuf:"bytes,6,rep,name=volume_mounts,json=volumeMounts,proto3" json:"volume_mounts,omitempty"`
	// +k8s:optional
	SecurityContext *SecurityContext `protobuf:"bytes,8,opt,name=security_context,json=securityContext,proto3" json:"security_context,omitempty"`
	// resources are the cgroup limits for this container, resolved by
	// ate-api-server from the ActorTemplate. Unset means no limits.
	//
	// +k8s:optional
	Resources *ResourceLimits `protobuf:"bytes,9,opt,name=resources,proto3" json:"resources,omitempty"`
	// contains filtered or unexported fields
}

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

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

type EgressDestinations struct {

	// Hostnames as the control plane's rule has them, wildcards included.
	Hostnames []string `protobuf:"bytes,1,rep,name=hostnames,proto3" json:"hostnames,omitempty"`
	// The ports the rule allows, with the control plane's defaults applied.
	Ports *EgressPorts `protobuf:"bytes,2,opt,name=ports,proto3" json:"ports,omitempty"`
	// contains filtered or unexported fields
}

type EgressGateway struct {

	// address is required and identifies the remote gateway as an IP address or
	// DNS name followed by its port.
	//
	// +k8s:required
	// +k8s:maxLength=261 # a bracketed or 253-character host, ':' and a 5-digit port
	// +k8s:customValidation # host:port shape
	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
	// contains filtered or unexported fields
}

type EgressPolicy struct {

	// Rules are an unordered set of allows, as in the control plane's policy.
	Rules []*EgressRule `protobuf:"bytes,1,rep,name=rules,proto3" json:"rules,omitempty"`
	// contains filtered or unexported fields
}

type EgressPorts struct {

	// Set if the rule allows every port.
	All *EgressAllPorts `protobuf:"bytes,1,opt,name=all,proto3" json:"all,omitempty"`
	// The port numbers the rule allows, when all is unset.
	Numbers []int32 `protobuf:"varint,2,rep,packed,name=numbers,proto3" json:"numbers,omitempty"`
	// contains filtered or unexported fields
}

type EgressRule struct {

	// Cleartext HTTP to the named hosts.
	Http *EgressDestinations `protobuf:"bytes,1,opt,name=http,proto3" json:"http,omitempty"`
	// HTTPS to the named hosts, intercepted by the egress gateway.
	Https *EgressDestinations `protobuf:"bytes,2,opt,name=https,proto3" json:"https,omitempty"`
	// TLS to the named servers, forwarded without decryption.
	TlsPassthrough *EgressDestinations `protobuf:"bytes,3,opt,name=tls_passthrough,json=tlsPassthrough,proto3" json:"tls_passthrough,omitempty"`
	// contains filtered or unexported fields
}

type EnvEntry struct {

	// name may be any printable ASCII character except '='.
	//
	// +k8s:required
	// +k8s:maxLength=256 # guardrail
	// +k8s:customValidation # printable ASCII except '='
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// +k8s:optional
	// +k8s:maxLength=32768 # guardrail
	Value string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	// contains filtered or unexported fields
}

type ExternalVolumeSource struct {

	// Required, unlike the actor status counterpart: the control plane only
	// sends volumes that finished provisioning.
	//
	// +k8s:required
	// +k8s:maxLength=256 # matches ExternalVolume.storage_volume_id's bound
	// +k8s:customValidation # no control characters
	StorageVolumeId string `protobuf:"bytes,1,opt,name=storage_volume_id,json=storageVolumeId,proto3" json:"storage_volume_id,omitempty"`
	// +k8s:optional
	// +k8s:maxLength=253 # matches ExternalVolume.volume_type's bound
	// +k8s:customValidation # optional "substrate.io/" prefix + DNS subdomain
	VolumeType string `protobuf:"bytes,2,opt,name=volume_type,json=volumeType,proto3" json:"volume_type,omitempty"`
	// volume_context is the driver's provisioning metadata. Its entries are the
	// driver's own, so the map is only bounded, not validated.
	//
	// +k8s:optional
	// +k8s:customValidation # at most 40 KiB in total, ten times the CSI limit for map fields
	VolumeContext map[string]string `` /* 174-byte string literal not displayed */
	// publish_context is the driver's attachment metadata for this node, which
	// the node plugin needs to complete the mount. Bounded like volume_context.
	//
	// +k8s:optional
	// +k8s:customValidation # at most 40 KiB in total, ten times the CSI limit for map fields
	PublishContext map[string]string `` /* 177-byte string literal not displayed */
	// contains filtered or unexported fields
}

type GetActorEgressPolicyRequest struct {

	// The actor the calling worker is hosting. atelet reads its policy from the
	// control plane by name.
	//
	// +k8s:required
	// +k8s:format=k8s-short-name
	ActorAtespace string `protobuf:"bytes,1,opt,name=actor_atespace,json=actorAtespace,proto3" json:"actor_atespace,omitempty"`
	// +k8s:required
	// +k8s:format=k8s-short-name
	ActorName string `protobuf:"bytes,2,opt,name=actor_name,json=actorName,proto3" json:"actor_name,omitempty"`
	// contains filtered or unexported fields
}

type GetActorEgressPolicyResponse struct {

	// The actor's policy, copied from the control plane's. Unset if the actor
	// has no policy, which denies all of its egress, DNS included.
	EgressPolicy *EgressPolicy `protobuf:"bytes,1,opt,name=egress_policy,json=egressPolicy,proto3" json:"egress_policy,omitempty"`
	// contains filtered or unexported fields
}

type HttpGetAction struct {

	// Path to access on the HTTP server.
	//
	// +k8s:required
	// +k8s:maxLength=1024 # matches the template probe path's bound
	// +k8s:customValidation # RFC 3986 path shape; no regex/pattern tag exists
	Path string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
	// TCP port to connect to (1..65535).
	//
	// +k8s:required
	// +k8s:minimum=1
	// +k8s:maximum=65535
	Port int32 `protobuf:"varint,2,opt,name=port,proto3" json:"port,omitempty"`
	// contains filtered or unexported fields
}

type ImageVolumeSource struct {

	// reference is the OCI image reference, pinned by digest.
	//
	// +k8s:required
	// +k8s:maxLength=512 # matches the template ImageVolumeSource.reference's bound
	// +k8s:customValidation # must be a well-formed image reference, pinned by digest
	Reference string `protobuf:"bytes,1,opt,name=reference,proto3" json:"reference,omitempty"`
	// contains filtered or unexported fields
}

type Limits struct {

	// +k8s:required
	// +k8s:maxLength=16 # the Limits hook restricts values to cpu/memory
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// quantity is in Kubernetes resource.Quantity string form (e.g. "500m",
	// "2Gi").
	//
	// +k8s:required
	// +k8s:maxLength=32 # the Limits hook requires a parseable quantity
	Quantity string `protobuf:"bytes,2,opt,name=quantity,proto3" json:"quantity,omitempty"`
	// contains filtered or unexported fields
}

type MintActorCertificateRequest struct {

	// The actor for which the certificate should be issued.
	//
	// +k8s:required
	// +k8s:format=k8s-short-name
	ActorAtespace string `protobuf:"bytes,3,opt,name=actor_atespace,json=actorAtespace,proto3" json:"actor_atespace,omitempty"`
	// +k8s:required
	// +k8s:format=k8s-short-name
	ActorName string `protobuf:"bytes,4,opt,name=actor_name,json=actorName,proto3" json:"actor_name,omitempty"`
	// The UID of the actor --- used to guard against deletion and recreation of
	// an actor with the same name.
	//
	// +k8s:required
	// +k8s:format=k8s-uuid
	ActorUid string `protobuf:"bytes,5,opt,name=actor_uid,json=actorUid,proto3" json:"actor_uid,omitempty"`
	// DER-encoded PKCS #10 certificate signing request. Atunnel retains the
	// corresponding private key.
	//
	// +k8s:required
	// +k8s:maxBytes=16384 # matches the control-plane MintActorCertificateRequest bound this is forwarded to
	CertificateSigningRequest []byte `` /* 138-byte string literal not displayed */
	// contains filtered or unexported fields
}

type MintActorCertificateResponse struct {

	// DER-encoded leaf followed by any intermediate certificates.
	ActorCertificates [][]byte `protobuf:"bytes,1,rep,name=actor_certificates,json=actorCertificates,proto3" json:"actor_certificates,omitempty"`
	// contains filtered or unexported fields
}

type ObjectStorage struct {

	// The object storage URI of the snapshot. Object names are appended to it,
	// so it addresses the snapshot as a whole rather than any one object.
	//
	// +k8s:required
	// +k8s:maxLength=2048
	// +k8s:customValidation # a parseable snapshot URI
	SnapshotUri string `protobuf:"bytes,1,opt,name=snapshot_uri,json=snapshotUri,proto3" json:"snapshot_uri,omitempty"`
	// contains filtered or unexported fields
}

type PromoteSnapshotRequest struct {

	// Golden actors are never paused, so the golden atespace is rejected.
	//
	// +k8s:required
	// +k8s:format=k8s-short-name
	// +k8s:customValidation # not the golden atespace
	Atespace string `protobuf:"bytes,1,opt,name=atespace,proto3" json:"atespace,omitempty"`
	// +k8s:required
	// +k8s:format=k8s-short-name
	ActorName string `protobuf:"bytes,2,opt,name=actor_name,json=actorName,proto3" json:"actor_name,omitempty"`
	// +k8s:required
	// +k8s:format=k8s-uuid
	ActorUid string `protobuf:"bytes,3,opt,name=actor_uid,json=actorUid,proto3" json:"actor_uid,omitempty"`
	// For metrics attribution, like on CheckpointRequest.
	//
	// +k8s:optional
	// +k8s:format=k8s-short-name
	ActorTemplateAtespace string `` /* 126-byte string literal not displayed */
	// +k8s:optional
	// +k8s:format=k8s-short-name
	ActorTemplateName string `protobuf:"bytes,5,opt,name=actor_template_name,json=actorTemplateName,proto3" json:"actor_template_name,omitempty"`
	// The actor's latest snapshot as the control plane records it, and where
	// it is, or will be, uploaded.
	//
	// +k8s:required
	// +k8s:subfield(object)=+k8s:required
	Snapshot *Snapshot `protobuf:"bytes,6,opt,name=snapshot,proto3" json:"snapshot,omitempty"`
	// contains filtered or unexported fields
}

type PromoteSnapshotResponse struct {

	// The actor's state once promoted: latest_durable is its latest snapshot,
	// and latest_local remains set if atelet still holds the local copy.
	//
	// TODO: Temporarily, atelet leaves this unset. An unset state says nothing
	// about which snapshots atelet holds.
	State *ActorSnapshotState `protobuf:"bytes,1,opt,name=state,proto3" json:"state,omitempty"`
	// contains filtered or unexported fields
}

type RegisterWorkerRequest struct {

	// What the worker can supply. atelet converts it to the control plane's
	// WorkerResources when forwarding.
	//
	// +k8s:required
	Capacity *WorkerResources `protobuf:"bytes,1,opt,name=capacity,proto3" json:"capacity,omitempty"`
	// Runtime that new and cold-booted actors start under.
	// Snapshots matching default_runtime can also warm-boot on this worker.
	// atelet converts it to the control plane's SandboxRuntime when forwarding.
	//
	// +k8s:required
	DefaultRuntime *SandboxRuntime `protobuf:"bytes,2,opt,name=default_runtime,json=defaultRuntime,proto3" json:"default_runtime,omitempty"`
	// Additional runtimes (excluding default_runtime) that this worker can
	// restore snapshots from right now.
	//
	// +k8s:optional
	// +k8s:maxItems=32
	// +k8s:listType=atomic
	RestorableRuntimes []*SandboxRuntime `protobuf:"bytes,3,rep,name=restorable_runtimes,json=restorableRuntimes,proto3" json:"restorable_runtimes,omitempty"`
	// contains filtered or unexported fields
}

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

type RequestActorSuspendRequest struct {

	// The actor the calling worker is hosting. atelet forwards this to the
	// control plane, which serves it only if the actor is assigned to the worker
	// the caller's certificate names.
	//
	// +k8s:required
	// +k8s:format=k8s-short-name
	ActorAtespace string `protobuf:"bytes,1,opt,name=actor_atespace,json=actorAtespace,proto3" json:"actor_atespace,omitempty"`
	// +k8s:required
	// +k8s:format=k8s-short-name
	ActorName string `protobuf:"bytes,2,opt,name=actor_name,json=actorName,proto3" json:"actor_name,omitempty"`
	// The UID of the actor --- used to guard against deletion and recreation of
	// an actor with the same name, as for MintActorCertificate.
	//
	// +k8s:required
	// +k8s:format=k8s-uuid
	ActorUid string `protobuf:"bytes,3,opt,name=actor_uid,json=actorUid,proto3" json:"actor_uid,omitempty"`
	// contains filtered or unexported fields
}

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

type ResourceLimits struct {

	// memory_bytes is the memory limit in bytes. 0 means unset.
	//
	// +k8s:optional
	// +k8s:minimum=0
	MemoryBytes int64 `protobuf:"varint,1,opt,name=memory_bytes,json=memoryBytes,proto3" json:"memory_bytes,omitempty"`
	// cpu_millis is the CPU limit in milli-cores (1000 = one core). 0 means unset.
	//
	// +k8s:optional
	// +k8s:minimum=0
	// +k8s:maximum=999999 # the control plane caps cpu limits strictly below 1000 cores
	CpuMillis int64 `protobuf:"varint,2,opt,name=cpu_millis,json=cpuMillis,proto3" json:"cpu_millis,omitempty"`
	// contains filtered or unexported fields
}

type Resources struct {

	// limits is the maximum amount of compute resources allowed. Only "cpu"
	// and "memory" are supported, each at most once, and each quantity must be
	// greater than zero; the cpu limit must be less than 1000 cores.
	//
	// +k8s:optional
	// +k8s:maxItems=2
	// +k8s:listType=map
	// +k8s:listMapKey=name
	Limits []*Limits `protobuf:"bytes,1,rep,name=limits,proto3" json:"limits,omitempty"`
	// contains filtered or unexported fields
}

type RestoreRequest struct {

	// The UID of the worker pod whose ateom hosts the actor.
	//
	// +k8s:required
	// +k8s:format=k8s-uuid
	WorkerPodUid string `protobuf:"bytes,1,opt,name=worker_pod_uid,json=workerPodUid,proto3" json:"worker_pod_uid,omitempty"`
	// +k8s:required
	// +k8s:format=k8s-short-name
	Atespace string `protobuf:"bytes,2,opt,name=atespace,proto3" json:"atespace,omitempty"`
	// +k8s:required
	// +k8s:format=k8s-short-name
	ActorName string `protobuf:"bytes,3,opt,name=actor_name,json=actorName,proto3" json:"actor_name,omitempty"`
	// +k8s:required
	// +k8s:format=k8s-uuid
	ActorUid string `protobuf:"bytes,4,opt,name=actor_uid,json=actorUid,proto3" json:"actor_uid,omitempty"`
	// The template identity is carried for metrics attribution.
	//
	// +k8s:optional
	// +k8s:format=k8s-short-name
	ActorTemplateAtespace string `` /* 126-byte string literal not displayed */
	// +k8s:optional
	// +k8s:format=k8s-short-name
	ActorTemplateName string `protobuf:"bytes,6,opt,name=actor_template_name,json=actorTemplateName,proto3" json:"actor_template_name,omitempty"`
	// +k8s:required
	Spec *WorkloadSpec `protobuf:"bytes,7,opt,name=spec,proto3" json:"spec,omitempty"`
	// Snapshot to restore from. atelet reads its local copy if it holds a
	// usable one, and `snapshot.object` otherwise. A local copy is unusable if
	// its manifest does not parse or lists a missing file. While atelet is
	// detaching the actor, it waits for the detach to finish and then reads
	// `snapshot.object`. Fails if neither copy exists: that generation is lost.
	//
	// TODO: Temporarily, the control plane does not set `snapshot.object` when
	// it restores a paused actor, so atelet has nothing to fall back to if that
	// actor's local copy is missing or unusable.
	//
	// +k8s:required
	Snapshot *Snapshot `protobuf:"bytes,8,opt,name=snapshot,proto3" json:"snapshot,omitempty"`
	// When absent the actor has no egress: its TCP is captured and refused.
	//
	// +k8s:optional
	EgressGateway *EgressGateway `protobuf:"bytes,13,opt,name=egress_gateway,json=egressGateway,proto3,oneof" json:"egress_gateway,omitempty"`
	// The actor's declared size, from the ActorTemplate's resource limits. For
	// gVisor and micro-VM VOLUMES restores the sandbox is (re)sized to these;
	// for a MEMORY micro-VM restore the size baked into the snapshot wins. Zero
	// means "unset": keep the runtime default.
	//
	// +k8s:optional
	// +k8s:minimum=0
	// +k8s:maximum=999999 # the control plane caps cpu limits strictly below 1000 cores
	CpuMilli int64 `protobuf:"varint,14,opt,name=cpu_milli,json=cpuMilli,proto3" json:"cpu_milli,omitempty"` // CPU limit in millicores (1000 = one core).
	// +k8s:optional
	// +k8s:minimum=0
	MemoryBytes int64 `protobuf:"varint,15,opt,name=memory_bytes,json=memoryBytes,proto3" json:"memory_bytes,omitempty"` // Memory limit in bytes.
	// The sandbox binaries and pause image to restore with, resolved from the
	// ActorTemplate's SandboxConfig.
	//
	// +k8s:required
	SandboxAssets *SandboxAssets `protobuf:"bytes,16,opt,name=sandbox_assets,json=sandboxAssets,proto3" json:"sandbox_assets,omitempty"`
	// contains filtered or unexported fields
}

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

type RunRequest struct {

	// The UID of the worker pod whose ateom hosts the actor.
	//
	// +k8s:required
	// +k8s:format=k8s-uuid
	WorkerPodUid string `protobuf:"bytes,1,opt,name=worker_pod_uid,json=workerPodUid,proto3" json:"worker_pod_uid,omitempty"`
	// +k8s:required
	// +k8s:format=k8s-short-name
	Atespace string `protobuf:"bytes,2,opt,name=atespace,proto3" json:"atespace,omitempty"`
	// +k8s:required
	// +k8s:format=k8s-short-name
	ActorName string `protobuf:"bytes,3,opt,name=actor_name,json=actorName,proto3" json:"actor_name,omitempty"`
	// +k8s:required
	// +k8s:format=k8s-uuid
	ActorUid string `protobuf:"bytes,4,opt,name=actor_uid,json=actorUid,proto3" json:"actor_uid,omitempty"`
	// The template identity is carried for metrics attribution.
	//
	// +k8s:optional
	// +k8s:format=k8s-short-name
	ActorTemplateAtespace string `` /* 126-byte string literal not displayed */
	// +k8s:optional
	// +k8s:format=k8s-short-name
	ActorTemplateName string `protobuf:"bytes,6,opt,name=actor_template_name,json=actorTemplateName,proto3" json:"actor_template_name,omitempty"`
	// +k8s:required
	Spec *WorkloadSpec `protobuf:"bytes,7,opt,name=spec,proto3" json:"spec,omitempty"`
	// The sandbox binaries to use for booting this actor from scratch. atelet
	// fetches the relevant assets and records them with the actor's on-node state
	// so a later Checkpoint can pin the same version into the snapshot manifest.
	//
	// +k8s:required
	SandboxAssets *SandboxAssets `protobuf:"bytes,8,opt,name=sandbox_assets,json=sandboxAssets,proto3" json:"sandbox_assets,omitempty"`
	// When absent the actor has no egress: its TCP is captured and refused.
	//
	// +k8s:optional
	EgressGateway *EgressGateway `protobuf:"bytes,9,opt,name=egress_gateway,json=egressGateway,proto3,oneof" json:"egress_gateway,omitempty"`
	// The actor's declared size, from the ActorTemplate's resource limits. atelet
	// passes these through to the sandbox so it is sized to the actor (not the
	// whole host or worker pod). Zero means "unset": keep the runtime default.
	//
	// +k8s:optional
	// +k8s:minimum=0
	// +k8s:maximum=999999 # the control plane caps cpu limits strictly below 1000 cores
	CpuMilli int64 `protobuf:"varint,10,opt,name=cpu_milli,json=cpuMilli,proto3" json:"cpu_milli,omitempty"` // CPU limit in millicores (1000 = one core).
	// +k8s:optional
	// +k8s:minimum=0
	MemoryBytes int64 `protobuf:"varint,11,opt,name=memory_bytes,json=memoryBytes,proto3" json:"memory_bytes,omitempty"` // Memory limit in bytes.
	// contains filtered or unexported fields
}

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

type SandboxAssets struct {

	// +k8s:required
	// +k8s:maxLength=63 # guardrail; the class names are a few characters
	// +k8s:customValidation # gvisor or microvm
	SandboxClass string `protobuf:"bytes,1,opt,name=sandbox_class,json=sandboxClass,proto3" json:"sandbox_class,omitempty"` // e.g. "gvisor"
	// +k8s:required
	// +k8s:maxProperties=8 # one entry per architecture
	// +k8s:eachKey=+k8s:maxLength=16
	Assets map[string]*ArchAssets `` // arch -> {name -> file}
	/* 139-byte string literal not displayed */
	// pause_image is the image for the sandbox's root container. Like the
	// binaries above it is sandbox configuration, not workload configuration,
	// and atelet pins it into the snapshot manifest so a restore rebuilds the
	// sandbox from the same image. Empty for sandboxes without a pause
	// container (microvm).
	//
	// +k8s:optional
	// +k8s:maxLength=512
	// +k8s:customValidation # must be a well-formed image reference, pinned by digest
	PauseImage string `protobuf:"bytes,3,opt,name=pause_image,json=pauseImage,proto3" json:"pause_image,omitempty"`
	// contains filtered or unexported fields
}

type SandboxRuntime struct {

	// e.g. "gvisor", "microvm"
	//
	// +k8s:required
	// +k8s:maxLength=63
	// +k8s:customValidation # gvisor or microvm
	SandboxClass string `protobuf:"bytes,1,opt,name=sandbox_class,json=sandboxClass,proto3" json:"sandbox_class,omitempty"`
	// Primary compatibility version stamped onto an actor's snapshot when a
	// checkpoint is taken on this runtime. Snapshots matching `version`
	// can warm-boot on this runtime.
	// TODO: Add support for additional compatibility versions.
	//
	// +k8s:required
	Version *VersionedSandboxCompat `protobuf:"bytes,2,opt,name=version,proto3" json:"version,omitempty"`
	// contains filtered or unexported fields
}

type SecurityContext struct {

	// +k8s:optional
	Capabilities *Capabilities `protobuf:"bytes,1,opt,name=capabilities,proto3" json:"capabilities,omitempty"`
	// contains filtered or unexported fields
}

type Snapshot struct {

	// ateapi Snapshot.uuid. Names the snapshot's directory under the actor's
	// local-checkpoint directory, so this is a bare name and must not contain
	// a path separator.
	//
	// +k8s:required
	// +k8s:format=k8s-short-name
	SnapshotUuid string `protobuf:"bytes,1,opt,name=snapshot_uuid,json=snapshotUuid,proto3" json:"snapshot_uuid,omitempty"`
	// ateapi Snapshot.generation, starting at 1. Orders the actor's snapshots.
	// Checkpoint and PromoteSnapshot fail for a generation below atelet's newest
	// for the actor, or for its newest under another snapshot_uuid: the
	// caller's view is stale.
	//
	// TODO: Temporarily, the control plane does not set this and atelet does
	// not check it.
	//
	// +k8s:optional
	Generation int32 `protobuf:"varint,2,opt,name=generation,proto3" json:"generation,omitempty"`
	// On Checkpoint: the fidelity to capture.
	// On Restore: the fidelity to restore the actor with.
	// On PromoteSnapshot: the lowest fidelity the snapshot may hold. The call
	// fails if its manifest records a lower one.
	// In SnapshotReport: the fidelity the snapshot holds.
	//
	// TODO: Open question: should PromoteSnapshot accept a manifest that records
	// a higher fidelity than this? Until that is decided, atelet requires the
	// two to be equal.
	//
	// +k8s:required
	// +k8s:minimum=1
	// +k8s:maximum=3 # keep this in sync with the SnapshotFidelity enum
	Fidelity SnapshotFidelity `protobuf:"varint,3,opt,name=fidelity,proto3,enum=atelet.SnapshotFidelity" json:"fidelity,omitempty"`
	// The snapshot's durable copy in object storage. Required on every
	// request: atelet uploads there, or reads from there when it holds no
	// usable local copy.
	//
	// TODO: Temporarily, this is optional while we haven't implemented deferred
	// uploads.
	//
	// +k8s:optional
	Object *ObjectStorage `protobuf:"bytes,4,opt,name=object,proto3" json:"object,omitempty"`
	// contains filtered or unexported fields
}

type SnapshotFidelity int32

type SnapshotReport struct {
	Snapshot *Snapshot `protobuf:"bytes,1,opt,name=snapshot,proto3" json:"snapshot,omitempty"`
	// When the checkpoint that produced the snapshot committed on this node.
	LocalCommitTime *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=local_commit_time,json=localCommitTime,proto3" json:"local_commit_time,omitempty"`
	// When the snapshot's manifest, the upload's commit marker, was written to
	// object storage. Set only in ActorSnapshotState.latest_durable, and only
	// when this atelet wrote it.
	DurableCompleteTime *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=durable_complete_time,json=durableCompleteTime,proto3" json:"durable_complete_time,omitempty"`
	// contains filtered or unexported fields
}

type SystemInfoDataSource struct {

	// Exactly one of actor_metadata / trust_bundle must be set.
	//
	// +k8s:optional
	// +k8s:unionMember
	ActorMetadata *ActorMetadataDataSource `protobuf:"bytes,1,opt,name=actor_metadata,json=actorMetadata,proto3" json:"actor_metadata,omitempty"`
	// +k8s:optional
	// +k8s:unionMember
	TrustBundle *TrustBundleDataSource `protobuf:"bytes,2,opt,name=trust_bundle,json=trustBundle,proto3" json:"trust_bundle,omitempty"`
	// contains filtered or unexported fields
}

type SystemInfoVolume struct {

	// +k8s:optional
	// +k8s:maxItems=8 # matches the template's data_sources bound
	// +k8s:listType=atomic
	// +k8s:customValidation # at most one actor_metadata; paths unique across entries
	DataSources []*SystemInfoDataSource `protobuf:"bytes,1,rep,name=data_sources,json=dataSources,proto3" json:"data_sources,omitempty"`
	// contains filtered or unexported fields
}

type TerminateRequest struct {

	// The UID of the worker pod whose ateom hosts the actor. If unset, atelet
	// only cleans up the actor's node resources; it does not reach an ateom.
	//
	// +k8s:optional
	// +k8s:format=k8s-uuid
	WorkerPodUid string `protobuf:"bytes,1,opt,name=worker_pod_uid,json=workerPodUid,proto3" json:"worker_pod_uid,omitempty"`
	// +k8s:required
	// +k8s:format=k8s-short-name
	Atespace string `protobuf:"bytes,2,opt,name=atespace,proto3" json:"atespace,omitempty"`
	// +k8s:required
	// +k8s:format=k8s-short-name
	ActorName string `protobuf:"bytes,3,opt,name=actor_name,json=actorName,proto3" json:"actor_name,omitempty"`
	// +k8s:required
	// +k8s:format=k8s-uuid
	ActorUid string `protobuf:"bytes,4,opt,name=actor_uid,json=actorUid,proto3" json:"actor_uid,omitempty"`
	// The template identity is carried for metrics attribution.
	//
	// +k8s:optional
	// +k8s:format=k8s-short-name
	ActorTemplateAtespace string `` /* 126-byte string literal not displayed */
	// +k8s:optional
	// +k8s:format=k8s-short-name
	ActorTemplateName string `protobuf:"bytes,6,opt,name=actor_template_name,json=actorTemplateName,proto3" json:"actor_template_name,omitempty"`
	// A nil spec is tolerated: the delete flow terminates template-less
	// actors with a fallback spec.
	//
	// +k8s:optional
	Spec *WorkloadSpec `protobuf:"bytes,7,opt,name=spec,proto3" json:"spec,omitempty"`
	// contains filtered or unexported fields
}

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

type TrustBundleDataSource struct {

	// path must be a clean relative Unix path; the rule is shared with the
	// control plane through internal/resources.
	//
	// +k8s:required
	// +k8s:minLength=1
	// +k8s:maxLength=255
	// +k8s:customValidation # clean relative path
	Path string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
	// +k8s:required
	// +k8s:minItems=1
	// +k8s:maxItems=8 # matches the template's names bound
	// +k8s:listType=set
	// +k8s:eachVal=+k8s:minLength=1
	// +k8s:eachVal=+k8s:maxLength=253 # matches the template's bundle-name bound
	Names []string `protobuf:"bytes,3,rep,name=names,proto3" json:"names,omitempty"`
	// contains filtered or unexported fields
}

type UnimplementedAteomHerderServer struct{}

type UnimplementedAteomSupportServer struct{}

type UnsafeAteomHerderServer interface {
	// contains filtered or unexported methods
}

type UnsafeAteomSupportServer interface {
	// contains filtered or unexported methods
}

type UploadConfig struct {

	// +k8s:required
	// +k8s:minimum=1
	// +k8s:maximum=2 # keep this in sync with the UploadMode enum
	Mode UploadMode `protobuf:"varint,1,opt,name=mode,proto3,enum=atelet.UploadMode" json:"mode,omitempty"`
	// contains filtered or unexported fields
}

type UploadMode int32

type VersionedSandboxCompat struct {

	// Compatibility schema version (e.g. "v1") defining which runtime and
	// hardware attributes are recorded and how they are computed.
	//
	// +k8s:required
	// +k8s:maxLength=64
	SchemaVersion string `protobuf:"bytes,1,opt,name=schema_version,json=schemaVersion,proto3" json:"schema_version,omitempty"`
	// Key-value compatibility attributes defined by this schema version, covering
	// both runtime assets (e.g. "gvisor_asset_hash") and effective guest hardware
	// features after masking (e.g. "architecture", "cpu_features").
	// Matched against a snapshot under the same schema_version: every attribute
	// on the snapshot must be present on the worker with an equal value; keys
	// only the worker has are ignored. Bump schema_version when a key's meaning
	// changes or older snapshots must no longer match.
	// Order as sent does not matter: ate-api-server sorts attributes by key
	// before recording them.
	//
	// +k8s:required
	// +k8s:maxItems=32
	// +k8s:listType=map
	// +k8s:listMapKey=key
	Attributes []*AttributeEntry `protobuf:"bytes,2,rep,name=attributes,proto3" json:"attributes,omitempty"`
	// contains filtered or unexported fields
}