From e23737de0d46756cfe7e229930b9c0a073e3d997 Mon Sep 17 00:00:00 2001 From: cabbage Date: Mon, 31 Aug 2026 08:01:13 +0000 Subject: [PATCH] build: bootstrap Go toolchain and generated APIs --- .dockerignore | 9 + .gitignore | 2 + Makefile | 76 + buf.gen.yaml | 13 + cmd/rvbox-server/main.go | 4 + cmd/rvbox/main.go | 4 + cmd/rvc/main.go | 4 + config/buf-lint-baseline.txt | 33 + deploy/Dockerfile.runtime | 17 + deploy/Dockerfile.toolchain | 40 + deploy/compose.test.yaml | 5 + deploy/compose.yaml | 24 + docs/dependency-decisions.md | 12 + gen/go/rvbox/v1/agent.pb.go | 1710 +++++++++++++++++++ gen/go/rvbox/v1/common.pb.go | 2450 +++++++++++++++++++++++++++ gen/go/rvbox/v1/control.pb.go | 2471 ++++++++++++++++++++++++++++ gen/go/rvbox/v1/control_grpc.pb.go | 619 +++++++ go.mod | 15 + go.sum | 38 + scripts/check-buf-lint | 15 + scripts/test-e2e | 6 + scripts/test-env | 20 + scripts/test-integration | 6 + scripts/test-unit | 25 + 24 files changed, 7618 insertions(+) create mode 100644 .dockerignore create mode 100644 Makefile create mode 100644 buf.gen.yaml create mode 100644 cmd/rvbox-server/main.go create mode 100644 cmd/rvbox/main.go create mode 100644 cmd/rvc/main.go create mode 100644 config/buf-lint-baseline.txt create mode 100644 deploy/Dockerfile.runtime create mode 100644 deploy/Dockerfile.toolchain create mode 100644 deploy/compose.test.yaml create mode 100644 deploy/compose.yaml create mode 100644 docs/dependency-decisions.md create mode 100644 gen/go/rvbox/v1/agent.pb.go create mode 100644 gen/go/rvbox/v1/common.pb.go create mode 100644 gen/go/rvbox/v1/control.pb.go create mode 100644 gen/go/rvbox/v1/control_grpc.pb.go create mode 100644 go.mod create mode 100644 go.sum create mode 100755 scripts/check-buf-lint create mode 100755 scripts/test-e2e create mode 100755 scripts/test-env create mode 100755 scripts/test-integration create mode 100755 scripts/test-unit diff --git a/.dockerignore b/.dockerignore new file mode 100644 index 0000000..56f460d --- /dev/null +++ b/.dockerignore @@ -0,0 +1,9 @@ +.git +.test-runs +bin +coverage +dist +*.db +*.db-shm +*.db-wal + diff --git a/.gitignore b/.gitignore index 87a166e..bd96461 100644 --- a/.gitignore +++ b/.gitignore @@ -1,6 +1,8 @@ /bin/ /dist/ /coverage/ +/.test-runs/ +/.test-harness.lock *.db *.db-shm *.db-wal diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..fcab8d6 --- /dev/null +++ b/Makefile @@ -0,0 +1,76 @@ +SHELL := /bin/sh + +COMPOSE := docker compose -f deploy/compose.yaml +GO_PACKAGES := ./... + +.PHONY: generate fmt lint test test-race test-coverage test-integration test-e2e test-status build verify \ + _toolchain-generate _toolchain-fmt _toolchain-lint _toolchain-test _toolchain-test-race \ + _toolchain-test-coverage _toolchain-build _toolchain-verify + +ifeq ($(IN_TOOLCHAIN),1) +generate: _toolchain-generate +fmt: _toolchain-fmt +lint: _toolchain-lint +test: _toolchain-test +test-race: _toolchain-test-race +test-coverage: _toolchain-test-coverage +build: _toolchain-build +verify: _toolchain-verify +else +generate: + $(COMPOSE) run --rm toolchain make generate +fmt: + $(COMPOSE) run --rm toolchain make fmt +lint: + $(COMPOSE) run --rm toolchain make lint +test: + $(COMPOSE) run --rm toolchain make test +test-race: + $(COMPOSE) run --rm toolchain make test-race +test-coverage: + $(COMPOSE) run --rm toolchain make test-coverage +build: + $(COMPOSE) run --rm toolchain make build +verify: + $(COMPOSE) run --rm toolchain make verify +endif + +test-integration: + ./scripts/test-integration + +test-e2e: + ./scripts/test-e2e + +test-status: + ./scripts/test-env status + +_toolchain-generate: + buf generate + +_toolchain-fmt: + test -z "$$(gofmt -l $$(find cmd internal test -name '*.go' -type f 2>/dev/null))" + buf format --diff --exit-code + +_toolchain-lint: + ./scripts/check-buf-lint + go vet $(GO_PACKAGES) + +_toolchain-test: + go test -shuffle=on $(GO_PACKAGES) + +_toolchain-test-race: + go test -race -shuffle=on $(GO_PACKAGES) + +_toolchain-test-coverage: + mkdir -p coverage + go test -shuffle=on -covermode=atomic -coverprofile=coverage/unit.out $(GO_PACKAGES) + +_toolchain-build: + mkdir -p bin + CGO_ENABLED=0 GOOS=linux go build -trimpath -o bin/rvbox-server ./cmd/rvbox-server + CGO_ENABLED=0 GOOS=linux go build -trimpath -o bin/rvc ./cmd/rvc + CGO_ENABLED=0 GOOS=windows GOARCH=amd64 go build -trimpath -o bin/rvbox.exe ./cmd/rvbox + +_toolchain-verify: _toolchain-fmt _toolchain-lint _toolchain-test _toolchain-build + git diff --exit-code -- gen/go + diff --git a/buf.gen.yaml b/buf.gen.yaml new file mode 100644 index 0000000..4236463 --- /dev/null +++ b/buf.gen.yaml @@ -0,0 +1,13 @@ +version: v2 +plugins: + - local: protoc-gen-go + out: gen/go + opt: + - paths=source_relative + - local: protoc-gen-go-grpc + out: gen/go + opt: + - paths=source_relative +inputs: + - directory: protos + diff --git a/cmd/rvbox-server/main.go b/cmd/rvbox-server/main.go new file mode 100644 index 0000000..178f493 --- /dev/null +++ b/cmd/rvbox-server/main.go @@ -0,0 +1,4 @@ +// Command rvbox-server is the RVBox control and agent server. +package main + +func main() {} diff --git a/cmd/rvbox/main.go b/cmd/rvbox/main.go new file mode 100644 index 0000000..343ae55 --- /dev/null +++ b/cmd/rvbox/main.go @@ -0,0 +1,4 @@ +// Command rvbox is the RVBox client daemon and Windows service executable. +package main + +func main() {} diff --git a/cmd/rvc/main.go b/cmd/rvc/main.go new file mode 100644 index 0000000..c779a96 --- /dev/null +++ b/cmd/rvc/main.go @@ -0,0 +1,4 @@ +// Command rvc is the RVBox control-plane command-line client. +package main + +func main() {} diff --git a/config/buf-lint-baseline.txt b/config/buf-lint-baseline.txt new file mode 100644 index 0000000..2865ac7 --- /dev/null +++ b/config/buf-lint-baseline.txt @@ -0,0 +1,33 @@ +protos/rvbox/v1/common.proto:262:5:Enum value name "INVALID_ARGUMENT" should be prefixed with "CODE_". +protos/rvbox/v1/common.proto:263:5:Enum value name "NOT_FOUND" should be prefixed with "CODE_". +protos/rvbox/v1/common.proto:264:5:Enum value name "OFFLINE" should be prefixed with "CODE_". +protos/rvbox/v1/common.proto:265:5:Enum value name "CAPACITY_EXHAUSTED" should be prefixed with "CODE_". +protos/rvbox/v1/common.proto:266:5:Enum value name "CONFLICT" should be prefixed with "CODE_". +protos/rvbox/v1/common.proto:267:5:Enum value name "UNSUPPORTED" should be prefixed with "CODE_". +protos/rvbox/v1/common.proto:268:5:Enum value name "PROTOCOL_ERROR" should be prefixed with "CODE_". +protos/rvbox/v1/common.proto:269:5:Enum value name "TRANSIENT" should be prefixed with "CODE_". +protos/rvbox/v1/common.proto:270:5:Enum value name "INTERNAL" should be prefixed with "CODE_". +protos/rvbox/v1/common.proto:32:3:Enum value name "SHELL_SH" should be prefixed with "SHELL_TYPE_". +protos/rvbox/v1/common.proto:33:3:Enum value name "SHELL_BASH" should be prefixed with "SHELL_TYPE_". +protos/rvbox/v1/common.proto:34:3:Enum value name "SHELL_CMD" should be prefixed with "SHELL_TYPE_". +protos/rvbox/v1/common.proto:35:3:Enum value name "SHELL_POWERSHELL" should be prefixed with "SHELL_TYPE_". +protos/rvbox/v1/common.proto:56:3:Enum value name "COMMAND_QUEUED" should be prefixed with "COMMAND_LIFECYCLE_". +protos/rvbox/v1/common.proto:57:3:Enum value name "COMMAND_DISPATCHED" should be prefixed with "COMMAND_LIFECYCLE_". +protos/rvbox/v1/common.proto:58:3:Enum value name "COMMAND_ACCEPTED" should be prefixed with "COMMAND_LIFECYCLE_". +protos/rvbox/v1/common.proto:59:3:Enum value name "COMMAND_RUNNING" should be prefixed with "COMMAND_LIFECYCLE_". +protos/rvbox/v1/common.proto:60:3:Enum value name "COMMAND_SUCCEEDED" should be prefixed with "COMMAND_LIFECYCLE_". +protos/rvbox/v1/common.proto:61:3:Enum value name "COMMAND_FAILED" should be prefixed with "COMMAND_LIFECYCLE_". +protos/rvbox/v1/common.proto:62:3:Enum value name "COMMAND_TERMINATED" should be prefixed with "COMMAND_LIFECYCLE_". +protos/rvbox/v1/common.proto:63:3:Enum value name "COMMAND_CANCELLED" should be prefixed with "COMMAND_LIFECYCLE_". +protos/rvbox/v1/common.proto:64:3:Enum value name "COMMAND_INTERRUPTED" should be prefixed with "COMMAND_LIFECYCLE_". +protos/rvbox/v1/common.proto:65:3:Enum value name "COMMAND_EXPIRED" should be prefixed with "COMMAND_LIFECYCLE_". +protos/rvbox/v1/common.proto:66:3:Enum value name "COMMAND_REJECTED" should be prefixed with "COMMAND_LIFECYCLE_". +protos/rvbox/v1/common.proto:71:3:Enum value name "STREAM_STDOUT" should be prefixed with "STREAM_KIND_". +protos/rvbox/v1/common.proto:72:3:Enum value name "STREAM_STDERR" should be prefixed with "STREAM_KIND_". +protos/rvbox/v1/common.proto:77:3:Enum value name "SIGNAL_HUP" should be prefixed with "SIGNAL_KIND_". +protos/rvbox/v1/common.proto:78:3:Enum value name "SIGNAL_INT" should be prefixed with "SIGNAL_KIND_". +protos/rvbox/v1/common.proto:79:3:Enum value name "SIGNAL_TERM" should be prefixed with "SIGNAL_KIND_". +protos/rvbox/v1/common.proto:80:3:Enum value name "SIGNAL_KILL" should be prefixed with "SIGNAL_KIND_". +protos/rvbox/v1/common.proto:81:3:Enum value name "SIGNAL_USR1" should be prefixed with "SIGNAL_KIND_". +protos/rvbox/v1/common.proto:82:3:Enum value name "SIGNAL_USR2" should be prefixed with "SIGNAL_KIND_". +protos/rvbox/v1/control.proto:11:9:Service name "Control" should be suffixed with "Service". diff --git a/deploy/Dockerfile.runtime b/deploy/Dockerfile.runtime new file mode 100644 index 0000000..4d889d2 --- /dev/null +++ b/deploy/Dockerfile.runtime @@ -0,0 +1,17 @@ +FROM golang:1.27.0-bookworm AS build + +WORKDIR /src +COPY . . +RUN CGO_ENABLED=0 GOOS=linux go build -trimpath -ldflags="-s -w" -o /out/rvbox-server ./cmd/rvbox-server \ + && CGO_ENABLED=0 GOOS=linux go build -trimpath -ldflags="-s -w" -o /out/rvc ./cmd/rvc + +FROM alpine:3.22.1 + +RUN apk add --no-cache ca-certificates \ + && addgroup -S -g 65532 rvbox \ + && adduser -S -D -H -u 65532 -G rvbox rvbox +COPY --from=build /out/rvbox-server /usr/local/bin/rvbox-server +COPY --from=build /out/rvc /usr/local/bin/rvc +USER 65532:65532 +ENTRYPOINT ["/usr/local/bin/rvbox-server"] + diff --git a/deploy/Dockerfile.toolchain b/deploy/Dockerfile.toolchain new file mode 100644 index 0000000..4d69753 --- /dev/null +++ b/deploy/Dockerfile.toolchain @@ -0,0 +1,40 @@ +ARG BUF_VERSION=1.72.0 +FROM bufbuild/buf:${BUF_VERSION} AS buf + +FROM golang:1.27.0-bookworm + +ARG PROTOC_VERSION=35.0 +ARG PROTOC_AMD64_SHA256=a45cda0989c17dd950db55f6fbe1e5814c50fda08e87aa422980ac1f89dddbbc +ARG PROTOC_ARM64_SHA256=36b518ac14d90351cc6598228ed2bbe5afe4e357b1af470b07e0ec1609875de2 +ARG PROTOC_GEN_GO_VERSION=1.36.12 +ARG PROTOC_GEN_GO_GRPC_VERSION=1.6.2 +ARG TARGETARCH + +ENV GOCACHE=/cache/go-build \ + GOMODCACHE=/cache/go/pkg/mod \ + GOPATH=/cache/go \ + PATH=/cache/go/bin:/usr/local/go/bin:/usr/local/bin:/usr/bin:/bin + +COPY --from=buf /usr/local/bin/buf /usr/local/bin/buf + +RUN apt-get update \ + && apt-get install -y --no-install-recommends ca-certificates curl git make unzip \ + && rm -rf /var/lib/apt/lists/* \ + && case "${TARGETARCH}" in \ + amd64) protoc_arch=x86_64; protoc_sha="${PROTOC_AMD64_SHA256}" ;; \ + arm64) protoc_arch=aarch_64; protoc_sha="${PROTOC_ARM64_SHA256}" ;; \ + *) echo "unsupported toolchain architecture: ${TARGETARCH}" >&2; exit 1 ;; \ + esac \ + && curl -fsSLo /tmp/protoc.zip \ + "https://github.com/protocolbuffers/protobuf/releases/download/v${PROTOC_VERSION}/protoc-${PROTOC_VERSION}-linux-${protoc_arch}.zip" \ + && echo "${protoc_sha} /tmp/protoc.zip" | sha256sum -c - \ + && unzip -q /tmp/protoc.zip -d /usr/local \ + && rm /tmp/protoc.zip + +RUN GOBIN=/usr/local/bin go install "google.golang.org/protobuf/cmd/protoc-gen-go@v${PROTOC_GEN_GO_VERSION}" \ + && GOBIN=/usr/local/bin go install "google.golang.org/grpc/cmd/protoc-gen-go-grpc@v${PROTOC_GEN_GO_GRPC_VERSION}" + +RUN mkdir -p /cache/go-build /cache/go/pkg/mod /cache/xdg /workspace \ + && chown -R 1001:1001 /cache /workspace + +WORKDIR /workspace diff --git a/deploy/compose.test.yaml b/deploy/compose.test.yaml new file mode 100644 index 0000000..e77a3ad --- /dev/null +++ b/deploy/compose.test.yaml @@ -0,0 +1,5 @@ +services: + toolchain: + environment: + RVBOX_TEST_RUN_ID: "${RVBOX_TEST_RUN_ID:?set by scripts/test-env}" + diff --git a/deploy/compose.yaml b/deploy/compose.yaml new file mode 100644 index 0000000..7694c1b --- /dev/null +++ b/deploy/compose.yaml @@ -0,0 +1,24 @@ +name: rvbox-dev + +services: + toolchain: + build: + context: .. + dockerfile: deploy/Dockerfile.toolchain + working_dir: /workspace + user: "${RVBOX_UID:-1001}:${RVBOX_GID:-1001}" + environment: + IN_TOOLCHAIN: "1" + GOCACHE: /cache/go-build + GOMODCACHE: /cache/go/pkg/mod + GOPATH: /cache/go + HOME: /tmp + XDG_CACHE_HOME: /cache/xdg + volumes: + - ..:/workspace + - rvbox-go-build:/cache/go-build + - rvbox-go-mod:/cache/go/pkg/mod + +volumes: + rvbox-go-build: + rvbox-go-mod: diff --git a/docs/dependency-decisions.md b/docs/dependency-decisions.md new file mode 100644 index 0000000..131488c --- /dev/null +++ b/docs/dependency-decisions.md @@ -0,0 +1,12 @@ +# Dependency decisions + +This record explains dependencies that are not part of the Go standard library. +All versions are exact in `go.mod`, generated code, or the toolchain image. + +| Dependency | Purpose | Decision | +| --- | --- | --- | +| Buf 1.72.0 | Protobuf formatting, linting, and deterministic generation | Current stable release when the v1 implementation began; installed only in the toolchain image. | +| protoc 35.0 | Protobuf compiler and well-known includes | Pinned archive with a checked SHA-256; included even though normal generation is driven by Buf. | +| protobuf-go 1.36.12 | Go protobuf runtime and generator | Official maintained Go protobuf implementation. | +| protoc-gen-go-grpc 1.6.2 | Go gRPC generator | Official maintained gRPC-Go generator. | + diff --git a/gen/go/rvbox/v1/agent.pb.go b/gen/go/rvbox/v1/agent.pb.go new file mode 100644 index 0000000..b3fb974 --- /dev/null +++ b/gen/go/rvbox/v1/agent.pb.go @@ -0,0 +1,1710 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.36.12 +// protoc (unknown) +// source: rvbox/v1/agent.proto + +package rvboxv1 + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + timestamppb "google.golang.org/protobuf/types/known/timestamppb" + reflect "reflect" + sync "sync" + unsafe "unsafe" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// One AgentEnvelope is carried in one binary WebSocket message. +type AgentEnvelope struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Empty only for ClientHello. All other envelopes are fenced to a session. + SessionId string `protobuf:"bytes,1,opt,name=session_id,json=sessionId,proto3" json:"session_id,omitempty"` + SessionGeneration uint64 `protobuf:"varint,2,opt,name=session_generation,json=sessionGeneration,proto3" json:"session_generation,omitempty"` + // Types that are valid to be assigned to Payload: + // + // *AgentEnvelope_ClientHello + // *AgentEnvelope_ServerWelcome + // *AgentEnvelope_CommandDispatch + // *AgentEnvelope_CommandAccepted + // *AgentEnvelope_CommandEvent + // *AgentEnvelope_EventAck + // *AgentEnvelope_StdinWrite + // *AgentEnvelope_CloseStdin + // *AgentEnvelope_SignalCommand + // *AgentEnvelope_ScriptChunk + // *AgentEnvelope_ScriptCommit + // *AgentEnvelope_ClientCapacity + // *AgentEnvelope_ReconcileRequest + // *AgentEnvelope_ReconcileSnapshot + // *AgentEnvelope_Error + // *AgentEnvelope_ReconcileResult + Payload isAgentEnvelope_Payload `protobuf_oneof:"payload"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *AgentEnvelope) Reset() { + *x = AgentEnvelope{} + mi := &file_rvbox_v1_agent_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *AgentEnvelope) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AgentEnvelope) ProtoMessage() {} + +func (x *AgentEnvelope) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_agent_proto_msgTypes[0] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use AgentEnvelope.ProtoReflect.Descriptor instead. +func (*AgentEnvelope) Descriptor() ([]byte, []int) { + return file_rvbox_v1_agent_proto_rawDescGZIP(), []int{0} +} + +func (x *AgentEnvelope) GetSessionId() string { + if x != nil { + return x.SessionId + } + return "" +} + +func (x *AgentEnvelope) GetSessionGeneration() uint64 { + if x != nil { + return x.SessionGeneration + } + return 0 +} + +func (x *AgentEnvelope) GetPayload() isAgentEnvelope_Payload { + if x != nil { + return x.Payload + } + return nil +} + +func (x *AgentEnvelope) GetClientHello() *ClientHello { + if x != nil { + if x, ok := x.Payload.(*AgentEnvelope_ClientHello); ok { + return x.ClientHello + } + } + return nil +} + +func (x *AgentEnvelope) GetServerWelcome() *ServerWelcome { + if x != nil { + if x, ok := x.Payload.(*AgentEnvelope_ServerWelcome); ok { + return x.ServerWelcome + } + } + return nil +} + +func (x *AgentEnvelope) GetCommandDispatch() *CommandDispatch { + if x != nil { + if x, ok := x.Payload.(*AgentEnvelope_CommandDispatch); ok { + return x.CommandDispatch + } + } + return nil +} + +func (x *AgentEnvelope) GetCommandAccepted() *CommandAccepted { + if x != nil { + if x, ok := x.Payload.(*AgentEnvelope_CommandAccepted); ok { + return x.CommandAccepted + } + } + return nil +} + +func (x *AgentEnvelope) GetCommandEvent() *CommandEvent { + if x != nil { + if x, ok := x.Payload.(*AgentEnvelope_CommandEvent); ok { + return x.CommandEvent + } + } + return nil +} + +func (x *AgentEnvelope) GetEventAck() *EventAck { + if x != nil { + if x, ok := x.Payload.(*AgentEnvelope_EventAck); ok { + return x.EventAck + } + } + return nil +} + +func (x *AgentEnvelope) GetStdinWrite() *StdinWrite { + if x != nil { + if x, ok := x.Payload.(*AgentEnvelope_StdinWrite); ok { + return x.StdinWrite + } + } + return nil +} + +func (x *AgentEnvelope) GetCloseStdin() *CloseStdin { + if x != nil { + if x, ok := x.Payload.(*AgentEnvelope_CloseStdin); ok { + return x.CloseStdin + } + } + return nil +} + +func (x *AgentEnvelope) GetSignalCommand() *SignalCommand { + if x != nil { + if x, ok := x.Payload.(*AgentEnvelope_SignalCommand); ok { + return x.SignalCommand + } + } + return nil +} + +func (x *AgentEnvelope) GetScriptChunk() *ScriptChunk { + if x != nil { + if x, ok := x.Payload.(*AgentEnvelope_ScriptChunk); ok { + return x.ScriptChunk + } + } + return nil +} + +func (x *AgentEnvelope) GetScriptCommit() *ScriptCommit { + if x != nil { + if x, ok := x.Payload.(*AgentEnvelope_ScriptCommit); ok { + return x.ScriptCommit + } + } + return nil +} + +func (x *AgentEnvelope) GetClientCapacity() *ClientCapacity { + if x != nil { + if x, ok := x.Payload.(*AgentEnvelope_ClientCapacity); ok { + return x.ClientCapacity + } + } + return nil +} + +func (x *AgentEnvelope) GetReconcileRequest() *ReconcileRequest { + if x != nil { + if x, ok := x.Payload.(*AgentEnvelope_ReconcileRequest); ok { + return x.ReconcileRequest + } + } + return nil +} + +func (x *AgentEnvelope) GetReconcileSnapshot() *ReconcileSnapshot { + if x != nil { + if x, ok := x.Payload.(*AgentEnvelope_ReconcileSnapshot); ok { + return x.ReconcileSnapshot + } + } + return nil +} + +func (x *AgentEnvelope) GetError() *AgentError { + if x != nil { + if x, ok := x.Payload.(*AgentEnvelope_Error); ok { + return x.Error + } + } + return nil +} + +func (x *AgentEnvelope) GetReconcileResult() *ReconcileResult { + if x != nil { + if x, ok := x.Payload.(*AgentEnvelope_ReconcileResult); ok { + return x.ReconcileResult + } + } + return nil +} + +type isAgentEnvelope_Payload interface { + isAgentEnvelope_Payload() +} + +type AgentEnvelope_ClientHello struct { + ClientHello *ClientHello `protobuf:"bytes,3,opt,name=client_hello,json=clientHello,proto3,oneof"` +} + +type AgentEnvelope_ServerWelcome struct { + ServerWelcome *ServerWelcome `protobuf:"bytes,4,opt,name=server_welcome,json=serverWelcome,proto3,oneof"` +} + +type AgentEnvelope_CommandDispatch struct { + CommandDispatch *CommandDispatch `protobuf:"bytes,5,opt,name=command_dispatch,json=commandDispatch,proto3,oneof"` +} + +type AgentEnvelope_CommandAccepted struct { + CommandAccepted *CommandAccepted `protobuf:"bytes,6,opt,name=command_accepted,json=commandAccepted,proto3,oneof"` +} + +type AgentEnvelope_CommandEvent struct { + CommandEvent *CommandEvent `protobuf:"bytes,7,opt,name=command_event,json=commandEvent,proto3,oneof"` +} + +type AgentEnvelope_EventAck struct { + EventAck *EventAck `protobuf:"bytes,8,opt,name=event_ack,json=eventAck,proto3,oneof"` +} + +type AgentEnvelope_StdinWrite struct { + StdinWrite *StdinWrite `protobuf:"bytes,9,opt,name=stdin_write,json=stdinWrite,proto3,oneof"` +} + +type AgentEnvelope_CloseStdin struct { + CloseStdin *CloseStdin `protobuf:"bytes,10,opt,name=close_stdin,json=closeStdin,proto3,oneof"` +} + +type AgentEnvelope_SignalCommand struct { + SignalCommand *SignalCommand `protobuf:"bytes,11,opt,name=signal_command,json=signalCommand,proto3,oneof"` +} + +type AgentEnvelope_ScriptChunk struct { + ScriptChunk *ScriptChunk `protobuf:"bytes,12,opt,name=script_chunk,json=scriptChunk,proto3,oneof"` +} + +type AgentEnvelope_ScriptCommit struct { + ScriptCommit *ScriptCommit `protobuf:"bytes,13,opt,name=script_commit,json=scriptCommit,proto3,oneof"` +} + +type AgentEnvelope_ClientCapacity struct { + ClientCapacity *ClientCapacity `protobuf:"bytes,14,opt,name=client_capacity,json=clientCapacity,proto3,oneof"` +} + +type AgentEnvelope_ReconcileRequest struct { + ReconcileRequest *ReconcileRequest `protobuf:"bytes,15,opt,name=reconcile_request,json=reconcileRequest,proto3,oneof"` +} + +type AgentEnvelope_ReconcileSnapshot struct { + ReconcileSnapshot *ReconcileSnapshot `protobuf:"bytes,16,opt,name=reconcile_snapshot,json=reconcileSnapshot,proto3,oneof"` +} + +type AgentEnvelope_Error struct { + Error *AgentError `protobuf:"bytes,17,opt,name=error,proto3,oneof"` +} + +type AgentEnvelope_ReconcileResult struct { + ReconcileResult *ReconcileResult `protobuf:"bytes,18,opt,name=reconcile_result,json=reconcileResult,proto3,oneof"` +} + +func (*AgentEnvelope_ClientHello) isAgentEnvelope_Payload() {} + +func (*AgentEnvelope_ServerWelcome) isAgentEnvelope_Payload() {} + +func (*AgentEnvelope_CommandDispatch) isAgentEnvelope_Payload() {} + +func (*AgentEnvelope_CommandAccepted) isAgentEnvelope_Payload() {} + +func (*AgentEnvelope_CommandEvent) isAgentEnvelope_Payload() {} + +func (*AgentEnvelope_EventAck) isAgentEnvelope_Payload() {} + +func (*AgentEnvelope_StdinWrite) isAgentEnvelope_Payload() {} + +func (*AgentEnvelope_CloseStdin) isAgentEnvelope_Payload() {} + +func (*AgentEnvelope_SignalCommand) isAgentEnvelope_Payload() {} + +func (*AgentEnvelope_ScriptChunk) isAgentEnvelope_Payload() {} + +func (*AgentEnvelope_ScriptCommit) isAgentEnvelope_Payload() {} + +func (*AgentEnvelope_ClientCapacity) isAgentEnvelope_Payload() {} + +func (*AgentEnvelope_ReconcileRequest) isAgentEnvelope_Payload() {} + +func (*AgentEnvelope_ReconcileSnapshot) isAgentEnvelope_Payload() {} + +func (*AgentEnvelope_Error) isAgentEnvelope_Payload() {} + +func (*AgentEnvelope_ReconcileResult) isAgentEnvelope_Payload() {} + +type ClientHello struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Configured hostname; opaque 1-128 ASCII characters. + ClientId string `protobuf:"bytes,1,opt,name=client_id,json=clientId,proto3" json:"client_id,omitempty"` + SupportedProtocol *ProtocolRange `protobuf:"bytes,2,opt,name=supported_protocol,json=supportedProtocol,proto3" json:"supported_protocol,omitempty"` + DaemonVersion string `protobuf:"bytes,3,opt,name=daemon_version,json=daemonVersion,proto3" json:"daemon_version,omitempty"` + Platform Platform `protobuf:"varint,4,opt,name=platform,proto3,enum=rvbox.v1.Platform" json:"platform,omitempty"` + Architecture string `protobuf:"bytes,5,opt,name=architecture,proto3" json:"architecture,omitempty"` + // Omitted-CWD default on Unix; protected per-identity work root on Windows. + DaemonCwd string `protobuf:"bytes,6,opt,name=daemon_cwd,json=daemonCwd,proto3" json:"daemon_cwd,omitempty"` + SupportedShells []ShellType `protobuf:"varint,7,rep,packed,name=supported_shells,json=supportedShells,proto3,enum=rvbox.v1.ShellType" json:"supported_shells,omitempty"` + // Generated once and persisted in the client state directory. + ClientInstanceId string `protobuf:"bytes,8,opt,name=client_instance_id,json=clientInstanceId,proto3" json:"client_instance_id,omitempty"` + MaxRunningCommands uint32 `protobuf:"varint,9,opt,name=max_running_commands,json=maxRunningCommands,proto3" json:"max_running_commands,omitempty"` + MaxQueuedCommands uint32 `protobuf:"varint,10,opt,name=max_queued_commands,json=maxQueuedCommands,proto3" json:"max_queued_commands,omitempty"` + SentAt *timestamppb.Timestamp `protobuf:"bytes,11,opt,name=sent_at,json=sentAt,proto3" json:"sent_at,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ClientHello) Reset() { + *x = ClientHello{} + mi := &file_rvbox_v1_agent_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ClientHello) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ClientHello) ProtoMessage() {} + +func (x *ClientHello) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_agent_proto_msgTypes[1] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ClientHello.ProtoReflect.Descriptor instead. +func (*ClientHello) Descriptor() ([]byte, []int) { + return file_rvbox_v1_agent_proto_rawDescGZIP(), []int{1} +} + +func (x *ClientHello) GetClientId() string { + if x != nil { + return x.ClientId + } + return "" +} + +func (x *ClientHello) GetSupportedProtocol() *ProtocolRange { + if x != nil { + return x.SupportedProtocol + } + return nil +} + +func (x *ClientHello) GetDaemonVersion() string { + if x != nil { + return x.DaemonVersion + } + return "" +} + +func (x *ClientHello) GetPlatform() Platform { + if x != nil { + return x.Platform + } + return Platform_PLATFORM_UNSPECIFIED +} + +func (x *ClientHello) GetArchitecture() string { + if x != nil { + return x.Architecture + } + return "" +} + +func (x *ClientHello) GetDaemonCwd() string { + if x != nil { + return x.DaemonCwd + } + return "" +} + +func (x *ClientHello) GetSupportedShells() []ShellType { + if x != nil { + return x.SupportedShells + } + return nil +} + +func (x *ClientHello) GetClientInstanceId() string { + if x != nil { + return x.ClientInstanceId + } + return "" +} + +func (x *ClientHello) GetMaxRunningCommands() uint32 { + if x != nil { + return x.MaxRunningCommands + } + return 0 +} + +func (x *ClientHello) GetMaxQueuedCommands() uint32 { + if x != nil { + return x.MaxQueuedCommands + } + return 0 +} + +func (x *ClientHello) GetSentAt() *timestamppb.Timestamp { + if x != nil { + return x.SentAt + } + return nil +} + +type ServerWelcome struct { + state protoimpl.MessageState `protogen:"open.v1"` + SelectedProtocol *ProtocolVersion `protobuf:"bytes,1,opt,name=selected_protocol,json=selectedProtocol,proto3" json:"selected_protocol,omitempty"` + // AgentEnvelope.session_id and .session_generation are canonical. + ServerTime *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=server_time,json=serverTime,proto3" json:"server_time,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ServerWelcome) Reset() { + *x = ServerWelcome{} + mi := &file_rvbox_v1_agent_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ServerWelcome) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ServerWelcome) ProtoMessage() {} + +func (x *ServerWelcome) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_agent_proto_msgTypes[2] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ServerWelcome.ProtoReflect.Descriptor instead. +func (*ServerWelcome) Descriptor() ([]byte, []int) { + return file_rvbox_v1_agent_proto_rawDescGZIP(), []int{2} +} + +func (x *ServerWelcome) GetSelectedProtocol() *ProtocolVersion { + if x != nil { + return x.SelectedProtocol + } + return nil +} + +func (x *ServerWelcome) GetServerTime() *timestamppb.Timestamp { + if x != nil { + return x.ServerTime + } + return nil +} + +type CommandDispatch struct { + state protoimpl.MessageState `protogen:"open.v1"` + IssueUuid string `protobuf:"bytes,1,opt,name=issue_uuid,json=issueUuid,proto3" json:"issue_uuid,omitempty"` + CommandRevision uint64 `protobuf:"varint,2,opt,name=command_revision,json=commandRevision,proto3" json:"command_revision,omitempty"` + TargetSessionGeneration uint64 `protobuf:"varint,3,opt,name=target_session_generation,json=targetSessionGeneration,proto3" json:"target_session_generation,omitempty"` + IssueTime *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=issue_time,json=issueTime,proto3" json:"issue_time,omitempty"` + Spec *ExecutionSpec `protobuf:"bytes,5,opt,name=spec,proto3" json:"spec,omitempty"` + QueueExpiryTime *timestamppb.Timestamp `protobuf:"bytes,6,opt,name=queue_expiry_time,json=queueExpiryTime,proto3" json:"queue_expiry_time,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *CommandDispatch) Reset() { + *x = CommandDispatch{} + mi := &file_rvbox_v1_agent_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *CommandDispatch) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CommandDispatch) ProtoMessage() {} + +func (x *CommandDispatch) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_agent_proto_msgTypes[3] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CommandDispatch.ProtoReflect.Descriptor instead. +func (*CommandDispatch) Descriptor() ([]byte, []int) { + return file_rvbox_v1_agent_proto_rawDescGZIP(), []int{3} +} + +func (x *CommandDispatch) GetIssueUuid() string { + if x != nil { + return x.IssueUuid + } + return "" +} + +func (x *CommandDispatch) GetCommandRevision() uint64 { + if x != nil { + return x.CommandRevision + } + return 0 +} + +func (x *CommandDispatch) GetTargetSessionGeneration() uint64 { + if x != nil { + return x.TargetSessionGeneration + } + return 0 +} + +func (x *CommandDispatch) GetIssueTime() *timestamppb.Timestamp { + if x != nil { + return x.IssueTime + } + return nil +} + +func (x *CommandDispatch) GetSpec() *ExecutionSpec { + if x != nil { + return x.Spec + } + return nil +} + +func (x *CommandDispatch) GetQueueExpiryTime() *timestamppb.Timestamp { + if x != nil { + return x.QueueExpiryTime + } + return nil +} + +type CommandAccepted struct { + state protoimpl.MessageState `protogen:"open.v1"` + IssueUuid string `protobuf:"bytes,1,opt,name=issue_uuid,json=issueUuid,proto3" json:"issue_uuid,omitempty"` + CommandRevision uint64 `protobuf:"varint,2,opt,name=command_revision,json=commandRevision,proto3" json:"command_revision,omitempty"` + Accepted bool `protobuf:"varint,3,opt,name=accepted,proto3" json:"accepted,omitempty"` + Rejection *ControlError `protobuf:"bytes,4,opt,name=rejection,proto3" json:"rejection,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *CommandAccepted) Reset() { + *x = CommandAccepted{} + mi := &file_rvbox_v1_agent_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *CommandAccepted) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CommandAccepted) ProtoMessage() {} + +func (x *CommandAccepted) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_agent_proto_msgTypes[4] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CommandAccepted.ProtoReflect.Descriptor instead. +func (*CommandAccepted) Descriptor() ([]byte, []int) { + return file_rvbox_v1_agent_proto_rawDescGZIP(), []int{4} +} + +func (x *CommandAccepted) GetIssueUuid() string { + if x != nil { + return x.IssueUuid + } + return "" +} + +func (x *CommandAccepted) GetCommandRevision() uint64 { + if x != nil { + return x.CommandRevision + } + return 0 +} + +func (x *CommandAccepted) GetAccepted() bool { + if x != nil { + return x.Accepted + } + return false +} + +func (x *CommandAccepted) GetRejection() *ControlError { + if x != nil { + return x.Rejection + } + return nil +} + +// Cumulative durable acknowledgement of client CommandEvent values. +type EventAck struct { + state protoimpl.MessageState `protogen:"open.v1"` + IssueUuid string `protobuf:"bytes,1,opt,name=issue_uuid,json=issueUuid,proto3" json:"issue_uuid,omitempty"` + ThroughEventSeq uint64 `protobuf:"varint,2,opt,name=through_event_seq,json=throughEventSeq,proto3" json:"through_event_seq,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *EventAck) Reset() { + *x = EventAck{} + mi := &file_rvbox_v1_agent_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *EventAck) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*EventAck) ProtoMessage() {} + +func (x *EventAck) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_agent_proto_msgTypes[5] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use EventAck.ProtoReflect.Descriptor instead. +func (*EventAck) Descriptor() ([]byte, []int) { + return file_rvbox_v1_agent_proto_rawDescGZIP(), []int{5} +} + +func (x *EventAck) GetIssueUuid() string { + if x != nil { + return x.IssueUuid + } + return "" +} + +func (x *EventAck) GetThroughEventSeq() uint64 { + if x != nil { + return x.ThroughEventSeq + } + return 0 +} + +type StdinWrite struct { + state protoimpl.MessageState `protogen:"open.v1"` + IssueUuid string `protobuf:"bytes,1,opt,name=issue_uuid,json=issueUuid,proto3" json:"issue_uuid,omitempty"` + WriteSeq uint64 `protobuf:"varint,2,opt,name=write_seq,json=writeSeq,proto3" json:"write_seq,omitempty"` + Data []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"` + AppendNewline bool `protobuf:"varint,4,opt,name=append_newline,json=appendNewline,proto3" json:"append_newline,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *StdinWrite) Reset() { + *x = StdinWrite{} + mi := &file_rvbox_v1_agent_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *StdinWrite) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*StdinWrite) ProtoMessage() {} + +func (x *StdinWrite) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_agent_proto_msgTypes[6] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use StdinWrite.ProtoReflect.Descriptor instead. +func (*StdinWrite) Descriptor() ([]byte, []int) { + return file_rvbox_v1_agent_proto_rawDescGZIP(), []int{6} +} + +func (x *StdinWrite) GetIssueUuid() string { + if x != nil { + return x.IssueUuid + } + return "" +} + +func (x *StdinWrite) GetWriteSeq() uint64 { + if x != nil { + return x.WriteSeq + } + return 0 +} + +func (x *StdinWrite) GetData() []byte { + if x != nil { + return x.Data + } + return nil +} + +func (x *StdinWrite) GetAppendNewline() bool { + if x != nil { + return x.AppendNewline + } + return false +} + +type CloseStdin struct { + state protoimpl.MessageState `protogen:"open.v1"` + IssueUuid string `protobuf:"bytes,1,opt,name=issue_uuid,json=issueUuid,proto3" json:"issue_uuid,omitempty"` + WriteSeq uint64 `protobuf:"varint,2,opt,name=write_seq,json=writeSeq,proto3" json:"write_seq,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *CloseStdin) Reset() { + *x = CloseStdin{} + mi := &file_rvbox_v1_agent_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *CloseStdin) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CloseStdin) ProtoMessage() {} + +func (x *CloseStdin) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_agent_proto_msgTypes[7] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CloseStdin.ProtoReflect.Descriptor instead. +func (*CloseStdin) Descriptor() ([]byte, []int) { + return file_rvbox_v1_agent_proto_rawDescGZIP(), []int{7} +} + +func (x *CloseStdin) GetIssueUuid() string { + if x != nil { + return x.IssueUuid + } + return "" +} + +func (x *CloseStdin) GetWriteSeq() uint64 { + if x != nil { + return x.WriteSeq + } + return 0 +} + +type SignalCommand struct { + state protoimpl.MessageState `protogen:"open.v1"` + IssueUuid string `protobuf:"bytes,1,opt,name=issue_uuid,json=issueUuid,proto3" json:"issue_uuid,omitempty"` + CommandRevision uint64 `protobuf:"varint,2,opt,name=command_revision,json=commandRevision,proto3" json:"command_revision,omitempty"` + Signal SignalKind `protobuf:"varint,3,opt,name=signal,proto3,enum=rvbox.v1.SignalKind" json:"signal,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SignalCommand) Reset() { + *x = SignalCommand{} + mi := &file_rvbox_v1_agent_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SignalCommand) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SignalCommand) ProtoMessage() {} + +func (x *SignalCommand) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_agent_proto_msgTypes[8] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SignalCommand.ProtoReflect.Descriptor instead. +func (*SignalCommand) Descriptor() ([]byte, []int) { + return file_rvbox_v1_agent_proto_rawDescGZIP(), []int{8} +} + +func (x *SignalCommand) GetIssueUuid() string { + if x != nil { + return x.IssueUuid + } + return "" +} + +func (x *SignalCommand) GetCommandRevision() uint64 { + if x != nil { + return x.CommandRevision + } + return 0 +} + +func (x *SignalCommand) GetSignal() SignalKind { + if x != nil { + return x.Signal + } + return SignalKind_SIGNAL_KIND_UNSPECIFIED +} + +type ScriptChunk struct { + state protoimpl.MessageState `protogen:"open.v1"` + IssueUuid string `protobuf:"bytes,1,opt,name=issue_uuid,json=issueUuid,proto3" json:"issue_uuid,omitempty"` + Offset uint64 `protobuf:"varint,2,opt,name=offset,proto3" json:"offset,omitempty"` + Data []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"` + Sha256 []byte `protobuf:"bytes,4,opt,name=sha256,proto3" json:"sha256,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ScriptChunk) Reset() { + *x = ScriptChunk{} + mi := &file_rvbox_v1_agent_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ScriptChunk) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ScriptChunk) ProtoMessage() {} + +func (x *ScriptChunk) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_agent_proto_msgTypes[9] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ScriptChunk.ProtoReflect.Descriptor instead. +func (*ScriptChunk) Descriptor() ([]byte, []int) { + return file_rvbox_v1_agent_proto_rawDescGZIP(), []int{9} +} + +func (x *ScriptChunk) GetIssueUuid() string { + if x != nil { + return x.IssueUuid + } + return "" +} + +func (x *ScriptChunk) GetOffset() uint64 { + if x != nil { + return x.Offset + } + return 0 +} + +func (x *ScriptChunk) GetData() []byte { + if x != nil { + return x.Data + } + return nil +} + +func (x *ScriptChunk) GetSha256() []byte { + if x != nil { + return x.Sha256 + } + return nil +} + +type ScriptCommit struct { + state protoimpl.MessageState `protogen:"open.v1"` + IssueUuid string `protobuf:"bytes,1,opt,name=issue_uuid,json=issueUuid,proto3" json:"issue_uuid,omitempty"` + SizeBytes uint64 `protobuf:"varint,2,opt,name=size_bytes,json=sizeBytes,proto3" json:"size_bytes,omitempty"` + Sha256 []byte `protobuf:"bytes,3,opt,name=sha256,proto3" json:"sha256,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ScriptCommit) Reset() { + *x = ScriptCommit{} + mi := &file_rvbox_v1_agent_proto_msgTypes[10] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ScriptCommit) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ScriptCommit) ProtoMessage() {} + +func (x *ScriptCommit) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_agent_proto_msgTypes[10] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ScriptCommit.ProtoReflect.Descriptor instead. +func (*ScriptCommit) Descriptor() ([]byte, []int) { + return file_rvbox_v1_agent_proto_rawDescGZIP(), []int{10} +} + +func (x *ScriptCommit) GetIssueUuid() string { + if x != nil { + return x.IssueUuid + } + return "" +} + +func (x *ScriptCommit) GetSizeBytes() uint64 { + if x != nil { + return x.SizeBytes + } + return 0 +} + +func (x *ScriptCommit) GetSha256() []byte { + if x != nil { + return x.Sha256 + } + return nil +} + +type ClientCapacity struct { + state protoimpl.MessageState `protogen:"open.v1"` + RunningCommands uint32 `protobuf:"varint,1,opt,name=running_commands,json=runningCommands,proto3" json:"running_commands,omitempty"` + QueuedCommands uint32 `protobuf:"varint,2,opt,name=queued_commands,json=queuedCommands,proto3" json:"queued_commands,omitempty"` + MaxRunningCommands uint32 `protobuf:"varint,3,opt,name=max_running_commands,json=maxRunningCommands,proto3" json:"max_running_commands,omitempty"` + MaxQueuedCommands uint32 `protobuf:"varint,4,opt,name=max_queued_commands,json=maxQueuedCommands,proto3" json:"max_queued_commands,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ClientCapacity) Reset() { + *x = ClientCapacity{} + mi := &file_rvbox_v1_agent_proto_msgTypes[11] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ClientCapacity) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ClientCapacity) ProtoMessage() {} + +func (x *ClientCapacity) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_agent_proto_msgTypes[11] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ClientCapacity.ProtoReflect.Descriptor instead. +func (*ClientCapacity) Descriptor() ([]byte, []int) { + return file_rvbox_v1_agent_proto_rawDescGZIP(), []int{11} +} + +func (x *ClientCapacity) GetRunningCommands() uint32 { + if x != nil { + return x.RunningCommands + } + return 0 +} + +func (x *ClientCapacity) GetQueuedCommands() uint32 { + if x != nil { + return x.QueuedCommands + } + return 0 +} + +func (x *ClientCapacity) GetMaxRunningCommands() uint32 { + if x != nil { + return x.MaxRunningCommands + } + return 0 +} + +func (x *ClientCapacity) GetMaxQueuedCommands() uint32 { + if x != nil { + return x.MaxQueuedCommands + } + return 0 +} + +type ReconcileRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Targets []*ReconcileTarget `protobuf:"bytes,1,rep,name=targets,proto3" json:"targets,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ReconcileRequest) Reset() { + *x = ReconcileRequest{} + mi := &file_rvbox_v1_agent_proto_msgTypes[12] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ReconcileRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ReconcileRequest) ProtoMessage() {} + +func (x *ReconcileRequest) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_agent_proto_msgTypes[12] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ReconcileRequest.ProtoReflect.Descriptor instead. +func (*ReconcileRequest) Descriptor() ([]byte, []int) { + return file_rvbox_v1_agent_proto_rawDescGZIP(), []int{12} +} + +func (x *ReconcileRequest) GetTargets() []*ReconcileTarget { + if x != nil { + return x.Targets + } + return nil +} + +type ReconcileTarget struct { + state protoimpl.MessageState `protogen:"open.v1"` + IssueUuid string `protobuf:"bytes,1,opt,name=issue_uuid,json=issueUuid,proto3" json:"issue_uuid,omitempty"` + LastServerEventSeq uint64 `protobuf:"varint,2,opt,name=last_server_event_seq,json=lastServerEventSeq,proto3" json:"last_server_event_seq,omitempty"` + CommandRevision uint64 `protobuf:"varint,3,opt,name=command_revision,json=commandRevision,proto3" json:"command_revision,omitempty"` + ImmutableRequestSha256 []byte `protobuf:"bytes,4,opt,name=immutable_request_sha256,json=immutableRequestSha256,proto3" json:"immutable_request_sha256,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ReconcileTarget) Reset() { + *x = ReconcileTarget{} + mi := &file_rvbox_v1_agent_proto_msgTypes[13] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ReconcileTarget) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ReconcileTarget) ProtoMessage() {} + +func (x *ReconcileTarget) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_agent_proto_msgTypes[13] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ReconcileTarget.ProtoReflect.Descriptor instead. +func (*ReconcileTarget) Descriptor() ([]byte, []int) { + return file_rvbox_v1_agent_proto_rawDescGZIP(), []int{13} +} + +func (x *ReconcileTarget) GetIssueUuid() string { + if x != nil { + return x.IssueUuid + } + return "" +} + +func (x *ReconcileTarget) GetLastServerEventSeq() uint64 { + if x != nil { + return x.LastServerEventSeq + } + return 0 +} + +func (x *ReconcileTarget) GetCommandRevision() uint64 { + if x != nil { + return x.CommandRevision + } + return 0 +} + +func (x *ReconcileTarget) GetImmutableRequestSha256() []byte { + if x != nil { + return x.ImmutableRequestSha256 + } + return nil +} + +type ReconcileSnapshot struct { + state protoimpl.MessageState `protogen:"open.v1"` + // The complete set still retained by the client, including non-terminal and + // terminal-but-unacknowledged commands. + RetainedCommands []*ReconcileCommandState `protobuf:"bytes,1,rep,name=retained_commands,json=retainedCommands,proto3" json:"retained_commands,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ReconcileSnapshot) Reset() { + *x = ReconcileSnapshot{} + mi := &file_rvbox_v1_agent_proto_msgTypes[14] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ReconcileSnapshot) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ReconcileSnapshot) ProtoMessage() {} + +func (x *ReconcileSnapshot) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_agent_proto_msgTypes[14] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ReconcileSnapshot.ProtoReflect.Descriptor instead. +func (*ReconcileSnapshot) Descriptor() ([]byte, []int) { + return file_rvbox_v1_agent_proto_rawDescGZIP(), []int{14} +} + +func (x *ReconcileSnapshot) GetRetainedCommands() []*ReconcileCommandState { + if x != nil { + return x.RetainedCommands + } + return nil +} + +type ReconcileCommandState struct { + state protoimpl.MessageState `protogen:"open.v1"` + IssueUuid string `protobuf:"bytes,1,opt,name=issue_uuid,json=issueUuid,proto3" json:"issue_uuid,omitempty"` + Lifecycle CommandLifecycle `protobuf:"varint,2,opt,name=lifecycle,proto3,enum=rvbox.v1.CommandLifecycle" json:"lifecycle,omitempty"` + LastClientEventSeq uint64 `protobuf:"varint,3,opt,name=last_client_event_seq,json=lastClientEventSeq,proto3" json:"last_client_event_seq,omitempty"` + CommandRevision uint64 `protobuf:"varint,4,opt,name=command_revision,json=commandRevision,proto3" json:"command_revision,omitempty"` + // True only for a matching UUID/request hash in the compact tombstone ledger. + Tombstoned bool `protobuf:"varint,5,opt,name=tombstoned,proto3" json:"tombstoned,omitempty"` + ImmutableRequestSha256 []byte `protobuf:"bytes,6,opt,name=immutable_request_sha256,json=immutableRequestSha256,proto3" json:"immutable_request_sha256,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ReconcileCommandState) Reset() { + *x = ReconcileCommandState{} + mi := &file_rvbox_v1_agent_proto_msgTypes[15] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ReconcileCommandState) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ReconcileCommandState) ProtoMessage() {} + +func (x *ReconcileCommandState) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_agent_proto_msgTypes[15] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ReconcileCommandState.ProtoReflect.Descriptor instead. +func (*ReconcileCommandState) Descriptor() ([]byte, []int) { + return file_rvbox_v1_agent_proto_rawDescGZIP(), []int{15} +} + +func (x *ReconcileCommandState) GetIssueUuid() string { + if x != nil { + return x.IssueUuid + } + return "" +} + +func (x *ReconcileCommandState) GetLifecycle() CommandLifecycle { + if x != nil { + return x.Lifecycle + } + return CommandLifecycle_COMMAND_LIFECYCLE_UNSPECIFIED +} + +func (x *ReconcileCommandState) GetLastClientEventSeq() uint64 { + if x != nil { + return x.LastClientEventSeq + } + return 0 +} + +func (x *ReconcileCommandState) GetCommandRevision() uint64 { + if x != nil { + return x.CommandRevision + } + return 0 +} + +func (x *ReconcileCommandState) GetTombstoned() bool { + if x != nil { + return x.Tombstoned + } + return false +} + +func (x *ReconcileCommandState) GetImmutableRequestSha256() []byte { + if x != nil { + return x.ImmutableRequestSha256 + } + return nil +} + +// Sent after the server durably compares a complete snapshot and before it +// dispatches new work on the session. Repetition is idempotent. +type ReconcileResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + TerminateLocalIssueUuids []string `protobuf:"bytes,1,rep,name=terminate_local_issue_uuids,json=terminateLocalIssueUuids,proto3" json:"terminate_local_issue_uuids,omitempty"` + DiscardLocalTerminalIssueUuids []string `protobuf:"bytes,2,rep,name=discard_local_terminal_issue_uuids,json=discardLocalTerminalIssueUuids,proto3" json:"discard_local_terminal_issue_uuids,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ReconcileResult) Reset() { + *x = ReconcileResult{} + mi := &file_rvbox_v1_agent_proto_msgTypes[16] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ReconcileResult) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ReconcileResult) ProtoMessage() {} + +func (x *ReconcileResult) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_agent_proto_msgTypes[16] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ReconcileResult.ProtoReflect.Descriptor instead. +func (*ReconcileResult) Descriptor() ([]byte, []int) { + return file_rvbox_v1_agent_proto_rawDescGZIP(), []int{16} +} + +func (x *ReconcileResult) GetTerminateLocalIssueUuids() []string { + if x != nil { + return x.TerminateLocalIssueUuids + } + return nil +} + +func (x *ReconcileResult) GetDiscardLocalTerminalIssueUuids() []string { + if x != nil { + return x.DiscardLocalTerminalIssueUuids + } + return nil +} + +type AgentError struct { + state protoimpl.MessageState `protogen:"open.v1"` + Error *ControlError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"` + CloseSession bool `protobuf:"varint,2,opt,name=close_session,json=closeSession,proto3" json:"close_session,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *AgentError) Reset() { + *x = AgentError{} + mi := &file_rvbox_v1_agent_proto_msgTypes[17] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *AgentError) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AgentError) ProtoMessage() {} + +func (x *AgentError) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_agent_proto_msgTypes[17] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use AgentError.ProtoReflect.Descriptor instead. +func (*AgentError) Descriptor() ([]byte, []int) { + return file_rvbox_v1_agent_proto_rawDescGZIP(), []int{17} +} + +func (x *AgentError) GetError() *ControlError { + if x != nil { + return x.Error + } + return nil +} + +func (x *AgentError) GetCloseSession() bool { + if x != nil { + return x.CloseSession + } + return false +} + +var File_rvbox_v1_agent_proto protoreflect.FileDescriptor + +const file_rvbox_v1_agent_proto_rawDesc = "" + + "\n" + + "\x14rvbox/v1/agent.proto\x12\brvbox.v1\x1a\x1fgoogle/protobuf/timestamp.proto\x1a\x15rvbox/v1/common.proto\"\xeb\b\n" + + "\rAgentEnvelope\x12\x1d\n" + + "\n" + + "session_id\x18\x01 \x01(\tR\tsessionId\x12-\n" + + "\x12session_generation\x18\x02 \x01(\x04R\x11sessionGeneration\x12:\n" + + "\fclient_hello\x18\x03 \x01(\v2\x15.rvbox.v1.ClientHelloH\x00R\vclientHello\x12@\n" + + "\x0eserver_welcome\x18\x04 \x01(\v2\x17.rvbox.v1.ServerWelcomeH\x00R\rserverWelcome\x12F\n" + + "\x10command_dispatch\x18\x05 \x01(\v2\x19.rvbox.v1.CommandDispatchH\x00R\x0fcommandDispatch\x12F\n" + + "\x10command_accepted\x18\x06 \x01(\v2\x19.rvbox.v1.CommandAcceptedH\x00R\x0fcommandAccepted\x12=\n" + + "\rcommand_event\x18\a \x01(\v2\x16.rvbox.v1.CommandEventH\x00R\fcommandEvent\x121\n" + + "\tevent_ack\x18\b \x01(\v2\x12.rvbox.v1.EventAckH\x00R\beventAck\x127\n" + + "\vstdin_write\x18\t \x01(\v2\x14.rvbox.v1.StdinWriteH\x00R\n" + + "stdinWrite\x127\n" + + "\vclose_stdin\x18\n" + + " \x01(\v2\x14.rvbox.v1.CloseStdinH\x00R\n" + + "closeStdin\x12@\n" + + "\x0esignal_command\x18\v \x01(\v2\x17.rvbox.v1.SignalCommandH\x00R\rsignalCommand\x12:\n" + + "\fscript_chunk\x18\f \x01(\v2\x15.rvbox.v1.ScriptChunkH\x00R\vscriptChunk\x12=\n" + + "\rscript_commit\x18\r \x01(\v2\x16.rvbox.v1.ScriptCommitH\x00R\fscriptCommit\x12C\n" + + "\x0fclient_capacity\x18\x0e \x01(\v2\x18.rvbox.v1.ClientCapacityH\x00R\x0eclientCapacity\x12I\n" + + "\x11reconcile_request\x18\x0f \x01(\v2\x1a.rvbox.v1.ReconcileRequestH\x00R\x10reconcileRequest\x12L\n" + + "\x12reconcile_snapshot\x18\x10 \x01(\v2\x1b.rvbox.v1.ReconcileSnapshotH\x00R\x11reconcileSnapshot\x12,\n" + + "\x05error\x18\x11 \x01(\v2\x14.rvbox.v1.AgentErrorH\x00R\x05error\x12F\n" + + "\x10reconcile_result\x18\x12 \x01(\v2\x19.rvbox.v1.ReconcileResultH\x00R\x0freconcileResultB\t\n" + + "\apayload\"\x91\x04\n" + + "\vClientHello\x12\x1b\n" + + "\tclient_id\x18\x01 \x01(\tR\bclientId\x12F\n" + + "\x12supported_protocol\x18\x02 \x01(\v2\x17.rvbox.v1.ProtocolRangeR\x11supportedProtocol\x12%\n" + + "\x0edaemon_version\x18\x03 \x01(\tR\rdaemonVersion\x12.\n" + + "\bplatform\x18\x04 \x01(\x0e2\x12.rvbox.v1.PlatformR\bplatform\x12\"\n" + + "\farchitecture\x18\x05 \x01(\tR\farchitecture\x12\x1d\n" + + "\n" + + "daemon_cwd\x18\x06 \x01(\tR\tdaemonCwd\x12>\n" + + "\x10supported_shells\x18\a \x03(\x0e2\x13.rvbox.v1.ShellTypeR\x0fsupportedShells\x12,\n" + + "\x12client_instance_id\x18\b \x01(\tR\x10clientInstanceId\x120\n" + + "\x14max_running_commands\x18\t \x01(\rR\x12maxRunningCommands\x12.\n" + + "\x13max_queued_commands\x18\n" + + " \x01(\rR\x11maxQueuedCommands\x123\n" + + "\asent_at\x18\v \x01(\v2\x1a.google.protobuf.TimestampR\x06sentAt\"\x94\x01\n" + + "\rServerWelcome\x12F\n" + + "\x11selected_protocol\x18\x01 \x01(\v2\x19.rvbox.v1.ProtocolVersionR\x10selectedProtocol\x12;\n" + + "\vserver_time\x18\x02 \x01(\v2\x1a.google.protobuf.TimestampR\n" + + "serverTime\"\xc7\x02\n" + + "\x0fCommandDispatch\x12\x1d\n" + + "\n" + + "issue_uuid\x18\x01 \x01(\tR\tissueUuid\x12)\n" + + "\x10command_revision\x18\x02 \x01(\x04R\x0fcommandRevision\x12:\n" + + "\x19target_session_generation\x18\x03 \x01(\x04R\x17targetSessionGeneration\x129\n" + + "\n" + + "issue_time\x18\x04 \x01(\v2\x1a.google.protobuf.TimestampR\tissueTime\x12+\n" + + "\x04spec\x18\x05 \x01(\v2\x17.rvbox.v1.ExecutionSpecR\x04spec\x12F\n" + + "\x11queue_expiry_time\x18\x06 \x01(\v2\x1a.google.protobuf.TimestampR\x0fqueueExpiryTime\"\xad\x01\n" + + "\x0fCommandAccepted\x12\x1d\n" + + "\n" + + "issue_uuid\x18\x01 \x01(\tR\tissueUuid\x12)\n" + + "\x10command_revision\x18\x02 \x01(\x04R\x0fcommandRevision\x12\x1a\n" + + "\baccepted\x18\x03 \x01(\bR\baccepted\x124\n" + + "\trejection\x18\x04 \x01(\v2\x16.rvbox.v1.ControlErrorR\trejection\"U\n" + + "\bEventAck\x12\x1d\n" + + "\n" + + "issue_uuid\x18\x01 \x01(\tR\tissueUuid\x12*\n" + + "\x11through_event_seq\x18\x02 \x01(\x04R\x0fthroughEventSeq\"\x83\x01\n" + + "\n" + + "StdinWrite\x12\x1d\n" + + "\n" + + "issue_uuid\x18\x01 \x01(\tR\tissueUuid\x12\x1b\n" + + "\twrite_seq\x18\x02 \x01(\x04R\bwriteSeq\x12\x12\n" + + "\x04data\x18\x03 \x01(\fR\x04data\x12%\n" + + "\x0eappend_newline\x18\x04 \x01(\bR\rappendNewline\"H\n" + + "\n" + + "CloseStdin\x12\x1d\n" + + "\n" + + "issue_uuid\x18\x01 \x01(\tR\tissueUuid\x12\x1b\n" + + "\twrite_seq\x18\x02 \x01(\x04R\bwriteSeq\"\x87\x01\n" + + "\rSignalCommand\x12\x1d\n" + + "\n" + + "issue_uuid\x18\x01 \x01(\tR\tissueUuid\x12)\n" + + "\x10command_revision\x18\x02 \x01(\x04R\x0fcommandRevision\x12,\n" + + "\x06signal\x18\x03 \x01(\x0e2\x14.rvbox.v1.SignalKindR\x06signal\"p\n" + + "\vScriptChunk\x12\x1d\n" + + "\n" + + "issue_uuid\x18\x01 \x01(\tR\tissueUuid\x12\x16\n" + + "\x06offset\x18\x02 \x01(\x04R\x06offset\x12\x12\n" + + "\x04data\x18\x03 \x01(\fR\x04data\x12\x16\n" + + "\x06sha256\x18\x04 \x01(\fR\x06sha256\"d\n" + + "\fScriptCommit\x12\x1d\n" + + "\n" + + "issue_uuid\x18\x01 \x01(\tR\tissueUuid\x12\x1d\n" + + "\n" + + "size_bytes\x18\x02 \x01(\x04R\tsizeBytes\x12\x16\n" + + "\x06sha256\x18\x03 \x01(\fR\x06sha256\"\xc6\x01\n" + + "\x0eClientCapacity\x12)\n" + + "\x10running_commands\x18\x01 \x01(\rR\x0frunningCommands\x12'\n" + + "\x0fqueued_commands\x18\x02 \x01(\rR\x0equeuedCommands\x120\n" + + "\x14max_running_commands\x18\x03 \x01(\rR\x12maxRunningCommands\x12.\n" + + "\x13max_queued_commands\x18\x04 \x01(\rR\x11maxQueuedCommands\"G\n" + + "\x10ReconcileRequest\x123\n" + + "\atargets\x18\x01 \x03(\v2\x19.rvbox.v1.ReconcileTargetR\atargets\"\xc8\x01\n" + + "\x0fReconcileTarget\x12\x1d\n" + + "\n" + + "issue_uuid\x18\x01 \x01(\tR\tissueUuid\x121\n" + + "\x15last_server_event_seq\x18\x02 \x01(\x04R\x12lastServerEventSeq\x12)\n" + + "\x10command_revision\x18\x03 \x01(\x04R\x0fcommandRevision\x128\n" + + "\x18immutable_request_sha256\x18\x04 \x01(\fR\x16immutableRequestSha256\"a\n" + + "\x11ReconcileSnapshot\x12L\n" + + "\x11retained_commands\x18\x01 \x03(\v2\x1f.rvbox.v1.ReconcileCommandStateR\x10retainedCommands\"\xa8\x02\n" + + "\x15ReconcileCommandState\x12\x1d\n" + + "\n" + + "issue_uuid\x18\x01 \x01(\tR\tissueUuid\x128\n" + + "\tlifecycle\x18\x02 \x01(\x0e2\x1a.rvbox.v1.CommandLifecycleR\tlifecycle\x121\n" + + "\x15last_client_event_seq\x18\x03 \x01(\x04R\x12lastClientEventSeq\x12)\n" + + "\x10command_revision\x18\x04 \x01(\x04R\x0fcommandRevision\x12\x1e\n" + + "\n" + + "tombstoned\x18\x05 \x01(\bR\n" + + "tombstoned\x128\n" + + "\x18immutable_request_sha256\x18\x06 \x01(\fR\x16immutableRequestSha256\"\x9c\x01\n" + + "\x0fReconcileResult\x12=\n" + + "\x1bterminate_local_issue_uuids\x18\x01 \x03(\tR\x18terminateLocalIssueUuids\x12J\n" + + "\"discard_local_terminal_issue_uuids\x18\x02 \x03(\tR\x1ediscardLocalTerminalIssueUuids\"_\n" + + "\n" + + "AgentError\x12,\n" + + "\x05error\x18\x01 \x01(\v2\x16.rvbox.v1.ControlErrorR\x05error\x12#\n" + + "\rclose_session\x18\x02 \x01(\bR\fcloseSessionB0Z.github.com/rvbox/rvbox/gen/go/rvbox/v1;rvboxv1b\x06proto3" + +var ( + file_rvbox_v1_agent_proto_rawDescOnce sync.Once + file_rvbox_v1_agent_proto_rawDescData []byte +) + +func file_rvbox_v1_agent_proto_rawDescGZIP() []byte { + file_rvbox_v1_agent_proto_rawDescOnce.Do(func() { + file_rvbox_v1_agent_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_rvbox_v1_agent_proto_rawDesc), len(file_rvbox_v1_agent_proto_rawDesc))) + }) + return file_rvbox_v1_agent_proto_rawDescData +} + +var file_rvbox_v1_agent_proto_msgTypes = make([]protoimpl.MessageInfo, 18) +var file_rvbox_v1_agent_proto_goTypes = []any{ + (*AgentEnvelope)(nil), // 0: rvbox.v1.AgentEnvelope + (*ClientHello)(nil), // 1: rvbox.v1.ClientHello + (*ServerWelcome)(nil), // 2: rvbox.v1.ServerWelcome + (*CommandDispatch)(nil), // 3: rvbox.v1.CommandDispatch + (*CommandAccepted)(nil), // 4: rvbox.v1.CommandAccepted + (*EventAck)(nil), // 5: rvbox.v1.EventAck + (*StdinWrite)(nil), // 6: rvbox.v1.StdinWrite + (*CloseStdin)(nil), // 7: rvbox.v1.CloseStdin + (*SignalCommand)(nil), // 8: rvbox.v1.SignalCommand + (*ScriptChunk)(nil), // 9: rvbox.v1.ScriptChunk + (*ScriptCommit)(nil), // 10: rvbox.v1.ScriptCommit + (*ClientCapacity)(nil), // 11: rvbox.v1.ClientCapacity + (*ReconcileRequest)(nil), // 12: rvbox.v1.ReconcileRequest + (*ReconcileTarget)(nil), // 13: rvbox.v1.ReconcileTarget + (*ReconcileSnapshot)(nil), // 14: rvbox.v1.ReconcileSnapshot + (*ReconcileCommandState)(nil), // 15: rvbox.v1.ReconcileCommandState + (*ReconcileResult)(nil), // 16: rvbox.v1.ReconcileResult + (*AgentError)(nil), // 17: rvbox.v1.AgentError + (*CommandEvent)(nil), // 18: rvbox.v1.CommandEvent + (*ProtocolRange)(nil), // 19: rvbox.v1.ProtocolRange + (Platform)(0), // 20: rvbox.v1.Platform + (ShellType)(0), // 21: rvbox.v1.ShellType + (*timestamppb.Timestamp)(nil), // 22: google.protobuf.Timestamp + (*ProtocolVersion)(nil), // 23: rvbox.v1.ProtocolVersion + (*ExecutionSpec)(nil), // 24: rvbox.v1.ExecutionSpec + (*ControlError)(nil), // 25: rvbox.v1.ControlError + (SignalKind)(0), // 26: rvbox.v1.SignalKind + (CommandLifecycle)(0), // 27: rvbox.v1.CommandLifecycle +} +var file_rvbox_v1_agent_proto_depIdxs = []int32{ + 1, // 0: rvbox.v1.AgentEnvelope.client_hello:type_name -> rvbox.v1.ClientHello + 2, // 1: rvbox.v1.AgentEnvelope.server_welcome:type_name -> rvbox.v1.ServerWelcome + 3, // 2: rvbox.v1.AgentEnvelope.command_dispatch:type_name -> rvbox.v1.CommandDispatch + 4, // 3: rvbox.v1.AgentEnvelope.command_accepted:type_name -> rvbox.v1.CommandAccepted + 18, // 4: rvbox.v1.AgentEnvelope.command_event:type_name -> rvbox.v1.CommandEvent + 5, // 5: rvbox.v1.AgentEnvelope.event_ack:type_name -> rvbox.v1.EventAck + 6, // 6: rvbox.v1.AgentEnvelope.stdin_write:type_name -> rvbox.v1.StdinWrite + 7, // 7: rvbox.v1.AgentEnvelope.close_stdin:type_name -> rvbox.v1.CloseStdin + 8, // 8: rvbox.v1.AgentEnvelope.signal_command:type_name -> rvbox.v1.SignalCommand + 9, // 9: rvbox.v1.AgentEnvelope.script_chunk:type_name -> rvbox.v1.ScriptChunk + 10, // 10: rvbox.v1.AgentEnvelope.script_commit:type_name -> rvbox.v1.ScriptCommit + 11, // 11: rvbox.v1.AgentEnvelope.client_capacity:type_name -> rvbox.v1.ClientCapacity + 12, // 12: rvbox.v1.AgentEnvelope.reconcile_request:type_name -> rvbox.v1.ReconcileRequest + 14, // 13: rvbox.v1.AgentEnvelope.reconcile_snapshot:type_name -> rvbox.v1.ReconcileSnapshot + 17, // 14: rvbox.v1.AgentEnvelope.error:type_name -> rvbox.v1.AgentError + 16, // 15: rvbox.v1.AgentEnvelope.reconcile_result:type_name -> rvbox.v1.ReconcileResult + 19, // 16: rvbox.v1.ClientHello.supported_protocol:type_name -> rvbox.v1.ProtocolRange + 20, // 17: rvbox.v1.ClientHello.platform:type_name -> rvbox.v1.Platform + 21, // 18: rvbox.v1.ClientHello.supported_shells:type_name -> rvbox.v1.ShellType + 22, // 19: rvbox.v1.ClientHello.sent_at:type_name -> google.protobuf.Timestamp + 23, // 20: rvbox.v1.ServerWelcome.selected_protocol:type_name -> rvbox.v1.ProtocolVersion + 22, // 21: rvbox.v1.ServerWelcome.server_time:type_name -> google.protobuf.Timestamp + 22, // 22: rvbox.v1.CommandDispatch.issue_time:type_name -> google.protobuf.Timestamp + 24, // 23: rvbox.v1.CommandDispatch.spec:type_name -> rvbox.v1.ExecutionSpec + 22, // 24: rvbox.v1.CommandDispatch.queue_expiry_time:type_name -> google.protobuf.Timestamp + 25, // 25: rvbox.v1.CommandAccepted.rejection:type_name -> rvbox.v1.ControlError + 26, // 26: rvbox.v1.SignalCommand.signal:type_name -> rvbox.v1.SignalKind + 13, // 27: rvbox.v1.ReconcileRequest.targets:type_name -> rvbox.v1.ReconcileTarget + 15, // 28: rvbox.v1.ReconcileSnapshot.retained_commands:type_name -> rvbox.v1.ReconcileCommandState + 27, // 29: rvbox.v1.ReconcileCommandState.lifecycle:type_name -> rvbox.v1.CommandLifecycle + 25, // 30: rvbox.v1.AgentError.error:type_name -> rvbox.v1.ControlError + 31, // [31:31] is the sub-list for method output_type + 31, // [31:31] is the sub-list for method input_type + 31, // [31:31] is the sub-list for extension type_name + 31, // [31:31] is the sub-list for extension extendee + 0, // [0:31] is the sub-list for field type_name +} + +func init() { file_rvbox_v1_agent_proto_init() } +func file_rvbox_v1_agent_proto_init() { + if File_rvbox_v1_agent_proto != nil { + return + } + file_rvbox_v1_common_proto_init() + file_rvbox_v1_agent_proto_msgTypes[0].OneofWrappers = []any{ + (*AgentEnvelope_ClientHello)(nil), + (*AgentEnvelope_ServerWelcome)(nil), + (*AgentEnvelope_CommandDispatch)(nil), + (*AgentEnvelope_CommandAccepted)(nil), + (*AgentEnvelope_CommandEvent)(nil), + (*AgentEnvelope_EventAck)(nil), + (*AgentEnvelope_StdinWrite)(nil), + (*AgentEnvelope_CloseStdin)(nil), + (*AgentEnvelope_SignalCommand)(nil), + (*AgentEnvelope_ScriptChunk)(nil), + (*AgentEnvelope_ScriptCommit)(nil), + (*AgentEnvelope_ClientCapacity)(nil), + (*AgentEnvelope_ReconcileRequest)(nil), + (*AgentEnvelope_ReconcileSnapshot)(nil), + (*AgentEnvelope_Error)(nil), + (*AgentEnvelope_ReconcileResult)(nil), + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: unsafe.Slice(unsafe.StringData(file_rvbox_v1_agent_proto_rawDesc), len(file_rvbox_v1_agent_proto_rawDesc)), + NumEnums: 0, + NumMessages: 18, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_rvbox_v1_agent_proto_goTypes, + DependencyIndexes: file_rvbox_v1_agent_proto_depIdxs, + MessageInfos: file_rvbox_v1_agent_proto_msgTypes, + }.Build() + File_rvbox_v1_agent_proto = out.File + file_rvbox_v1_agent_proto_goTypes = nil + file_rvbox_v1_agent_proto_depIdxs = nil +} diff --git a/gen/go/rvbox/v1/common.pb.go b/gen/go/rvbox/v1/common.pb.go new file mode 100644 index 0000000..f109aa4 --- /dev/null +++ b/gen/go/rvbox/v1/common.pb.go @@ -0,0 +1,2450 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.36.12 +// protoc (unknown) +// source: rvbox/v1/common.proto + +package rvboxv1 + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + durationpb "google.golang.org/protobuf/types/known/durationpb" + timestamppb "google.golang.org/protobuf/types/known/timestamppb" + reflect "reflect" + sync "sync" + unsafe "unsafe" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +type Platform int32 + +const ( + Platform_PLATFORM_UNSPECIFIED Platform = 0 + Platform_PLATFORM_LINUX Platform = 1 + Platform_PLATFORM_DARWIN Platform = 2 + Platform_PLATFORM_WINDOWS Platform = 3 + Platform_PLATFORM_OTHER_UNIX Platform = 4 +) + +// Enum value maps for Platform. +var ( + Platform_name = map[int32]string{ + 0: "PLATFORM_UNSPECIFIED", + 1: "PLATFORM_LINUX", + 2: "PLATFORM_DARWIN", + 3: "PLATFORM_WINDOWS", + 4: "PLATFORM_OTHER_UNIX", + } + Platform_value = map[string]int32{ + "PLATFORM_UNSPECIFIED": 0, + "PLATFORM_LINUX": 1, + "PLATFORM_DARWIN": 2, + "PLATFORM_WINDOWS": 3, + "PLATFORM_OTHER_UNIX": 4, + } +) + +func (x Platform) Enum() *Platform { + p := new(Platform) + *p = x + return p +} + +func (x Platform) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (Platform) Descriptor() protoreflect.EnumDescriptor { + return file_rvbox_v1_common_proto_enumTypes[0].Descriptor() +} + +func (Platform) Type() protoreflect.EnumType { + return &file_rvbox_v1_common_proto_enumTypes[0] +} + +func (x Platform) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use Platform.Descriptor instead. +func (Platform) EnumDescriptor() ([]byte, []int) { + return file_rvbox_v1_common_proto_rawDescGZIP(), []int{0} +} + +type ShellType int32 + +const ( + ShellType_SHELL_TYPE_UNSPECIFIED ShellType = 0 + ShellType_SHELL_SH ShellType = 1 + ShellType_SHELL_BASH ShellType = 2 + ShellType_SHELL_CMD ShellType = 3 + ShellType_SHELL_POWERSHELL ShellType = 4 +) + +// Enum value maps for ShellType. +var ( + ShellType_name = map[int32]string{ + 0: "SHELL_TYPE_UNSPECIFIED", + 1: "SHELL_SH", + 2: "SHELL_BASH", + 3: "SHELL_CMD", + 4: "SHELL_POWERSHELL", + } + ShellType_value = map[string]int32{ + "SHELL_TYPE_UNSPECIFIED": 0, + "SHELL_SH": 1, + "SHELL_BASH": 2, + "SHELL_CMD": 3, + "SHELL_POWERSHELL": 4, + } +) + +func (x ShellType) Enum() *ShellType { + p := new(ShellType) + *p = x + return p +} + +func (x ShellType) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (ShellType) Descriptor() protoreflect.EnumDescriptor { + return file_rvbox_v1_common_proto_enumTypes[1].Descriptor() +} + +func (ShellType) Type() protoreflect.EnumType { + return &file_rvbox_v1_common_proto_enumTypes[1] +} + +func (x ShellType) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use ShellType.Descriptor instead. +func (ShellType) EnumDescriptor() ([]byte, []int) { + return file_rvbox_v1_common_proto_rawDescGZIP(), []int{1} +} + +// Effective Windows process token/session context selected by the client. +type WindowsExecutionContext int32 + +const ( + WindowsExecutionContext_WINDOWS_EXECUTION_CONTEXT_UNSPECIFIED WindowsExecutionContext = 0 + WindowsExecutionContext_WINDOWS_EXECUTION_CONTEXT_LOCAL_SERVICE WindowsExecutionContext = 1 + WindowsExecutionContext_WINDOWS_EXECUTION_CONTEXT_LOCAL_SYSTEM WindowsExecutionContext = 2 + WindowsExecutionContext_WINDOWS_EXECUTION_CONTEXT_ACTIVE_USER WindowsExecutionContext = 3 + WindowsExecutionContext_WINDOWS_EXECUTION_CONTEXT_ACTIVE_USER_ELEVATED WindowsExecutionContext = 4 + WindowsExecutionContext_WINDOWS_EXECUTION_CONTEXT_ACTIVE_SYSTEM WindowsExecutionContext = 5 +) + +// Enum value maps for WindowsExecutionContext. +var ( + WindowsExecutionContext_name = map[int32]string{ + 0: "WINDOWS_EXECUTION_CONTEXT_UNSPECIFIED", + 1: "WINDOWS_EXECUTION_CONTEXT_LOCAL_SERVICE", + 2: "WINDOWS_EXECUTION_CONTEXT_LOCAL_SYSTEM", + 3: "WINDOWS_EXECUTION_CONTEXT_ACTIVE_USER", + 4: "WINDOWS_EXECUTION_CONTEXT_ACTIVE_USER_ELEVATED", + 5: "WINDOWS_EXECUTION_CONTEXT_ACTIVE_SYSTEM", + } + WindowsExecutionContext_value = map[string]int32{ + "WINDOWS_EXECUTION_CONTEXT_UNSPECIFIED": 0, + "WINDOWS_EXECUTION_CONTEXT_LOCAL_SERVICE": 1, + "WINDOWS_EXECUTION_CONTEXT_LOCAL_SYSTEM": 2, + "WINDOWS_EXECUTION_CONTEXT_ACTIVE_USER": 3, + "WINDOWS_EXECUTION_CONTEXT_ACTIVE_USER_ELEVATED": 4, + "WINDOWS_EXECUTION_CONTEXT_ACTIVE_SYSTEM": 5, + } +) + +func (x WindowsExecutionContext) Enum() *WindowsExecutionContext { + p := new(WindowsExecutionContext) + *p = x + return p +} + +func (x WindowsExecutionContext) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (WindowsExecutionContext) Descriptor() protoreflect.EnumDescriptor { + return file_rvbox_v1_common_proto_enumTypes[2].Descriptor() +} + +func (WindowsExecutionContext) Type() protoreflect.EnumType { + return &file_rvbox_v1_common_proto_enumTypes[2] +} + +func (x WindowsExecutionContext) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use WindowsExecutionContext.Descriptor instead. +func (WindowsExecutionContext) EnumDescriptor() ([]byte, []int) { + return file_rvbox_v1_common_proto_rawDescGZIP(), []int{2} +} + +type Compression int32 + +const ( + Compression_COMPRESSION_UNSPECIFIED Compression = 0 + Compression_COMPRESSION_NONE Compression = 1 + Compression_COMPRESSION_ZSTD Compression = 2 +) + +// Enum value maps for Compression. +var ( + Compression_name = map[int32]string{ + 0: "COMPRESSION_UNSPECIFIED", + 1: "COMPRESSION_NONE", + 2: "COMPRESSION_ZSTD", + } + Compression_value = map[string]int32{ + "COMPRESSION_UNSPECIFIED": 0, + "COMPRESSION_NONE": 1, + "COMPRESSION_ZSTD": 2, + } +) + +func (x Compression) Enum() *Compression { + p := new(Compression) + *p = x + return p +} + +func (x Compression) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (Compression) Descriptor() protoreflect.EnumDescriptor { + return file_rvbox_v1_common_proto_enumTypes[3].Descriptor() +} + +func (Compression) Type() protoreflect.EnumType { + return &file_rvbox_v1_common_proto_enumTypes[3] +} + +func (x Compression) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use Compression.Descriptor instead. +func (Compression) EnumDescriptor() ([]byte, []int) { + return file_rvbox_v1_common_proto_rawDescGZIP(), []int{3} +} + +type CommandLifecycle int32 + +const ( + CommandLifecycle_COMMAND_LIFECYCLE_UNSPECIFIED CommandLifecycle = 0 + CommandLifecycle_COMMAND_QUEUED CommandLifecycle = 1 + CommandLifecycle_COMMAND_DISPATCHED CommandLifecycle = 2 + CommandLifecycle_COMMAND_ACCEPTED CommandLifecycle = 3 + CommandLifecycle_COMMAND_RUNNING CommandLifecycle = 4 + CommandLifecycle_COMMAND_SUCCEEDED CommandLifecycle = 5 + CommandLifecycle_COMMAND_FAILED CommandLifecycle = 6 + CommandLifecycle_COMMAND_TERMINATED CommandLifecycle = 7 + CommandLifecycle_COMMAND_CANCELLED CommandLifecycle = 8 + CommandLifecycle_COMMAND_INTERRUPTED CommandLifecycle = 9 + CommandLifecycle_COMMAND_EXPIRED CommandLifecycle = 10 + CommandLifecycle_COMMAND_REJECTED CommandLifecycle = 11 +) + +// Enum value maps for CommandLifecycle. +var ( + CommandLifecycle_name = map[int32]string{ + 0: "COMMAND_LIFECYCLE_UNSPECIFIED", + 1: "COMMAND_QUEUED", + 2: "COMMAND_DISPATCHED", + 3: "COMMAND_ACCEPTED", + 4: "COMMAND_RUNNING", + 5: "COMMAND_SUCCEEDED", + 6: "COMMAND_FAILED", + 7: "COMMAND_TERMINATED", + 8: "COMMAND_CANCELLED", + 9: "COMMAND_INTERRUPTED", + 10: "COMMAND_EXPIRED", + 11: "COMMAND_REJECTED", + } + CommandLifecycle_value = map[string]int32{ + "COMMAND_LIFECYCLE_UNSPECIFIED": 0, + "COMMAND_QUEUED": 1, + "COMMAND_DISPATCHED": 2, + "COMMAND_ACCEPTED": 3, + "COMMAND_RUNNING": 4, + "COMMAND_SUCCEEDED": 5, + "COMMAND_FAILED": 6, + "COMMAND_TERMINATED": 7, + "COMMAND_CANCELLED": 8, + "COMMAND_INTERRUPTED": 9, + "COMMAND_EXPIRED": 10, + "COMMAND_REJECTED": 11, + } +) + +func (x CommandLifecycle) Enum() *CommandLifecycle { + p := new(CommandLifecycle) + *p = x + return p +} + +func (x CommandLifecycle) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (CommandLifecycle) Descriptor() protoreflect.EnumDescriptor { + return file_rvbox_v1_common_proto_enumTypes[4].Descriptor() +} + +func (CommandLifecycle) Type() protoreflect.EnumType { + return &file_rvbox_v1_common_proto_enumTypes[4] +} + +func (x CommandLifecycle) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use CommandLifecycle.Descriptor instead. +func (CommandLifecycle) EnumDescriptor() ([]byte, []int) { + return file_rvbox_v1_common_proto_rawDescGZIP(), []int{4} +} + +type StreamKind int32 + +const ( + StreamKind_STREAM_KIND_UNSPECIFIED StreamKind = 0 + StreamKind_STREAM_STDOUT StreamKind = 1 + StreamKind_STREAM_STDERR StreamKind = 2 +) + +// Enum value maps for StreamKind. +var ( + StreamKind_name = map[int32]string{ + 0: "STREAM_KIND_UNSPECIFIED", + 1: "STREAM_STDOUT", + 2: "STREAM_STDERR", + } + StreamKind_value = map[string]int32{ + "STREAM_KIND_UNSPECIFIED": 0, + "STREAM_STDOUT": 1, + "STREAM_STDERR": 2, + } +) + +func (x StreamKind) Enum() *StreamKind { + p := new(StreamKind) + *p = x + return p +} + +func (x StreamKind) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (StreamKind) Descriptor() protoreflect.EnumDescriptor { + return file_rvbox_v1_common_proto_enumTypes[5].Descriptor() +} + +func (StreamKind) Type() protoreflect.EnumType { + return &file_rvbox_v1_common_proto_enumTypes[5] +} + +func (x StreamKind) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use StreamKind.Descriptor instead. +func (StreamKind) EnumDescriptor() ([]byte, []int) { + return file_rvbox_v1_common_proto_rawDescGZIP(), []int{5} +} + +type SignalKind int32 + +const ( + SignalKind_SIGNAL_KIND_UNSPECIFIED SignalKind = 0 + SignalKind_SIGNAL_HUP SignalKind = 1 + SignalKind_SIGNAL_INT SignalKind = 2 + SignalKind_SIGNAL_TERM SignalKind = 3 + SignalKind_SIGNAL_KILL SignalKind = 4 + SignalKind_SIGNAL_USR1 SignalKind = 5 + SignalKind_SIGNAL_USR2 SignalKind = 6 +) + +// Enum value maps for SignalKind. +var ( + SignalKind_name = map[int32]string{ + 0: "SIGNAL_KIND_UNSPECIFIED", + 1: "SIGNAL_HUP", + 2: "SIGNAL_INT", + 3: "SIGNAL_TERM", + 4: "SIGNAL_KILL", + 5: "SIGNAL_USR1", + 6: "SIGNAL_USR2", + } + SignalKind_value = map[string]int32{ + "SIGNAL_KIND_UNSPECIFIED": 0, + "SIGNAL_HUP": 1, + "SIGNAL_INT": 2, + "SIGNAL_TERM": 3, + "SIGNAL_KILL": 4, + "SIGNAL_USR1": 5, + "SIGNAL_USR2": 6, + } +) + +func (x SignalKind) Enum() *SignalKind { + p := new(SignalKind) + *p = x + return p +} + +func (x SignalKind) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (SignalKind) Descriptor() protoreflect.EnumDescriptor { + return file_rvbox_v1_common_proto_enumTypes[6].Descriptor() +} + +func (SignalKind) Type() protoreflect.EnumType { + return &file_rvbox_v1_common_proto_enumTypes[6] +} + +func (x SignalKind) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use SignalKind.Descriptor instead. +func (SignalKind) EnumDescriptor() ([]byte, []int) { + return file_rvbox_v1_common_proto_rawDescGZIP(), []int{6} +} + +// These flags are composable. Their numeric limits are local administrator +// policy rather than part of the interoperable protocol. +type ExecutionProfile int32 + +const ( + ExecutionProfile_EXECUTION_PROFILE_UNSPECIFIED ExecutionProfile = 0 + ExecutionProfile_EXECUTION_PROFILE_LIGHT ExecutionProfile = 1 + ExecutionProfile_EXECUTION_PROFILE_CPU_MEDIUM ExecutionProfile = 2 + ExecutionProfile_EXECUTION_PROFILE_CPU_HEAVY ExecutionProfile = 3 + ExecutionProfile_EXECUTION_PROFILE_MEM_MEDIUM ExecutionProfile = 4 + ExecutionProfile_EXECUTION_PROFILE_MEM_HEAVY ExecutionProfile = 5 + ExecutionProfile_EXECUTION_PROFILE_DISK_MEDIUM ExecutionProfile = 6 + ExecutionProfile_EXECUTION_PROFILE_DISK_HEAVY ExecutionProfile = 7 +) + +// Enum value maps for ExecutionProfile. +var ( + ExecutionProfile_name = map[int32]string{ + 0: "EXECUTION_PROFILE_UNSPECIFIED", + 1: "EXECUTION_PROFILE_LIGHT", + 2: "EXECUTION_PROFILE_CPU_MEDIUM", + 3: "EXECUTION_PROFILE_CPU_HEAVY", + 4: "EXECUTION_PROFILE_MEM_MEDIUM", + 5: "EXECUTION_PROFILE_MEM_HEAVY", + 6: "EXECUTION_PROFILE_DISK_MEDIUM", + 7: "EXECUTION_PROFILE_DISK_HEAVY", + } + ExecutionProfile_value = map[string]int32{ + "EXECUTION_PROFILE_UNSPECIFIED": 0, + "EXECUTION_PROFILE_LIGHT": 1, + "EXECUTION_PROFILE_CPU_MEDIUM": 2, + "EXECUTION_PROFILE_CPU_HEAVY": 3, + "EXECUTION_PROFILE_MEM_MEDIUM": 4, + "EXECUTION_PROFILE_MEM_HEAVY": 5, + "EXECUTION_PROFILE_DISK_MEDIUM": 6, + "EXECUTION_PROFILE_DISK_HEAVY": 7, + } +) + +func (x ExecutionProfile) Enum() *ExecutionProfile { + p := new(ExecutionProfile) + *p = x + return p +} + +func (x ExecutionProfile) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (ExecutionProfile) Descriptor() protoreflect.EnumDescriptor { + return file_rvbox_v1_common_proto_enumTypes[7].Descriptor() +} + +func (ExecutionProfile) Type() protoreflect.EnumType { + return &file_rvbox_v1_common_proto_enumTypes[7] +} + +func (x ExecutionProfile) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use ExecutionProfile.Descriptor instead. +func (ExecutionProfile) EnumDescriptor() ([]byte, []int) { + return file_rvbox_v1_common_proto_rawDescGZIP(), []int{7} +} + +type OutputTruncationSource int32 + +const ( + OutputTruncationSource_OUTPUT_TRUNCATION_SOURCE_UNSPECIFIED OutputTruncationSource = 0 + OutputTruncationSource_OUTPUT_TRUNCATION_SOURCE_CLIENT_SPOOL OutputTruncationSource = 1 + OutputTruncationSource_OUTPUT_TRUNCATION_SOURCE_SERVER_COMMAND_WINDOW OutputTruncationSource = 2 + OutputTruncationSource_OUTPUT_TRUNCATION_SOURCE_SERVER_CLIENT_CAP OutputTruncationSource = 3 + OutputTruncationSource_OUTPUT_TRUNCATION_SOURCE_CLIENT_OVERLOAD OutputTruncationSource = 4 + OutputTruncationSource_OUTPUT_TRUNCATION_SOURCE_SERVER_GLOBAL_CAP OutputTruncationSource = 5 +) + +// Enum value maps for OutputTruncationSource. +var ( + OutputTruncationSource_name = map[int32]string{ + 0: "OUTPUT_TRUNCATION_SOURCE_UNSPECIFIED", + 1: "OUTPUT_TRUNCATION_SOURCE_CLIENT_SPOOL", + 2: "OUTPUT_TRUNCATION_SOURCE_SERVER_COMMAND_WINDOW", + 3: "OUTPUT_TRUNCATION_SOURCE_SERVER_CLIENT_CAP", + 4: "OUTPUT_TRUNCATION_SOURCE_CLIENT_OVERLOAD", + 5: "OUTPUT_TRUNCATION_SOURCE_SERVER_GLOBAL_CAP", + } + OutputTruncationSource_value = map[string]int32{ + "OUTPUT_TRUNCATION_SOURCE_UNSPECIFIED": 0, + "OUTPUT_TRUNCATION_SOURCE_CLIENT_SPOOL": 1, + "OUTPUT_TRUNCATION_SOURCE_SERVER_COMMAND_WINDOW": 2, + "OUTPUT_TRUNCATION_SOURCE_SERVER_CLIENT_CAP": 3, + "OUTPUT_TRUNCATION_SOURCE_CLIENT_OVERLOAD": 4, + "OUTPUT_TRUNCATION_SOURCE_SERVER_GLOBAL_CAP": 5, + } +) + +func (x OutputTruncationSource) Enum() *OutputTruncationSource { + p := new(OutputTruncationSource) + *p = x + return p +} + +func (x OutputTruncationSource) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (OutputTruncationSource) Descriptor() protoreflect.EnumDescriptor { + return file_rvbox_v1_common_proto_enumTypes[8].Descriptor() +} + +func (OutputTruncationSource) Type() protoreflect.EnumType { + return &file_rvbox_v1_common_proto_enumTypes[8] +} + +func (x OutputTruncationSource) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use OutputTruncationSource.Descriptor instead. +func (OutputTruncationSource) EnumDescriptor() ([]byte, []int) { + return file_rvbox_v1_common_proto_rawDescGZIP(), []int{8} +} + +type ControlError_Code int32 + +const ( + ControlError_CODE_UNSPECIFIED ControlError_Code = 0 + ControlError_INVALID_ARGUMENT ControlError_Code = 1 + ControlError_NOT_FOUND ControlError_Code = 2 + ControlError_OFFLINE ControlError_Code = 3 + ControlError_CAPACITY_EXHAUSTED ControlError_Code = 4 + ControlError_CONFLICT ControlError_Code = 5 + ControlError_UNSUPPORTED ControlError_Code = 6 + ControlError_PROTOCOL_ERROR ControlError_Code = 7 + ControlError_TRANSIENT ControlError_Code = 8 + ControlError_INTERNAL ControlError_Code = 9 + ControlError_CODE_ALREADY_EXECUTED ControlError_Code = 10 + ControlError_CODE_EXECUTION_CONTEXT_UNAVAILABLE ControlError_Code = 11 + ControlError_CODE_ELEVATION_UNAVAILABLE ControlError_Code = 12 +) + +// Enum value maps for ControlError_Code. +var ( + ControlError_Code_name = map[int32]string{ + 0: "CODE_UNSPECIFIED", + 1: "INVALID_ARGUMENT", + 2: "NOT_FOUND", + 3: "OFFLINE", + 4: "CAPACITY_EXHAUSTED", + 5: "CONFLICT", + 6: "UNSUPPORTED", + 7: "PROTOCOL_ERROR", + 8: "TRANSIENT", + 9: "INTERNAL", + 10: "CODE_ALREADY_EXECUTED", + 11: "CODE_EXECUTION_CONTEXT_UNAVAILABLE", + 12: "CODE_ELEVATION_UNAVAILABLE", + } + ControlError_Code_value = map[string]int32{ + "CODE_UNSPECIFIED": 0, + "INVALID_ARGUMENT": 1, + "NOT_FOUND": 2, + "OFFLINE": 3, + "CAPACITY_EXHAUSTED": 4, + "CONFLICT": 5, + "UNSUPPORTED": 6, + "PROTOCOL_ERROR": 7, + "TRANSIENT": 8, + "INTERNAL": 9, + "CODE_ALREADY_EXECUTED": 10, + "CODE_EXECUTION_CONTEXT_UNAVAILABLE": 11, + "CODE_ELEVATION_UNAVAILABLE": 12, + } +) + +func (x ControlError_Code) Enum() *ControlError_Code { + p := new(ControlError_Code) + *p = x + return p +} + +func (x ControlError_Code) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (ControlError_Code) Descriptor() protoreflect.EnumDescriptor { + return file_rvbox_v1_common_proto_enumTypes[9].Descriptor() +} + +func (ControlError_Code) Type() protoreflect.EnumType { + return &file_rvbox_v1_common_proto_enumTypes[9] +} + +func (x ControlError_Code) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use ControlError_Code.Descriptor instead. +func (ControlError_Code) EnumDescriptor() ([]byte, []int) { + return file_rvbox_v1_common_proto_rawDescGZIP(), []int{15, 0} +} + +// An inclusive protocol-version range advertised during registration. +type ProtocolRange struct { + state protoimpl.MessageState `protogen:"open.v1"` + Major uint32 `protobuf:"varint,1,opt,name=major,proto3" json:"major,omitempty"` + MinMinor uint32 `protobuf:"varint,2,opt,name=min_minor,json=minMinor,proto3" json:"min_minor,omitempty"` + MaxMinor uint32 `protobuf:"varint,3,opt,name=max_minor,json=maxMinor,proto3" json:"max_minor,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ProtocolRange) Reset() { + *x = ProtocolRange{} + mi := &file_rvbox_v1_common_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ProtocolRange) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ProtocolRange) ProtoMessage() {} + +func (x *ProtocolRange) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_common_proto_msgTypes[0] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ProtocolRange.ProtoReflect.Descriptor instead. +func (*ProtocolRange) Descriptor() ([]byte, []int) { + return file_rvbox_v1_common_proto_rawDescGZIP(), []int{0} +} + +func (x *ProtocolRange) GetMajor() uint32 { + if x != nil { + return x.Major + } + return 0 +} + +func (x *ProtocolRange) GetMinMinor() uint32 { + if x != nil { + return x.MinMinor + } + return 0 +} + +func (x *ProtocolRange) GetMaxMinor() uint32 { + if x != nil { + return x.MaxMinor + } + return 0 +} + +type ProtocolVersion struct { + state protoimpl.MessageState `protogen:"open.v1"` + Major uint32 `protobuf:"varint,1,opt,name=major,proto3" json:"major,omitempty"` + Minor uint32 `protobuf:"varint,2,opt,name=minor,proto3" json:"minor,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ProtocolVersion) Reset() { + *x = ProtocolVersion{} + mi := &file_rvbox_v1_common_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ProtocolVersion) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ProtocolVersion) ProtoMessage() {} + +func (x *ProtocolVersion) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_common_proto_msgTypes[1] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ProtocolVersion.ProtoReflect.Descriptor instead. +func (*ProtocolVersion) Descriptor() ([]byte, []int) { + return file_rvbox_v1_common_proto_rawDescGZIP(), []int{1} +} + +func (x *ProtocolVersion) GetMajor() uint32 { + if x != nil { + return x.Major + } + return 0 +} + +func (x *ProtocolVersion) GetMinor() uint32 { + if x != nil { + return x.Minor + } + return 0 +} + +type ScriptDescriptor struct { + state protoimpl.MessageState `protogen:"open.v1"` + Filename string `protobuf:"bytes,1,opt,name=filename,proto3" json:"filename,omitempty"` + SizeBytes uint64 `protobuf:"varint,2,opt,name=size_bytes,json=sizeBytes,proto3" json:"size_bytes,omitempty"` + Sha256 []byte `protobuf:"bytes,3,opt,name=sha256,proto3" json:"sha256,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ScriptDescriptor) Reset() { + *x = ScriptDescriptor{} + mi := &file_rvbox_v1_common_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ScriptDescriptor) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ScriptDescriptor) ProtoMessage() {} + +func (x *ScriptDescriptor) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_common_proto_msgTypes[2] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ScriptDescriptor.ProtoReflect.Descriptor instead. +func (*ScriptDescriptor) Descriptor() ([]byte, []int) { + return file_rvbox_v1_common_proto_rawDescGZIP(), []int{2} +} + +func (x *ScriptDescriptor) GetFilename() string { + if x != nil { + return x.Filename + } + return "" +} + +func (x *ScriptDescriptor) GetSizeBytes() uint64 { + if x != nil { + return x.SizeBytes + } + return 0 +} + +func (x *ScriptDescriptor) GetSha256() []byte { + if x != nil { + return x.Sha256 + } + return nil +} + +// Execution settings sent to the client. A script's bytes travel separately. +type ExecutionSpec struct { + state protoimpl.MessageState `protogen:"open.v1"` + ShellType ShellType `protobuf:"varint,1,opt,name=shell_type,json=shellType,proto3,enum=rvbox.v1.ShellType" json:"shell_type,omitempty"` + Cwd string `protobuf:"bytes,2,opt,name=cwd,proto3" json:"cwd,omitempty"` + EnvOverrides map[string]string `protobuf:"bytes,3,rep,name=env_overrides,json=envOverrides,proto3" json:"env_overrides,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + ExecutionProfiles []ExecutionProfile `protobuf:"varint,4,rep,packed,name=execution_profiles,json=executionProfiles,proto3,enum=rvbox.v1.ExecutionProfile" json:"execution_profiles,omitempty"` + // Types that are valid to be assigned to Source: + // + // *ExecutionSpec_CommandText + // *ExecutionSpec_Script + Source isExecutionSpec_Source `protobuf_oneof:"source"` + // Requests the platform's elevated execution policy. False is the normal + // least-privilege policy. Non-Windows clients reject true in v1. + Elevated bool `protobuf:"varint,7,opt,name=elevated,proto3" json:"elevated,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ExecutionSpec) Reset() { + *x = ExecutionSpec{} + mi := &file_rvbox_v1_common_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ExecutionSpec) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ExecutionSpec) ProtoMessage() {} + +func (x *ExecutionSpec) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_common_proto_msgTypes[3] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ExecutionSpec.ProtoReflect.Descriptor instead. +func (*ExecutionSpec) Descriptor() ([]byte, []int) { + return file_rvbox_v1_common_proto_rawDescGZIP(), []int{3} +} + +func (x *ExecutionSpec) GetShellType() ShellType { + if x != nil { + return x.ShellType + } + return ShellType_SHELL_TYPE_UNSPECIFIED +} + +func (x *ExecutionSpec) GetCwd() string { + if x != nil { + return x.Cwd + } + return "" +} + +func (x *ExecutionSpec) GetEnvOverrides() map[string]string { + if x != nil { + return x.EnvOverrides + } + return nil +} + +func (x *ExecutionSpec) GetExecutionProfiles() []ExecutionProfile { + if x != nil { + return x.ExecutionProfiles + } + return nil +} + +func (x *ExecutionSpec) GetSource() isExecutionSpec_Source { + if x != nil { + return x.Source + } + return nil +} + +func (x *ExecutionSpec) GetCommandText() string { + if x != nil { + if x, ok := x.Source.(*ExecutionSpec_CommandText); ok { + return x.CommandText + } + } + return "" +} + +func (x *ExecutionSpec) GetScript() *ScriptDescriptor { + if x != nil { + if x, ok := x.Source.(*ExecutionSpec_Script); ok { + return x.Script + } + } + return nil +} + +func (x *ExecutionSpec) GetElevated() bool { + if x != nil { + return x.Elevated + } + return false +} + +type isExecutionSpec_Source interface { + isExecutionSpec_Source() +} + +type ExecutionSpec_CommandText struct { + CommandText string `protobuf:"bytes,5,opt,name=command_text,json=commandText,proto3,oneof"` +} + +type ExecutionSpec_Script struct { + Script *ScriptDescriptor `protobuf:"bytes,6,opt,name=script,proto3,oneof"` +} + +func (*ExecutionSpec_CommandText) isExecutionSpec_Source() {} + +func (*ExecutionSpec_Script) isExecutionSpec_Source() {} + +// Effective Windows identity captured at launch. session_id and +// session_user_sid are absent for Session 0 contexts. effective_user_sid is +// the actual process-token user, not the owner of the target desktop session. +type WindowsExecutionIdentity struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Absent when every allowed context failed before launch preparation. + EffectiveContext *WindowsExecutionContext `protobuf:"varint,1,opt,name=effective_context,json=effectiveContext,proto3,enum=rvbox.v1.WindowsExecutionContext,oneof" json:"effective_context,omitempty"` + SessionId *uint32 `protobuf:"varint,2,opt,name=session_id,json=sessionId,proto3,oneof" json:"session_id,omitempty"` + SessionUserSid string `protobuf:"bytes,3,opt,name=session_user_sid,json=sessionUserSid,proto3" json:"session_user_sid,omitempty"` + EffectiveUserSid string `protobuf:"bytes,4,opt,name=effective_user_sid,json=effectiveUserSid,proto3" json:"effective_user_sid,omitempty"` + // Ordered contexts considered during pre-launch selection, including the + // effective final context. This is never a record of process retries. + AttemptedContexts []WindowsExecutionContext `protobuf:"varint,5,rep,packed,name=attempted_contexts,json=attemptedContexts,proto3,enum=rvbox.v1.WindowsExecutionContext" json:"attempted_contexts,omitempty"` + SelectionDetail string `protobuf:"bytes,6,opt,name=selection_detail,json=selectionDetail,proto3" json:"selection_detail,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *WindowsExecutionIdentity) Reset() { + *x = WindowsExecutionIdentity{} + mi := &file_rvbox_v1_common_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *WindowsExecutionIdentity) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WindowsExecutionIdentity) ProtoMessage() {} + +func (x *WindowsExecutionIdentity) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_common_proto_msgTypes[4] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use WindowsExecutionIdentity.ProtoReflect.Descriptor instead. +func (*WindowsExecutionIdentity) Descriptor() ([]byte, []int) { + return file_rvbox_v1_common_proto_rawDescGZIP(), []int{4} +} + +func (x *WindowsExecutionIdentity) GetEffectiveContext() WindowsExecutionContext { + if x != nil && x.EffectiveContext != nil { + return *x.EffectiveContext + } + return WindowsExecutionContext_WINDOWS_EXECUTION_CONTEXT_UNSPECIFIED +} + +func (x *WindowsExecutionIdentity) GetSessionId() uint32 { + if x != nil && x.SessionId != nil { + return *x.SessionId + } + return 0 +} + +func (x *WindowsExecutionIdentity) GetSessionUserSid() string { + if x != nil { + return x.SessionUserSid + } + return "" +} + +func (x *WindowsExecutionIdentity) GetEffectiveUserSid() string { + if x != nil { + return x.EffectiveUserSid + } + return "" +} + +func (x *WindowsExecutionIdentity) GetAttemptedContexts() []WindowsExecutionContext { + if x != nil { + return x.AttemptedContexts + } + return nil +} + +func (x *WindowsExecutionIdentity) GetSelectionDetail() string { + if x != nil { + return x.SelectionDetail + } + return "" +} + +type CommandRecord struct { + state protoimpl.MessageState `protogen:"open.v1"` + IssueUuid string `protobuf:"bytes,1,opt,name=issue_uuid,json=issueUuid,proto3" json:"issue_uuid,omitempty"` + TargetClientId string `protobuf:"bytes,2,opt,name=target_client_id,json=targetClientId,proto3" json:"target_client_id,omitempty"` + IssueTime *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=issue_time,json=issueTime,proto3" json:"issue_time,omitempty"` + ServerReceiptTime *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=server_receipt_time,json=serverReceiptTime,proto3" json:"server_receipt_time,omitempty"` + Spec *ExecutionSpec `protobuf:"bytes,5,opt,name=spec,proto3" json:"spec,omitempty"` + Lifecycle CommandLifecycle `protobuf:"varint,6,opt,name=lifecycle,proto3,enum=rvbox.v1.CommandLifecycle" json:"lifecycle,omitempty"` + LastEventSeq uint64 `protobuf:"varint,7,opt,name=last_event_seq,json=lastEventSeq,proto3" json:"last_event_seq,omitempty"` + ExitCode *int32 `protobuf:"varint,8,opt,name=exit_code,json=exitCode,proto3,oneof" json:"exit_code,omitempty"` + TerminalTime *timestamppb.Timestamp `protobuf:"bytes,9,opt,name=terminal_time,json=terminalTime,proto3" json:"terminal_time,omitempty"` + OutputTruncated bool `protobuf:"varint,10,opt,name=output_truncated,json=outputTruncated,proto3" json:"output_truncated,omitempty"` + RetainedCompressedBytes uint64 `protobuf:"varint,11,opt,name=retained_compressed_bytes,json=retainedCompressedBytes,proto3" json:"retained_compressed_bytes,omitempty"` + QueueExpiryTime *timestamppb.Timestamp `protobuf:"bytes,12,opt,name=queue_expiry_time,json=queueExpiryTime,proto3" json:"queue_expiry_time,omitempty"` + OutputIncomplete bool `protobuf:"varint,13,opt,name=output_incomplete,json=outputIncomplete,proto3" json:"output_incomplete,omitempty"` + // Present when lifecycle is COMMAND_REJECTED. + Rejection *ControlError `protobuf:"bytes,14,opt,name=rejection,proto3" json:"rejection,omitempty"` + CommandRevision uint64 `protobuf:"varint,15,opt,name=command_revision,json=commandRevision,proto3" json:"command_revision,omitempty"` + LateAfterExpiry bool `protobuf:"varint,16,opt,name=late_after_expiry,json=lateAfterExpiry,proto3" json:"late_after_expiry,omitempty"` + // Present after Windows context selection was attempted, including a + // pre-launch rejection for which effective_context is absent. + WindowsExecutionIdentity *WindowsExecutionIdentity `protobuf:"bytes,17,opt,name=windows_execution_identity,json=windowsExecutionIdentity,proto3" json:"windows_execution_identity,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *CommandRecord) Reset() { + *x = CommandRecord{} + mi := &file_rvbox_v1_common_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *CommandRecord) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CommandRecord) ProtoMessage() {} + +func (x *CommandRecord) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_common_proto_msgTypes[5] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CommandRecord.ProtoReflect.Descriptor instead. +func (*CommandRecord) Descriptor() ([]byte, []int) { + return file_rvbox_v1_common_proto_rawDescGZIP(), []int{5} +} + +func (x *CommandRecord) GetIssueUuid() string { + if x != nil { + return x.IssueUuid + } + return "" +} + +func (x *CommandRecord) GetTargetClientId() string { + if x != nil { + return x.TargetClientId + } + return "" +} + +func (x *CommandRecord) GetIssueTime() *timestamppb.Timestamp { + if x != nil { + return x.IssueTime + } + return nil +} + +func (x *CommandRecord) GetServerReceiptTime() *timestamppb.Timestamp { + if x != nil { + return x.ServerReceiptTime + } + return nil +} + +func (x *CommandRecord) GetSpec() *ExecutionSpec { + if x != nil { + return x.Spec + } + return nil +} + +func (x *CommandRecord) GetLifecycle() CommandLifecycle { + if x != nil { + return x.Lifecycle + } + return CommandLifecycle_COMMAND_LIFECYCLE_UNSPECIFIED +} + +func (x *CommandRecord) GetLastEventSeq() uint64 { + if x != nil { + return x.LastEventSeq + } + return 0 +} + +func (x *CommandRecord) GetExitCode() int32 { + if x != nil && x.ExitCode != nil { + return *x.ExitCode + } + return 0 +} + +func (x *CommandRecord) GetTerminalTime() *timestamppb.Timestamp { + if x != nil { + return x.TerminalTime + } + return nil +} + +func (x *CommandRecord) GetOutputTruncated() bool { + if x != nil { + return x.OutputTruncated + } + return false +} + +func (x *CommandRecord) GetRetainedCompressedBytes() uint64 { + if x != nil { + return x.RetainedCompressedBytes + } + return 0 +} + +func (x *CommandRecord) GetQueueExpiryTime() *timestamppb.Timestamp { + if x != nil { + return x.QueueExpiryTime + } + return nil +} + +func (x *CommandRecord) GetOutputIncomplete() bool { + if x != nil { + return x.OutputIncomplete + } + return false +} + +func (x *CommandRecord) GetRejection() *ControlError { + if x != nil { + return x.Rejection + } + return nil +} + +func (x *CommandRecord) GetCommandRevision() uint64 { + if x != nil { + return x.CommandRevision + } + return 0 +} + +func (x *CommandRecord) GetLateAfterExpiry() bool { + if x != nil { + return x.LateAfterExpiry + } + return false +} + +func (x *CommandRecord) GetWindowsExecutionIdentity() *WindowsExecutionIdentity { + if x != nil { + return x.WindowsExecutionIdentity + } + return nil +} + +type LifecycleChange struct { + state protoimpl.MessageState `protogen:"open.v1"` + Lifecycle CommandLifecycle `protobuf:"varint,1,opt,name=lifecycle,proto3,enum=rvbox.v1.CommandLifecycle" json:"lifecycle,omitempty"` + ExitCode *int32 `protobuf:"varint,2,opt,name=exit_code,json=exitCode,proto3,oneof" json:"exit_code,omitempty"` + Detail string `protobuf:"bytes,3,opt,name=detail,proto3" json:"detail,omitempty"` + CommandRevision uint64 `protobuf:"varint,4,opt,name=command_revision,json=commandRevision,proto3" json:"command_revision,omitempty"` + // Set on a Windows context-selection rejection or RUNNING, then repeated + // unchanged on later lifecycle events. + WindowsExecutionIdentity *WindowsExecutionIdentity `protobuf:"bytes,5,opt,name=windows_execution_identity,json=windowsExecutionIdentity,proto3" json:"windows_execution_identity,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *LifecycleChange) Reset() { + *x = LifecycleChange{} + mi := &file_rvbox_v1_common_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *LifecycleChange) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*LifecycleChange) ProtoMessage() {} + +func (x *LifecycleChange) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_common_proto_msgTypes[6] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use LifecycleChange.ProtoReflect.Descriptor instead. +func (*LifecycleChange) Descriptor() ([]byte, []int) { + return file_rvbox_v1_common_proto_rawDescGZIP(), []int{6} +} + +func (x *LifecycleChange) GetLifecycle() CommandLifecycle { + if x != nil { + return x.Lifecycle + } + return CommandLifecycle_COMMAND_LIFECYCLE_UNSPECIFIED +} + +func (x *LifecycleChange) GetExitCode() int32 { + if x != nil && x.ExitCode != nil { + return *x.ExitCode + } + return 0 +} + +func (x *LifecycleChange) GetDetail() string { + if x != nil { + return x.Detail + } + return "" +} + +func (x *LifecycleChange) GetCommandRevision() uint64 { + if x != nil { + return x.CommandRevision + } + return 0 +} + +func (x *LifecycleChange) GetWindowsExecutionIdentity() *WindowsExecutionIdentity { + if x != nil { + return x.WindowsExecutionIdentity + } + return nil +} + +// data is compressed according to compression. uncompressed_size is mandatory +// when compression is ZSTD and must be validated before decompression. +type OutputChunk struct { + state protoimpl.MessageState `protogen:"open.v1"` + Stream StreamKind `protobuf:"varint,1,opt,name=stream,proto3,enum=rvbox.v1.StreamKind" json:"stream,omitempty"` + Compression Compression `protobuf:"varint,2,opt,name=compression,proto3,enum=rvbox.v1.Compression" json:"compression,omitempty"` + Data []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"` + UncompressedSize uint64 `protobuf:"varint,4,opt,name=uncompressed_size,json=uncompressedSize,proto3" json:"uncompressed_size,omitempty"` + CompressedSize uint64 `protobuf:"varint,5,opt,name=compressed_size,json=compressedSize,proto3" json:"compressed_size,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *OutputChunk) Reset() { + *x = OutputChunk{} + mi := &file_rvbox_v1_common_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *OutputChunk) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*OutputChunk) ProtoMessage() {} + +func (x *OutputChunk) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_common_proto_msgTypes[7] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use OutputChunk.ProtoReflect.Descriptor instead. +func (*OutputChunk) Descriptor() ([]byte, []int) { + return file_rvbox_v1_common_proto_rawDescGZIP(), []int{7} +} + +func (x *OutputChunk) GetStream() StreamKind { + if x != nil { + return x.Stream + } + return StreamKind_STREAM_KIND_UNSPECIFIED +} + +func (x *OutputChunk) GetCompression() Compression { + if x != nil { + return x.Compression + } + return Compression_COMPRESSION_UNSPECIFIED +} + +func (x *OutputChunk) GetData() []byte { + if x != nil { + return x.Data + } + return nil +} + +func (x *OutputChunk) GetUncompressedSize() uint64 { + if x != nil { + return x.UncompressedSize + } + return 0 +} + +func (x *OutputChunk) GetCompressedSize() uint64 { + if x != nil { + return x.CompressedSize + } + return 0 +} + +type ResourceSnapshot struct { + state protoimpl.MessageState `protogen:"open.v1"` + ResidentMemoryBytes *uint64 `protobuf:"varint,1,opt,name=resident_memory_bytes,json=residentMemoryBytes,proto3,oneof" json:"resident_memory_bytes,omitempty"` + VirtualMemoryBytes *uint64 `protobuf:"varint,2,opt,name=virtual_memory_bytes,json=virtualMemoryBytes,proto3,oneof" json:"virtual_memory_bytes,omitempty"` + CpuTime *durationpb.Duration `protobuf:"bytes,3,opt,name=cpu_time,json=cpuTime,proto3" json:"cpu_time,omitempty"` + ReadBytes *uint64 `protobuf:"varint,4,opt,name=read_bytes,json=readBytes,proto3,oneof" json:"read_bytes,omitempty"` + WriteBytes *uint64 `protobuf:"varint,5,opt,name=write_bytes,json=writeBytes,proto3,oneof" json:"write_bytes,omitempty"` + ProcessState *string `protobuf:"bytes,6,opt,name=process_state,json=processState,proto3,oneof" json:"process_state,omitempty"` + WaitReason *string `protobuf:"bytes,7,opt,name=wait_reason,json=waitReason,proto3,oneof" json:"wait_reason,omitempty"` + SuspectedHung bool `protobuf:"varint,8,opt,name=suspected_hung,json=suspectedHung,proto3" json:"suspected_hung,omitempty"` + DiagnosticDetail string `protobuf:"bytes,9,opt,name=diagnostic_detail,json=diagnosticDetail,proto3" json:"diagnostic_detail,omitempty"` + CurrentCwd *string `protobuf:"bytes,10,opt,name=current_cwd,json=currentCwd,proto3,oneof" json:"current_cwd,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResourceSnapshot) Reset() { + *x = ResourceSnapshot{} + mi := &file_rvbox_v1_common_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResourceSnapshot) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResourceSnapshot) ProtoMessage() {} + +func (x *ResourceSnapshot) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_common_proto_msgTypes[8] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ResourceSnapshot.ProtoReflect.Descriptor instead. +func (*ResourceSnapshot) Descriptor() ([]byte, []int) { + return file_rvbox_v1_common_proto_rawDescGZIP(), []int{8} +} + +func (x *ResourceSnapshot) GetResidentMemoryBytes() uint64 { + if x != nil && x.ResidentMemoryBytes != nil { + return *x.ResidentMemoryBytes + } + return 0 +} + +func (x *ResourceSnapshot) GetVirtualMemoryBytes() uint64 { + if x != nil && x.VirtualMemoryBytes != nil { + return *x.VirtualMemoryBytes + } + return 0 +} + +func (x *ResourceSnapshot) GetCpuTime() *durationpb.Duration { + if x != nil { + return x.CpuTime + } + return nil +} + +func (x *ResourceSnapshot) GetReadBytes() uint64 { + if x != nil && x.ReadBytes != nil { + return *x.ReadBytes + } + return 0 +} + +func (x *ResourceSnapshot) GetWriteBytes() uint64 { + if x != nil && x.WriteBytes != nil { + return *x.WriteBytes + } + return 0 +} + +func (x *ResourceSnapshot) GetProcessState() string { + if x != nil && x.ProcessState != nil { + return *x.ProcessState + } + return "" +} + +func (x *ResourceSnapshot) GetWaitReason() string { + if x != nil && x.WaitReason != nil { + return *x.WaitReason + } + return "" +} + +func (x *ResourceSnapshot) GetSuspectedHung() bool { + if x != nil { + return x.SuspectedHung + } + return false +} + +func (x *ResourceSnapshot) GetDiagnosticDetail() string { + if x != nil { + return x.DiagnosticDetail + } + return "" +} + +func (x *ResourceSnapshot) GetCurrentCwd() string { + if x != nil && x.CurrentCwd != nil { + return *x.CurrentCwd + } + return "" +} + +// Metadata for missing output. Server-side retention supplies the optional +// event range. Client output discarded before wire sequence assignment omits +// the range and carries this as a normally sequenced CommandEvent. +type OutputTruncation struct { + state protoimpl.MessageState `protogen:"open.v1"` + FirstRemovedEventSeq *uint64 `protobuf:"varint,1,opt,name=first_removed_event_seq,json=firstRemovedEventSeq,proto3,oneof" json:"first_removed_event_seq,omitempty"` + LastRemovedEventSeq *uint64 `protobuf:"varint,2,opt,name=last_removed_event_seq,json=lastRemovedEventSeq,proto3,oneof" json:"last_removed_event_seq,omitempty"` + // Absent when bytes were discarded before compression. + RemovedCompressedBytes *uint64 `protobuf:"varint,3,opt,name=removed_compressed_bytes,json=removedCompressedBytes,proto3,oneof" json:"removed_compressed_bytes,omitempty"` + RemovedUncompressedBytes uint64 `protobuf:"varint,4,opt,name=removed_uncompressed_bytes,json=removedUncompressedBytes,proto3" json:"removed_uncompressed_bytes,omitempty"` + Reason string `protobuf:"bytes,5,opt,name=reason,proto3" json:"reason,omitempty"` + Source OutputTruncationSource `protobuf:"varint,6,opt,name=source,proto3,enum=rvbox.v1.OutputTruncationSource" json:"source,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *OutputTruncation) Reset() { + *x = OutputTruncation{} + mi := &file_rvbox_v1_common_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *OutputTruncation) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*OutputTruncation) ProtoMessage() {} + +func (x *OutputTruncation) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_common_proto_msgTypes[9] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use OutputTruncation.ProtoReflect.Descriptor instead. +func (*OutputTruncation) Descriptor() ([]byte, []int) { + return file_rvbox_v1_common_proto_rawDescGZIP(), []int{9} +} + +func (x *OutputTruncation) GetFirstRemovedEventSeq() uint64 { + if x != nil && x.FirstRemovedEventSeq != nil { + return *x.FirstRemovedEventSeq + } + return 0 +} + +func (x *OutputTruncation) GetLastRemovedEventSeq() uint64 { + if x != nil && x.LastRemovedEventSeq != nil { + return *x.LastRemovedEventSeq + } + return 0 +} + +func (x *OutputTruncation) GetRemovedCompressedBytes() uint64 { + if x != nil && x.RemovedCompressedBytes != nil { + return *x.RemovedCompressedBytes + } + return 0 +} + +func (x *OutputTruncation) GetRemovedUncompressedBytes() uint64 { + if x != nil { + return x.RemovedUncompressedBytes + } + return 0 +} + +func (x *OutputTruncation) GetReason() string { + if x != nil { + return x.Reason + } + return "" +} + +func (x *OutputTruncation) GetSource() OutputTruncationSource { + if x != nil { + return x.Source + } + return OutputTruncationSource_OUTPUT_TRUNCATION_SOURCE_UNSPECIFIED +} + +// Indicates that capture ended without a provably complete byte stream. It is +// sequenced before the terminal lifecycle event but does not claim an invented +// event or byte range. +type OutputIncomplete struct { + state protoimpl.MessageState `protogen:"open.v1"` + Streams []StreamKind `protobuf:"varint,1,rep,packed,name=streams,proto3,enum=rvbox.v1.StreamKind" json:"streams,omitempty"` + Reason string `protobuf:"bytes,2,opt,name=reason,proto3" json:"reason,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *OutputIncomplete) Reset() { + *x = OutputIncomplete{} + mi := &file_rvbox_v1_common_proto_msgTypes[10] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *OutputIncomplete) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*OutputIncomplete) ProtoMessage() {} + +func (x *OutputIncomplete) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_common_proto_msgTypes[10] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use OutputIncomplete.ProtoReflect.Descriptor instead. +func (*OutputIncomplete) Descriptor() ([]byte, []int) { + return file_rvbox_v1_common_proto_rawDescGZIP(), []int{10} +} + +func (x *OutputIncomplete) GetStreams() []StreamKind { + if x != nil { + return x.Streams + } + return nil +} + +func (x *OutputIncomplete) GetReason() string { + if x != nil { + return x.Reason + } + return "" +} + +type StdinAcknowledgement struct { + state protoimpl.MessageState `protogen:"open.v1"` + WriteSeq uint64 `protobuf:"varint,1,opt,name=write_seq,json=writeSeq,proto3" json:"write_seq,omitempty"` + StdinClosed bool `protobuf:"varint,2,opt,name=stdin_closed,json=stdinClosed,proto3" json:"stdin_closed,omitempty"` + Detail string `protobuf:"bytes,3,opt,name=detail,proto3" json:"detail,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *StdinAcknowledgement) Reset() { + *x = StdinAcknowledgement{} + mi := &file_rvbox_v1_common_proto_msgTypes[11] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *StdinAcknowledgement) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*StdinAcknowledgement) ProtoMessage() {} + +func (x *StdinAcknowledgement) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_common_proto_msgTypes[11] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use StdinAcknowledgement.ProtoReflect.Descriptor instead. +func (*StdinAcknowledgement) Descriptor() ([]byte, []int) { + return file_rvbox_v1_common_proto_rawDescGZIP(), []int{11} +} + +func (x *StdinAcknowledgement) GetWriteSeq() uint64 { + if x != nil { + return x.WriteSeq + } + return 0 +} + +func (x *StdinAcknowledgement) GetStdinClosed() bool { + if x != nil { + return x.StdinClosed + } + return false +} + +func (x *StdinAcknowledgement) GetDetail() string { + if x != nil { + return x.Detail + } + return "" +} + +type SignalResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + Signal SignalKind `protobuf:"varint,1,opt,name=signal,proto3,enum=rvbox.v1.SignalKind" json:"signal,omitempty"` + Accepted bool `protobuf:"varint,2,opt,name=accepted,proto3" json:"accepted,omitempty"` + GracefulDeliveryAttempted bool `protobuf:"varint,3,opt,name=graceful_delivery_attempted,json=gracefulDeliveryAttempted,proto3" json:"graceful_delivery_attempted,omitempty"` + ForcedTerminationUsed bool `protobuf:"varint,4,opt,name=forced_termination_used,json=forcedTerminationUsed,proto3" json:"forced_termination_used,omitempty"` + Detail string `protobuf:"bytes,5,opt,name=detail,proto3" json:"detail,omitempty"` + CommandRevision uint64 `protobuf:"varint,6,opt,name=command_revision,json=commandRevision,proto3" json:"command_revision,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SignalResult) Reset() { + *x = SignalResult{} + mi := &file_rvbox_v1_common_proto_msgTypes[12] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SignalResult) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SignalResult) ProtoMessage() {} + +func (x *SignalResult) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_common_proto_msgTypes[12] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SignalResult.ProtoReflect.Descriptor instead. +func (*SignalResult) Descriptor() ([]byte, []int) { + return file_rvbox_v1_common_proto_rawDescGZIP(), []int{12} +} + +func (x *SignalResult) GetSignal() SignalKind { + if x != nil { + return x.Signal + } + return SignalKind_SIGNAL_KIND_UNSPECIFIED +} + +func (x *SignalResult) GetAccepted() bool { + if x != nil { + return x.Accepted + } + return false +} + +func (x *SignalResult) GetGracefulDeliveryAttempted() bool { + if x != nil { + return x.GracefulDeliveryAttempted + } + return false +} + +func (x *SignalResult) GetForcedTerminationUsed() bool { + if x != nil { + return x.ForcedTerminationUsed + } + return false +} + +func (x *SignalResult) GetDetail() string { + if x != nil { + return x.Detail + } + return "" +} + +func (x *SignalResult) GetCommandRevision() uint64 { + if x != nil { + return x.CommandRevision + } + return 0 +} + +type ScriptUploadStatus struct { + state protoimpl.MessageState `protogen:"open.v1"` + ReceivedBytes uint64 `protobuf:"varint,1,opt,name=received_bytes,json=receivedBytes,proto3" json:"received_bytes,omitempty"` + Complete bool `protobuf:"varint,2,opt,name=complete,proto3" json:"complete,omitempty"` + Detail string `protobuf:"bytes,3,opt,name=detail,proto3" json:"detail,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ScriptUploadStatus) Reset() { + *x = ScriptUploadStatus{} + mi := &file_rvbox_v1_common_proto_msgTypes[13] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ScriptUploadStatus) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ScriptUploadStatus) ProtoMessage() {} + +func (x *ScriptUploadStatus) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_common_proto_msgTypes[13] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ScriptUploadStatus.ProtoReflect.Descriptor instead. +func (*ScriptUploadStatus) Descriptor() ([]byte, []int) { + return file_rvbox_v1_common_proto_rawDescGZIP(), []int{13} +} + +func (x *ScriptUploadStatus) GetReceivedBytes() uint64 { + if x != nil { + return x.ReceivedBytes + } + return 0 +} + +func (x *ScriptUploadStatus) GetComplete() bool { + if x != nil { + return x.Complete + } + return false +} + +func (x *ScriptUploadStatus) GetDetail() string { + if x != nil { + return x.Detail + } + return "" +} + +// Client-originated ordered history. event_seq is strictly increasing per +// issue_uuid and is reused exactly on retransmission. +type CommandEvent struct { + state protoimpl.MessageState `protogen:"open.v1"` + IssueUuid string `protobuf:"bytes,1,opt,name=issue_uuid,json=issueUuid,proto3" json:"issue_uuid,omitempty"` + EventSeq uint64 `protobuf:"varint,2,opt,name=event_seq,json=eventSeq,proto3" json:"event_seq,omitempty"` + ObservedAt *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=observed_at,json=observedAt,proto3" json:"observed_at,omitempty"` + // Types that are valid to be assigned to Payload: + // + // *CommandEvent_Lifecycle + // *CommandEvent_Output + // *CommandEvent_Resource + // *CommandEvent_StdinAck + // *CommandEvent_SignalResult + // *CommandEvent_ScriptStatus + // *CommandEvent_OutputTruncation + // *CommandEvent_OutputIncomplete + Payload isCommandEvent_Payload `protobuf_oneof:"payload"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *CommandEvent) Reset() { + *x = CommandEvent{} + mi := &file_rvbox_v1_common_proto_msgTypes[14] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *CommandEvent) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CommandEvent) ProtoMessage() {} + +func (x *CommandEvent) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_common_proto_msgTypes[14] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CommandEvent.ProtoReflect.Descriptor instead. +func (*CommandEvent) Descriptor() ([]byte, []int) { + return file_rvbox_v1_common_proto_rawDescGZIP(), []int{14} +} + +func (x *CommandEvent) GetIssueUuid() string { + if x != nil { + return x.IssueUuid + } + return "" +} + +func (x *CommandEvent) GetEventSeq() uint64 { + if x != nil { + return x.EventSeq + } + return 0 +} + +func (x *CommandEvent) GetObservedAt() *timestamppb.Timestamp { + if x != nil { + return x.ObservedAt + } + return nil +} + +func (x *CommandEvent) GetPayload() isCommandEvent_Payload { + if x != nil { + return x.Payload + } + return nil +} + +func (x *CommandEvent) GetLifecycle() *LifecycleChange { + if x != nil { + if x, ok := x.Payload.(*CommandEvent_Lifecycle); ok { + return x.Lifecycle + } + } + return nil +} + +func (x *CommandEvent) GetOutput() *OutputChunk { + if x != nil { + if x, ok := x.Payload.(*CommandEvent_Output); ok { + return x.Output + } + } + return nil +} + +func (x *CommandEvent) GetResource() *ResourceSnapshot { + if x != nil { + if x, ok := x.Payload.(*CommandEvent_Resource); ok { + return x.Resource + } + } + return nil +} + +func (x *CommandEvent) GetStdinAck() *StdinAcknowledgement { + if x != nil { + if x, ok := x.Payload.(*CommandEvent_StdinAck); ok { + return x.StdinAck + } + } + return nil +} + +func (x *CommandEvent) GetSignalResult() *SignalResult { + if x != nil { + if x, ok := x.Payload.(*CommandEvent_SignalResult); ok { + return x.SignalResult + } + } + return nil +} + +func (x *CommandEvent) GetScriptStatus() *ScriptUploadStatus { + if x != nil { + if x, ok := x.Payload.(*CommandEvent_ScriptStatus); ok { + return x.ScriptStatus + } + } + return nil +} + +func (x *CommandEvent) GetOutputTruncation() *OutputTruncation { + if x != nil { + if x, ok := x.Payload.(*CommandEvent_OutputTruncation); ok { + return x.OutputTruncation + } + } + return nil +} + +func (x *CommandEvent) GetOutputIncomplete() *OutputIncomplete { + if x != nil { + if x, ok := x.Payload.(*CommandEvent_OutputIncomplete); ok { + return x.OutputIncomplete + } + } + return nil +} + +type isCommandEvent_Payload interface { + isCommandEvent_Payload() +} + +type CommandEvent_Lifecycle struct { + Lifecycle *LifecycleChange `protobuf:"bytes,4,opt,name=lifecycle,proto3,oneof"` +} + +type CommandEvent_Output struct { + Output *OutputChunk `protobuf:"bytes,5,opt,name=output,proto3,oneof"` +} + +type CommandEvent_Resource struct { + Resource *ResourceSnapshot `protobuf:"bytes,6,opt,name=resource,proto3,oneof"` +} + +type CommandEvent_StdinAck struct { + StdinAck *StdinAcknowledgement `protobuf:"bytes,7,opt,name=stdin_ack,json=stdinAck,proto3,oneof"` +} + +type CommandEvent_SignalResult struct { + SignalResult *SignalResult `protobuf:"bytes,8,opt,name=signal_result,json=signalResult,proto3,oneof"` +} + +type CommandEvent_ScriptStatus struct { + ScriptStatus *ScriptUploadStatus `protobuf:"bytes,9,opt,name=script_status,json=scriptStatus,proto3,oneof"` +} + +type CommandEvent_OutputTruncation struct { + OutputTruncation *OutputTruncation `protobuf:"bytes,10,opt,name=output_truncation,json=outputTruncation,proto3,oneof"` +} + +type CommandEvent_OutputIncomplete struct { + OutputIncomplete *OutputIncomplete `protobuf:"bytes,11,opt,name=output_incomplete,json=outputIncomplete,proto3,oneof"` +} + +func (*CommandEvent_Lifecycle) isCommandEvent_Payload() {} + +func (*CommandEvent_Output) isCommandEvent_Payload() {} + +func (*CommandEvent_Resource) isCommandEvent_Payload() {} + +func (*CommandEvent_StdinAck) isCommandEvent_Payload() {} + +func (*CommandEvent_SignalResult) isCommandEvent_Payload() {} + +func (*CommandEvent_ScriptStatus) isCommandEvent_Payload() {} + +func (*CommandEvent_OutputTruncation) isCommandEvent_Payload() {} + +func (*CommandEvent_OutputIncomplete) isCommandEvent_Payload() {} + +type ControlError struct { + state protoimpl.MessageState `protogen:"open.v1"` + Code ControlError_Code `protobuf:"varint,1,opt,name=code,proto3,enum=rvbox.v1.ControlError_Code" json:"code,omitempty"` + Message string `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"` + Retryable bool `protobuf:"varint,3,opt,name=retryable,proto3" json:"retryable,omitempty"` + IssueUuid string `protobuf:"bytes,4,opt,name=issue_uuid,json=issueUuid,proto3" json:"issue_uuid,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ControlError) Reset() { + *x = ControlError{} + mi := &file_rvbox_v1_common_proto_msgTypes[15] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ControlError) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ControlError) ProtoMessage() {} + +func (x *ControlError) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_common_proto_msgTypes[15] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ControlError.ProtoReflect.Descriptor instead. +func (*ControlError) Descriptor() ([]byte, []int) { + return file_rvbox_v1_common_proto_rawDescGZIP(), []int{15} +} + +func (x *ControlError) GetCode() ControlError_Code { + if x != nil { + return x.Code + } + return ControlError_CODE_UNSPECIFIED +} + +func (x *ControlError) GetMessage() string { + if x != nil { + return x.Message + } + return "" +} + +func (x *ControlError) GetRetryable() bool { + if x != nil { + return x.Retryable + } + return false +} + +func (x *ControlError) GetIssueUuid() string { + if x != nil { + return x.IssueUuid + } + return "" +} + +var File_rvbox_v1_common_proto protoreflect.FileDescriptor + +const file_rvbox_v1_common_proto_rawDesc = "" + + "\n" + + "\x15rvbox/v1/common.proto\x12\brvbox.v1\x1a\x1egoogle/protobuf/duration.proto\x1a\x1fgoogle/protobuf/timestamp.proto\"_\n" + + "\rProtocolRange\x12\x14\n" + + "\x05major\x18\x01 \x01(\rR\x05major\x12\x1b\n" + + "\tmin_minor\x18\x02 \x01(\rR\bminMinor\x12\x1b\n" + + "\tmax_minor\x18\x03 \x01(\rR\bmaxMinor\"=\n" + + "\x0fProtocolVersion\x12\x14\n" + + "\x05major\x18\x01 \x01(\rR\x05major\x12\x14\n" + + "\x05minor\x18\x02 \x01(\rR\x05minor\"e\n" + + "\x10ScriptDescriptor\x12\x1a\n" + + "\bfilename\x18\x01 \x01(\tR\bfilename\x12\x1d\n" + + "\n" + + "size_bytes\x18\x02 \x01(\x04R\tsizeBytes\x12\x16\n" + + "\x06sha256\x18\x03 \x01(\fR\x06sha256\"\xb2\x03\n" + + "\rExecutionSpec\x122\n" + + "\n" + + "shell_type\x18\x01 \x01(\x0e2\x13.rvbox.v1.ShellTypeR\tshellType\x12\x10\n" + + "\x03cwd\x18\x02 \x01(\tR\x03cwd\x12N\n" + + "\renv_overrides\x18\x03 \x03(\v2).rvbox.v1.ExecutionSpec.EnvOverridesEntryR\fenvOverrides\x12I\n" + + "\x12execution_profiles\x18\x04 \x03(\x0e2\x1a.rvbox.v1.ExecutionProfileR\x11executionProfiles\x12#\n" + + "\fcommand_text\x18\x05 \x01(\tH\x00R\vcommandText\x124\n" + + "\x06script\x18\x06 \x01(\v2\x1a.rvbox.v1.ScriptDescriptorH\x00R\x06script\x12\x1a\n" + + "\belevated\x18\a \x01(\bR\belevated\x1a?\n" + + "\x11EnvOverridesEntry\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + + "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01B\b\n" + + "\x06source\"\x8d\x03\n" + + "\x18WindowsExecutionIdentity\x12S\n" + + "\x11effective_context\x18\x01 \x01(\x0e2!.rvbox.v1.WindowsExecutionContextH\x00R\x10effectiveContext\x88\x01\x01\x12\"\n" + + "\n" + + "session_id\x18\x02 \x01(\rH\x01R\tsessionId\x88\x01\x01\x12(\n" + + "\x10session_user_sid\x18\x03 \x01(\tR\x0esessionUserSid\x12,\n" + + "\x12effective_user_sid\x18\x04 \x01(\tR\x10effectiveUserSid\x12P\n" + + "\x12attempted_contexts\x18\x05 \x03(\x0e2!.rvbox.v1.WindowsExecutionContextR\x11attemptedContexts\x12)\n" + + "\x10selection_detail\x18\x06 \x01(\tR\x0fselectionDetailB\x14\n" + + "\x12_effective_contextB\r\n" + + "\v_session_id\"\xa8\a\n" + + "\rCommandRecord\x12\x1d\n" + + "\n" + + "issue_uuid\x18\x01 \x01(\tR\tissueUuid\x12(\n" + + "\x10target_client_id\x18\x02 \x01(\tR\x0etargetClientId\x129\n" + + "\n" + + "issue_time\x18\x03 \x01(\v2\x1a.google.protobuf.TimestampR\tissueTime\x12J\n" + + "\x13server_receipt_time\x18\x04 \x01(\v2\x1a.google.protobuf.TimestampR\x11serverReceiptTime\x12+\n" + + "\x04spec\x18\x05 \x01(\v2\x17.rvbox.v1.ExecutionSpecR\x04spec\x128\n" + + "\tlifecycle\x18\x06 \x01(\x0e2\x1a.rvbox.v1.CommandLifecycleR\tlifecycle\x12$\n" + + "\x0elast_event_seq\x18\a \x01(\x04R\flastEventSeq\x12 \n" + + "\texit_code\x18\b \x01(\x05H\x00R\bexitCode\x88\x01\x01\x12?\n" + + "\rterminal_time\x18\t \x01(\v2\x1a.google.protobuf.TimestampR\fterminalTime\x12)\n" + + "\x10output_truncated\x18\n" + + " \x01(\bR\x0foutputTruncated\x12:\n" + + "\x19retained_compressed_bytes\x18\v \x01(\x04R\x17retainedCompressedBytes\x12F\n" + + "\x11queue_expiry_time\x18\f \x01(\v2\x1a.google.protobuf.TimestampR\x0fqueueExpiryTime\x12+\n" + + "\x11output_incomplete\x18\r \x01(\bR\x10outputIncomplete\x124\n" + + "\trejection\x18\x0e \x01(\v2\x16.rvbox.v1.ControlErrorR\trejection\x12)\n" + + "\x10command_revision\x18\x0f \x01(\x04R\x0fcommandRevision\x12*\n" + + "\x11late_after_expiry\x18\x10 \x01(\bR\x0flateAfterExpiry\x12`\n" + + "\x1awindows_execution_identity\x18\x11 \x01(\v2\".rvbox.v1.WindowsExecutionIdentityR\x18windowsExecutionIdentityB\f\n" + + "\n" + + "_exit_code\"\xa0\x02\n" + + "\x0fLifecycleChange\x128\n" + + "\tlifecycle\x18\x01 \x01(\x0e2\x1a.rvbox.v1.CommandLifecycleR\tlifecycle\x12 \n" + + "\texit_code\x18\x02 \x01(\x05H\x00R\bexitCode\x88\x01\x01\x12\x16\n" + + "\x06detail\x18\x03 \x01(\tR\x06detail\x12)\n" + + "\x10command_revision\x18\x04 \x01(\x04R\x0fcommandRevision\x12`\n" + + "\x1awindows_execution_identity\x18\x05 \x01(\v2\".rvbox.v1.WindowsExecutionIdentityR\x18windowsExecutionIdentityB\f\n" + + "\n" + + "_exit_code\"\xde\x01\n" + + "\vOutputChunk\x12,\n" + + "\x06stream\x18\x01 \x01(\x0e2\x14.rvbox.v1.StreamKindR\x06stream\x127\n" + + "\vcompression\x18\x02 \x01(\x0e2\x15.rvbox.v1.CompressionR\vcompression\x12\x12\n" + + "\x04data\x18\x03 \x01(\fR\x04data\x12+\n" + + "\x11uncompressed_size\x18\x04 \x01(\x04R\x10uncompressedSize\x12'\n" + + "\x0fcompressed_size\x18\x05 \x01(\x04R\x0ecompressedSize\"\xd0\x04\n" + + "\x10ResourceSnapshot\x127\n" + + "\x15resident_memory_bytes\x18\x01 \x01(\x04H\x00R\x13residentMemoryBytes\x88\x01\x01\x125\n" + + "\x14virtual_memory_bytes\x18\x02 \x01(\x04H\x01R\x12virtualMemoryBytes\x88\x01\x01\x124\n" + + "\bcpu_time\x18\x03 \x01(\v2\x19.google.protobuf.DurationR\acpuTime\x12\"\n" + + "\n" + + "read_bytes\x18\x04 \x01(\x04H\x02R\treadBytes\x88\x01\x01\x12$\n" + + "\vwrite_bytes\x18\x05 \x01(\x04H\x03R\n" + + "writeBytes\x88\x01\x01\x12(\n" + + "\rprocess_state\x18\x06 \x01(\tH\x04R\fprocessState\x88\x01\x01\x12$\n" + + "\vwait_reason\x18\a \x01(\tH\x05R\n" + + "waitReason\x88\x01\x01\x12%\n" + + "\x0esuspected_hung\x18\b \x01(\bR\rsuspectedHung\x12+\n" + + "\x11diagnostic_detail\x18\t \x01(\tR\x10diagnosticDetail\x12$\n" + + "\vcurrent_cwd\x18\n" + + " \x01(\tH\x06R\n" + + "currentCwd\x88\x01\x01B\x18\n" + + "\x16_resident_memory_bytesB\x17\n" + + "\x15_virtual_memory_bytesB\r\n" + + "\v_read_bytesB\x0e\n" + + "\f_write_bytesB\x10\n" + + "\x0e_process_stateB\x0e\n" + + "\f_wait_reasonB\x0e\n" + + "\f_current_cwd\"\xab\x03\n" + + "\x10OutputTruncation\x12:\n" + + "\x17first_removed_event_seq\x18\x01 \x01(\x04H\x00R\x14firstRemovedEventSeq\x88\x01\x01\x128\n" + + "\x16last_removed_event_seq\x18\x02 \x01(\x04H\x01R\x13lastRemovedEventSeq\x88\x01\x01\x12=\n" + + "\x18removed_compressed_bytes\x18\x03 \x01(\x04H\x02R\x16removedCompressedBytes\x88\x01\x01\x12<\n" + + "\x1aremoved_uncompressed_bytes\x18\x04 \x01(\x04R\x18removedUncompressedBytes\x12\x16\n" + + "\x06reason\x18\x05 \x01(\tR\x06reason\x128\n" + + "\x06source\x18\x06 \x01(\x0e2 .rvbox.v1.OutputTruncationSourceR\x06sourceB\x1a\n" + + "\x18_first_removed_event_seqB\x19\n" + + "\x17_last_removed_event_seqB\x1b\n" + + "\x19_removed_compressed_bytes\"Z\n" + + "\x10OutputIncomplete\x12.\n" + + "\astreams\x18\x01 \x03(\x0e2\x14.rvbox.v1.StreamKindR\astreams\x12\x16\n" + + "\x06reason\x18\x02 \x01(\tR\x06reason\"n\n" + + "\x14StdinAcknowledgement\x12\x1b\n" + + "\twrite_seq\x18\x01 \x01(\x04R\bwriteSeq\x12!\n" + + "\fstdin_closed\x18\x02 \x01(\bR\vstdinClosed\x12\x16\n" + + "\x06detail\x18\x03 \x01(\tR\x06detail\"\x93\x02\n" + + "\fSignalResult\x12,\n" + + "\x06signal\x18\x01 \x01(\x0e2\x14.rvbox.v1.SignalKindR\x06signal\x12\x1a\n" + + "\baccepted\x18\x02 \x01(\bR\baccepted\x12>\n" + + "\x1bgraceful_delivery_attempted\x18\x03 \x01(\bR\x19gracefulDeliveryAttempted\x126\n" + + "\x17forced_termination_used\x18\x04 \x01(\bR\x15forcedTerminationUsed\x12\x16\n" + + "\x06detail\x18\x05 \x01(\tR\x06detail\x12)\n" + + "\x10command_revision\x18\x06 \x01(\x04R\x0fcommandRevision\"o\n" + + "\x12ScriptUploadStatus\x12%\n" + + "\x0ereceived_bytes\x18\x01 \x01(\x04R\rreceivedBytes\x12\x1a\n" + + "\bcomplete\x18\x02 \x01(\bR\bcomplete\x12\x16\n" + + "\x06detail\x18\x03 \x01(\tR\x06detail\"\x91\x05\n" + + "\fCommandEvent\x12\x1d\n" + + "\n" + + "issue_uuid\x18\x01 \x01(\tR\tissueUuid\x12\x1b\n" + + "\tevent_seq\x18\x02 \x01(\x04R\beventSeq\x12;\n" + + "\vobserved_at\x18\x03 \x01(\v2\x1a.google.protobuf.TimestampR\n" + + "observedAt\x129\n" + + "\tlifecycle\x18\x04 \x01(\v2\x19.rvbox.v1.LifecycleChangeH\x00R\tlifecycle\x12/\n" + + "\x06output\x18\x05 \x01(\v2\x15.rvbox.v1.OutputChunkH\x00R\x06output\x128\n" + + "\bresource\x18\x06 \x01(\v2\x1a.rvbox.v1.ResourceSnapshotH\x00R\bresource\x12=\n" + + "\tstdin_ack\x18\a \x01(\v2\x1e.rvbox.v1.StdinAcknowledgementH\x00R\bstdinAck\x12=\n" + + "\rsignal_result\x18\b \x01(\v2\x16.rvbox.v1.SignalResultH\x00R\fsignalResult\x12C\n" + + "\rscript_status\x18\t \x01(\v2\x1c.rvbox.v1.ScriptUploadStatusH\x00R\fscriptStatus\x12I\n" + + "\x11output_truncation\x18\n" + + " \x01(\v2\x1a.rvbox.v1.OutputTruncationH\x00R\x10outputTruncation\x12I\n" + + "\x11output_incomplete\x18\v \x01(\v2\x1a.rvbox.v1.OutputIncompleteH\x00R\x10outputIncompleteB\t\n" + + "\apayload\"\xb2\x03\n" + + "\fControlError\x12/\n" + + "\x04code\x18\x01 \x01(\x0e2\x1b.rvbox.v1.ControlError.CodeR\x04code\x12\x18\n" + + "\amessage\x18\x02 \x01(\tR\amessage\x12\x1c\n" + + "\tretryable\x18\x03 \x01(\bR\tretryable\x12\x1d\n" + + "\n" + + "issue_uuid\x18\x04 \x01(\tR\tissueUuid\"\x99\x02\n" + + "\x04Code\x12\x14\n" + + "\x10CODE_UNSPECIFIED\x10\x00\x12\x14\n" + + "\x10INVALID_ARGUMENT\x10\x01\x12\r\n" + + "\tNOT_FOUND\x10\x02\x12\v\n" + + "\aOFFLINE\x10\x03\x12\x16\n" + + "\x12CAPACITY_EXHAUSTED\x10\x04\x12\f\n" + + "\bCONFLICT\x10\x05\x12\x0f\n" + + "\vUNSUPPORTED\x10\x06\x12\x12\n" + + "\x0ePROTOCOL_ERROR\x10\a\x12\r\n" + + "\tTRANSIENT\x10\b\x12\f\n" + + "\bINTERNAL\x10\t\x12\x19\n" + + "\x15CODE_ALREADY_EXECUTED\x10\n" + + "\x12&\n" + + "\"CODE_EXECUTION_CONTEXT_UNAVAILABLE\x10\v\x12\x1e\n" + + "\x1aCODE_ELEVATION_UNAVAILABLE\x10\f*|\n" + + "\bPlatform\x12\x18\n" + + "\x14PLATFORM_UNSPECIFIED\x10\x00\x12\x12\n" + + "\x0ePLATFORM_LINUX\x10\x01\x12\x13\n" + + "\x0fPLATFORM_DARWIN\x10\x02\x12\x14\n" + + "\x10PLATFORM_WINDOWS\x10\x03\x12\x17\n" + + "\x13PLATFORM_OTHER_UNIX\x10\x04*j\n" + + "\tShellType\x12\x1a\n" + + "\x16SHELL_TYPE_UNSPECIFIED\x10\x00\x12\f\n" + + "\bSHELL_SH\x10\x01\x12\x0e\n" + + "\n" + + "SHELL_BASH\x10\x02\x12\r\n" + + "\tSHELL_CMD\x10\x03\x12\x14\n" + + "\x10SHELL_POWERSHELL\x10\x04*\xa9\x02\n" + + "\x17WindowsExecutionContext\x12)\n" + + "%WINDOWS_EXECUTION_CONTEXT_UNSPECIFIED\x10\x00\x12+\n" + + "'WINDOWS_EXECUTION_CONTEXT_LOCAL_SERVICE\x10\x01\x12*\n" + + "&WINDOWS_EXECUTION_CONTEXT_LOCAL_SYSTEM\x10\x02\x12)\n" + + "%WINDOWS_EXECUTION_CONTEXT_ACTIVE_USER\x10\x03\x122\n" + + ".WINDOWS_EXECUTION_CONTEXT_ACTIVE_USER_ELEVATED\x10\x04\x12+\n" + + "'WINDOWS_EXECUTION_CONTEXT_ACTIVE_SYSTEM\x10\x05*V\n" + + "\vCompression\x12\x1b\n" + + "\x17COMPRESSION_UNSPECIFIED\x10\x00\x12\x14\n" + + "\x10COMPRESSION_NONE\x10\x01\x12\x14\n" + + "\x10COMPRESSION_ZSTD\x10\x02*\xaa\x02\n" + + "\x10CommandLifecycle\x12!\n" + + "\x1dCOMMAND_LIFECYCLE_UNSPECIFIED\x10\x00\x12\x12\n" + + "\x0eCOMMAND_QUEUED\x10\x01\x12\x16\n" + + "\x12COMMAND_DISPATCHED\x10\x02\x12\x14\n" + + "\x10COMMAND_ACCEPTED\x10\x03\x12\x13\n" + + "\x0fCOMMAND_RUNNING\x10\x04\x12\x15\n" + + "\x11COMMAND_SUCCEEDED\x10\x05\x12\x12\n" + + "\x0eCOMMAND_FAILED\x10\x06\x12\x16\n" + + "\x12COMMAND_TERMINATED\x10\a\x12\x15\n" + + "\x11COMMAND_CANCELLED\x10\b\x12\x17\n" + + "\x13COMMAND_INTERRUPTED\x10\t\x12\x13\n" + + "\x0fCOMMAND_EXPIRED\x10\n" + + "\x12\x14\n" + + "\x10COMMAND_REJECTED\x10\v*O\n" + + "\n" + + "StreamKind\x12\x1b\n" + + "\x17STREAM_KIND_UNSPECIFIED\x10\x00\x12\x11\n" + + "\rSTREAM_STDOUT\x10\x01\x12\x11\n" + + "\rSTREAM_STDERR\x10\x02*\x8d\x01\n" + + "\n" + + "SignalKind\x12\x1b\n" + + "\x17SIGNAL_KIND_UNSPECIFIED\x10\x00\x12\x0e\n" + + "\n" + + "SIGNAL_HUP\x10\x01\x12\x0e\n" + + "\n" + + "SIGNAL_INT\x10\x02\x12\x0f\n" + + "\vSIGNAL_TERM\x10\x03\x12\x0f\n" + + "\vSIGNAL_KILL\x10\x04\x12\x0f\n" + + "\vSIGNAL_USR1\x10\x05\x12\x0f\n" + + "\vSIGNAL_USR2\x10\x06*\x9d\x02\n" + + "\x10ExecutionProfile\x12!\n" + + "\x1dEXECUTION_PROFILE_UNSPECIFIED\x10\x00\x12\x1b\n" + + "\x17EXECUTION_PROFILE_LIGHT\x10\x01\x12 \n" + + "\x1cEXECUTION_PROFILE_CPU_MEDIUM\x10\x02\x12\x1f\n" + + "\x1bEXECUTION_PROFILE_CPU_HEAVY\x10\x03\x12 \n" + + "\x1cEXECUTION_PROFILE_MEM_MEDIUM\x10\x04\x12\x1f\n" + + "\x1bEXECUTION_PROFILE_MEM_HEAVY\x10\x05\x12!\n" + + "\x1dEXECUTION_PROFILE_DISK_MEDIUM\x10\x06\x12 \n" + + "\x1cEXECUTION_PROFILE_DISK_HEAVY\x10\a*\xaf\x02\n" + + "\x16OutputTruncationSource\x12(\n" + + "$OUTPUT_TRUNCATION_SOURCE_UNSPECIFIED\x10\x00\x12)\n" + + "%OUTPUT_TRUNCATION_SOURCE_CLIENT_SPOOL\x10\x01\x122\n" + + ".OUTPUT_TRUNCATION_SOURCE_SERVER_COMMAND_WINDOW\x10\x02\x12.\n" + + "*OUTPUT_TRUNCATION_SOURCE_SERVER_CLIENT_CAP\x10\x03\x12,\n" + + "(OUTPUT_TRUNCATION_SOURCE_CLIENT_OVERLOAD\x10\x04\x12.\n" + + "*OUTPUT_TRUNCATION_SOURCE_SERVER_GLOBAL_CAP\x10\x05B0Z.github.com/rvbox/rvbox/gen/go/rvbox/v1;rvboxv1b\x06proto3" + +var ( + file_rvbox_v1_common_proto_rawDescOnce sync.Once + file_rvbox_v1_common_proto_rawDescData []byte +) + +func file_rvbox_v1_common_proto_rawDescGZIP() []byte { + file_rvbox_v1_common_proto_rawDescOnce.Do(func() { + file_rvbox_v1_common_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_rvbox_v1_common_proto_rawDesc), len(file_rvbox_v1_common_proto_rawDesc))) + }) + return file_rvbox_v1_common_proto_rawDescData +} + +var file_rvbox_v1_common_proto_enumTypes = make([]protoimpl.EnumInfo, 10) +var file_rvbox_v1_common_proto_msgTypes = make([]protoimpl.MessageInfo, 17) +var file_rvbox_v1_common_proto_goTypes = []any{ + (Platform)(0), // 0: rvbox.v1.Platform + (ShellType)(0), // 1: rvbox.v1.ShellType + (WindowsExecutionContext)(0), // 2: rvbox.v1.WindowsExecutionContext + (Compression)(0), // 3: rvbox.v1.Compression + (CommandLifecycle)(0), // 4: rvbox.v1.CommandLifecycle + (StreamKind)(0), // 5: rvbox.v1.StreamKind + (SignalKind)(0), // 6: rvbox.v1.SignalKind + (ExecutionProfile)(0), // 7: rvbox.v1.ExecutionProfile + (OutputTruncationSource)(0), // 8: rvbox.v1.OutputTruncationSource + (ControlError_Code)(0), // 9: rvbox.v1.ControlError.Code + (*ProtocolRange)(nil), // 10: rvbox.v1.ProtocolRange + (*ProtocolVersion)(nil), // 11: rvbox.v1.ProtocolVersion + (*ScriptDescriptor)(nil), // 12: rvbox.v1.ScriptDescriptor + (*ExecutionSpec)(nil), // 13: rvbox.v1.ExecutionSpec + (*WindowsExecutionIdentity)(nil), // 14: rvbox.v1.WindowsExecutionIdentity + (*CommandRecord)(nil), // 15: rvbox.v1.CommandRecord + (*LifecycleChange)(nil), // 16: rvbox.v1.LifecycleChange + (*OutputChunk)(nil), // 17: rvbox.v1.OutputChunk + (*ResourceSnapshot)(nil), // 18: rvbox.v1.ResourceSnapshot + (*OutputTruncation)(nil), // 19: rvbox.v1.OutputTruncation + (*OutputIncomplete)(nil), // 20: rvbox.v1.OutputIncomplete + (*StdinAcknowledgement)(nil), // 21: rvbox.v1.StdinAcknowledgement + (*SignalResult)(nil), // 22: rvbox.v1.SignalResult + (*ScriptUploadStatus)(nil), // 23: rvbox.v1.ScriptUploadStatus + (*CommandEvent)(nil), // 24: rvbox.v1.CommandEvent + (*ControlError)(nil), // 25: rvbox.v1.ControlError + nil, // 26: rvbox.v1.ExecutionSpec.EnvOverridesEntry + (*timestamppb.Timestamp)(nil), // 27: google.protobuf.Timestamp + (*durationpb.Duration)(nil), // 28: google.protobuf.Duration +} +var file_rvbox_v1_common_proto_depIdxs = []int32{ + 1, // 0: rvbox.v1.ExecutionSpec.shell_type:type_name -> rvbox.v1.ShellType + 26, // 1: rvbox.v1.ExecutionSpec.env_overrides:type_name -> rvbox.v1.ExecutionSpec.EnvOverridesEntry + 7, // 2: rvbox.v1.ExecutionSpec.execution_profiles:type_name -> rvbox.v1.ExecutionProfile + 12, // 3: rvbox.v1.ExecutionSpec.script:type_name -> rvbox.v1.ScriptDescriptor + 2, // 4: rvbox.v1.WindowsExecutionIdentity.effective_context:type_name -> rvbox.v1.WindowsExecutionContext + 2, // 5: rvbox.v1.WindowsExecutionIdentity.attempted_contexts:type_name -> rvbox.v1.WindowsExecutionContext + 27, // 6: rvbox.v1.CommandRecord.issue_time:type_name -> google.protobuf.Timestamp + 27, // 7: rvbox.v1.CommandRecord.server_receipt_time:type_name -> google.protobuf.Timestamp + 13, // 8: rvbox.v1.CommandRecord.spec:type_name -> rvbox.v1.ExecutionSpec + 4, // 9: rvbox.v1.CommandRecord.lifecycle:type_name -> rvbox.v1.CommandLifecycle + 27, // 10: rvbox.v1.CommandRecord.terminal_time:type_name -> google.protobuf.Timestamp + 27, // 11: rvbox.v1.CommandRecord.queue_expiry_time:type_name -> google.protobuf.Timestamp + 25, // 12: rvbox.v1.CommandRecord.rejection:type_name -> rvbox.v1.ControlError + 14, // 13: rvbox.v1.CommandRecord.windows_execution_identity:type_name -> rvbox.v1.WindowsExecutionIdentity + 4, // 14: rvbox.v1.LifecycleChange.lifecycle:type_name -> rvbox.v1.CommandLifecycle + 14, // 15: rvbox.v1.LifecycleChange.windows_execution_identity:type_name -> rvbox.v1.WindowsExecutionIdentity + 5, // 16: rvbox.v1.OutputChunk.stream:type_name -> rvbox.v1.StreamKind + 3, // 17: rvbox.v1.OutputChunk.compression:type_name -> rvbox.v1.Compression + 28, // 18: rvbox.v1.ResourceSnapshot.cpu_time:type_name -> google.protobuf.Duration + 8, // 19: rvbox.v1.OutputTruncation.source:type_name -> rvbox.v1.OutputTruncationSource + 5, // 20: rvbox.v1.OutputIncomplete.streams:type_name -> rvbox.v1.StreamKind + 6, // 21: rvbox.v1.SignalResult.signal:type_name -> rvbox.v1.SignalKind + 27, // 22: rvbox.v1.CommandEvent.observed_at:type_name -> google.protobuf.Timestamp + 16, // 23: rvbox.v1.CommandEvent.lifecycle:type_name -> rvbox.v1.LifecycleChange + 17, // 24: rvbox.v1.CommandEvent.output:type_name -> rvbox.v1.OutputChunk + 18, // 25: rvbox.v1.CommandEvent.resource:type_name -> rvbox.v1.ResourceSnapshot + 21, // 26: rvbox.v1.CommandEvent.stdin_ack:type_name -> rvbox.v1.StdinAcknowledgement + 22, // 27: rvbox.v1.CommandEvent.signal_result:type_name -> rvbox.v1.SignalResult + 23, // 28: rvbox.v1.CommandEvent.script_status:type_name -> rvbox.v1.ScriptUploadStatus + 19, // 29: rvbox.v1.CommandEvent.output_truncation:type_name -> rvbox.v1.OutputTruncation + 20, // 30: rvbox.v1.CommandEvent.output_incomplete:type_name -> rvbox.v1.OutputIncomplete + 9, // 31: rvbox.v1.ControlError.code:type_name -> rvbox.v1.ControlError.Code + 32, // [32:32] is the sub-list for method output_type + 32, // [32:32] is the sub-list for method input_type + 32, // [32:32] is the sub-list for extension type_name + 32, // [32:32] is the sub-list for extension extendee + 0, // [0:32] is the sub-list for field type_name +} + +func init() { file_rvbox_v1_common_proto_init() } +func file_rvbox_v1_common_proto_init() { + if File_rvbox_v1_common_proto != nil { + return + } + file_rvbox_v1_common_proto_msgTypes[3].OneofWrappers = []any{ + (*ExecutionSpec_CommandText)(nil), + (*ExecutionSpec_Script)(nil), + } + file_rvbox_v1_common_proto_msgTypes[4].OneofWrappers = []any{} + file_rvbox_v1_common_proto_msgTypes[5].OneofWrappers = []any{} + file_rvbox_v1_common_proto_msgTypes[6].OneofWrappers = []any{} + file_rvbox_v1_common_proto_msgTypes[8].OneofWrappers = []any{} + file_rvbox_v1_common_proto_msgTypes[9].OneofWrappers = []any{} + file_rvbox_v1_common_proto_msgTypes[14].OneofWrappers = []any{ + (*CommandEvent_Lifecycle)(nil), + (*CommandEvent_Output)(nil), + (*CommandEvent_Resource)(nil), + (*CommandEvent_StdinAck)(nil), + (*CommandEvent_SignalResult)(nil), + (*CommandEvent_ScriptStatus)(nil), + (*CommandEvent_OutputTruncation)(nil), + (*CommandEvent_OutputIncomplete)(nil), + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: unsafe.Slice(unsafe.StringData(file_rvbox_v1_common_proto_rawDesc), len(file_rvbox_v1_common_proto_rawDesc)), + NumEnums: 10, + NumMessages: 17, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_rvbox_v1_common_proto_goTypes, + DependencyIndexes: file_rvbox_v1_common_proto_depIdxs, + EnumInfos: file_rvbox_v1_common_proto_enumTypes, + MessageInfos: file_rvbox_v1_common_proto_msgTypes, + }.Build() + File_rvbox_v1_common_proto = out.File + file_rvbox_v1_common_proto_goTypes = nil + file_rvbox_v1_common_proto_depIdxs = nil +} diff --git a/gen/go/rvbox/v1/control.pb.go b/gen/go/rvbox/v1/control.pb.go new file mode 100644 index 0000000..9a9c940 --- /dev/null +++ b/gen/go/rvbox/v1/control.pb.go @@ -0,0 +1,2471 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.36.12 +// protoc (unknown) +// source: rvbox/v1/control.proto + +package rvboxv1 + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + durationpb "google.golang.org/protobuf/types/known/durationpb" + timestamppb "google.golang.org/protobuf/types/known/timestamppb" + reflect "reflect" + sync "sync" + unsafe "unsafe" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +type StorageIncidentState int32 + +const ( + StorageIncidentState_STORAGE_INCIDENT_STATE_UNSPECIFIED StorageIncidentState = 0 + StorageIncidentState_STORAGE_INCIDENT_STATE_OPEN StorageIncidentState = 1 + StorageIncidentState_STORAGE_INCIDENT_STATE_REPAIRED StorageIncidentState = 2 + StorageIncidentState_STORAGE_INCIDENT_STATE_ACKNOWLEDGED StorageIncidentState = 3 +) + +// Enum value maps for StorageIncidentState. +var ( + StorageIncidentState_name = map[int32]string{ + 0: "STORAGE_INCIDENT_STATE_UNSPECIFIED", + 1: "STORAGE_INCIDENT_STATE_OPEN", + 2: "STORAGE_INCIDENT_STATE_REPAIRED", + 3: "STORAGE_INCIDENT_STATE_ACKNOWLEDGED", + } + StorageIncidentState_value = map[string]int32{ + "STORAGE_INCIDENT_STATE_UNSPECIFIED": 0, + "STORAGE_INCIDENT_STATE_OPEN": 1, + "STORAGE_INCIDENT_STATE_REPAIRED": 2, + "STORAGE_INCIDENT_STATE_ACKNOWLEDGED": 3, + } +) + +func (x StorageIncidentState) Enum() *StorageIncidentState { + p := new(StorageIncidentState) + *p = x + return p +} + +func (x StorageIncidentState) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (StorageIncidentState) Descriptor() protoreflect.EnumDescriptor { + return file_rvbox_v1_control_proto_enumTypes[0].Descriptor() +} + +func (StorageIncidentState) Type() protoreflect.EnumType { + return &file_rvbox_v1_control_proto_enumTypes[0] +} + +func (x StorageIncidentState) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use StorageIncidentState.Descriptor instead. +func (StorageIncidentState) EnumDescriptor() ([]byte, []int) { + return file_rvbox_v1_control_proto_rawDescGZIP(), []int{0} +} + +type ClientSummary struct { + state protoimpl.MessageState `protogen:"open.v1"` + ClientId string `protobuf:"bytes,1,opt,name=client_id,json=clientId,proto3" json:"client_id,omitempty"` + Connected bool `protobuf:"varint,2,opt,name=connected,proto3" json:"connected,omitempty"` + ConnectedAt *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=connected_at,json=connectedAt,proto3" json:"connected_at,omitempty"` + LastSeenAt *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=last_seen_at,json=lastSeenAt,proto3" json:"last_seen_at,omitempty"` + RunningCommands uint32 `protobuf:"varint,5,opt,name=running_commands,json=runningCommands,proto3" json:"running_commands,omitempty"` + QueuedCommands uint32 `protobuf:"varint,6,opt,name=queued_commands,json=queuedCommands,proto3" json:"queued_commands,omitempty"` + Platform Platform `protobuf:"varint,7,opt,name=platform,proto3,enum=rvbox.v1.Platform" json:"platform,omitempty"` + Architecture string `protobuf:"bytes,8,opt,name=architecture,proto3" json:"architecture,omitempty"` + DaemonVersion string `protobuf:"bytes,9,opt,name=daemon_version,json=daemonVersion,proto3" json:"daemon_version,omitempty"` + // Omitted-CWD default on Unix; protected per-identity work root on Windows. + DaemonCwd string `protobuf:"bytes,10,opt,name=daemon_cwd,json=daemonCwd,proto3" json:"daemon_cwd,omitempty"` + SupportedShells []ShellType `protobuf:"varint,11,rep,packed,name=supported_shells,json=supportedShells,proto3,enum=rvbox.v1.ShellType" json:"supported_shells,omitempty"` + ClientInstanceId string `protobuf:"bytes,12,opt,name=client_instance_id,json=clientInstanceId,proto3" json:"client_instance_id,omitempty"` + // Most recently rejected different instance while this client is live. + PendingInstanceId string `protobuf:"bytes,13,opt,name=pending_instance_id,json=pendingInstanceId,proto3" json:"pending_instance_id,omitempty"` + PendingInstanceSeenAt *timestamppb.Timestamp `protobuf:"bytes,14,opt,name=pending_instance_seen_at,json=pendingInstanceSeenAt,proto3" json:"pending_instance_seen_at,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ClientSummary) Reset() { + *x = ClientSummary{} + mi := &file_rvbox_v1_control_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ClientSummary) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ClientSummary) ProtoMessage() {} + +func (x *ClientSummary) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_control_proto_msgTypes[0] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ClientSummary.ProtoReflect.Descriptor instead. +func (*ClientSummary) Descriptor() ([]byte, []int) { + return file_rvbox_v1_control_proto_rawDescGZIP(), []int{0} +} + +func (x *ClientSummary) GetClientId() string { + if x != nil { + return x.ClientId + } + return "" +} + +func (x *ClientSummary) GetConnected() bool { + if x != nil { + return x.Connected + } + return false +} + +func (x *ClientSummary) GetConnectedAt() *timestamppb.Timestamp { + if x != nil { + return x.ConnectedAt + } + return nil +} + +func (x *ClientSummary) GetLastSeenAt() *timestamppb.Timestamp { + if x != nil { + return x.LastSeenAt + } + return nil +} + +func (x *ClientSummary) GetRunningCommands() uint32 { + if x != nil { + return x.RunningCommands + } + return 0 +} + +func (x *ClientSummary) GetQueuedCommands() uint32 { + if x != nil { + return x.QueuedCommands + } + return 0 +} + +func (x *ClientSummary) GetPlatform() Platform { + if x != nil { + return x.Platform + } + return Platform_PLATFORM_UNSPECIFIED +} + +func (x *ClientSummary) GetArchitecture() string { + if x != nil { + return x.Architecture + } + return "" +} + +func (x *ClientSummary) GetDaemonVersion() string { + if x != nil { + return x.DaemonVersion + } + return "" +} + +func (x *ClientSummary) GetDaemonCwd() string { + if x != nil { + return x.DaemonCwd + } + return "" +} + +func (x *ClientSummary) GetSupportedShells() []ShellType { + if x != nil { + return x.SupportedShells + } + return nil +} + +func (x *ClientSummary) GetClientInstanceId() string { + if x != nil { + return x.ClientInstanceId + } + return "" +} + +func (x *ClientSummary) GetPendingInstanceId() string { + if x != nil { + return x.PendingInstanceId + } + return "" +} + +func (x *ClientSummary) GetPendingInstanceSeenAt() *timestamppb.Timestamp { + if x != nil { + return x.PendingInstanceSeenAt + } + return nil +} + +type ListClientsRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + PageSize uint32 `protobuf:"varint,1,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"` + PageToken string `protobuf:"bytes,2,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ListClientsRequest) Reset() { + *x = ListClientsRequest{} + mi := &file_rvbox_v1_control_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ListClientsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListClientsRequest) ProtoMessage() {} + +func (x *ListClientsRequest) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_control_proto_msgTypes[1] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ListClientsRequest.ProtoReflect.Descriptor instead. +func (*ListClientsRequest) Descriptor() ([]byte, []int) { + return file_rvbox_v1_control_proto_rawDescGZIP(), []int{1} +} + +func (x *ListClientsRequest) GetPageSize() uint32 { + if x != nil { + return x.PageSize + } + return 0 +} + +func (x *ListClientsRequest) GetPageToken() string { + if x != nil { + return x.PageToken + } + return "" +} + +type ListClientsResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Clients []*ClientSummary `protobuf:"bytes,1,rep,name=clients,proto3" json:"clients,omitempty"` + NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ListClientsResponse) Reset() { + *x = ListClientsResponse{} + mi := &file_rvbox_v1_control_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ListClientsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListClientsResponse) ProtoMessage() {} + +func (x *ListClientsResponse) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_control_proto_msgTypes[2] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ListClientsResponse.ProtoReflect.Descriptor instead. +func (*ListClientsResponse) Descriptor() ([]byte, []int) { + return file_rvbox_v1_control_proto_rawDescGZIP(), []int{2} +} + +func (x *ListClientsResponse) GetClients() []*ClientSummary { + if x != nil { + return x.Clients + } + return nil +} + +func (x *ListClientsResponse) GetNextPageToken() string { + if x != nil { + return x.NextPageToken + } + return "" +} + +type GetClientRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + ClientId string `protobuf:"bytes,1,opt,name=client_id,json=clientId,proto3" json:"client_id,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *GetClientRequest) Reset() { + *x = GetClientRequest{} + mi := &file_rvbox_v1_control_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GetClientRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetClientRequest) ProtoMessage() {} + +func (x *GetClientRequest) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_control_proto_msgTypes[3] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetClientRequest.ProtoReflect.Descriptor instead. +func (*GetClientRequest) Descriptor() ([]byte, []int) { + return file_rvbox_v1_control_proto_rawDescGZIP(), []int{3} +} + +func (x *GetClientRequest) GetClientId() string { + if x != nil { + return x.ClientId + } + return "" +} + +type GetClientResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Client *ClientSummary `protobuf:"bytes,1,opt,name=client,proto3" json:"client,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *GetClientResponse) Reset() { + *x = GetClientResponse{} + mi := &file_rvbox_v1_control_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GetClientResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetClientResponse) ProtoMessage() {} + +func (x *GetClientResponse) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_control_proto_msgTypes[4] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetClientResponse.ProtoReflect.Descriptor instead. +func (*GetClientResponse) Descriptor() ([]byte, []int) { + return file_rvbox_v1_control_proto_rawDescGZIP(), []int{4} +} + +func (x *GetClientResponse) GetClient() *ClientSummary { + if x != nil { + return x.Client + } + return nil +} + +type ListCommandsRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + ClientId string `protobuf:"bytes,1,opt,name=client_id,json=clientId,proto3" json:"client_id,omitempty"` + IncludeTerminal bool `protobuf:"varint,2,opt,name=include_terminal,json=includeTerminal,proto3" json:"include_terminal,omitempty"` + PageSize uint32 `protobuf:"varint,3,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"` + PageToken string `protobuf:"bytes,4,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ListCommandsRequest) Reset() { + *x = ListCommandsRequest{} + mi := &file_rvbox_v1_control_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ListCommandsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListCommandsRequest) ProtoMessage() {} + +func (x *ListCommandsRequest) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_control_proto_msgTypes[5] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ListCommandsRequest.ProtoReflect.Descriptor instead. +func (*ListCommandsRequest) Descriptor() ([]byte, []int) { + return file_rvbox_v1_control_proto_rawDescGZIP(), []int{5} +} + +func (x *ListCommandsRequest) GetClientId() string { + if x != nil { + return x.ClientId + } + return "" +} + +func (x *ListCommandsRequest) GetIncludeTerminal() bool { + if x != nil { + return x.IncludeTerminal + } + return false +} + +func (x *ListCommandsRequest) GetPageSize() uint32 { + if x != nil { + return x.PageSize + } + return 0 +} + +func (x *ListCommandsRequest) GetPageToken() string { + if x != nil { + return x.PageToken + } + return "" +} + +type ListCommandsResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Commands []*CommandRecord `protobuf:"bytes,1,rep,name=commands,proto3" json:"commands,omitempty"` + NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ListCommandsResponse) Reset() { + *x = ListCommandsResponse{} + mi := &file_rvbox_v1_control_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ListCommandsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListCommandsResponse) ProtoMessage() {} + +func (x *ListCommandsResponse) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_control_proto_msgTypes[6] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ListCommandsResponse.ProtoReflect.Descriptor instead. +func (*ListCommandsResponse) Descriptor() ([]byte, []int) { + return file_rvbox_v1_control_proto_rawDescGZIP(), []int{6} +} + +func (x *ListCommandsResponse) GetCommands() []*CommandRecord { + if x != nil { + return x.Commands + } + return nil +} + +func (x *ListCommandsResponse) GetNextPageToken() string { + if x != nil { + return x.NextPageToken + } + return "" +} + +type GetCommandRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + ClientId string `protobuf:"bytes,1,opt,name=client_id,json=clientId,proto3" json:"client_id,omitempty"` + IssueUuid string `protobuf:"bytes,2,opt,name=issue_uuid,json=issueUuid,proto3" json:"issue_uuid,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *GetCommandRequest) Reset() { + *x = GetCommandRequest{} + mi := &file_rvbox_v1_control_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GetCommandRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetCommandRequest) ProtoMessage() {} + +func (x *GetCommandRequest) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_control_proto_msgTypes[7] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetCommandRequest.ProtoReflect.Descriptor instead. +func (*GetCommandRequest) Descriptor() ([]byte, []int) { + return file_rvbox_v1_control_proto_rawDescGZIP(), []int{7} +} + +func (x *GetCommandRequest) GetClientId() string { + if x != nil { + return x.ClientId + } + return "" +} + +func (x *GetCommandRequest) GetIssueUuid() string { + if x != nil { + return x.IssueUuid + } + return "" +} + +type GetCommandResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Command *CommandRecord `protobuf:"bytes,1,opt,name=command,proto3" json:"command,omitempty"` + LatestResource *ResourceSnapshot `protobuf:"bytes,2,opt,name=latest_resource,json=latestResource,proto3" json:"latest_resource,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *GetCommandResponse) Reset() { + *x = GetCommandResponse{} + mi := &file_rvbox_v1_control_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GetCommandResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetCommandResponse) ProtoMessage() {} + +func (x *GetCommandResponse) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_control_proto_msgTypes[8] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetCommandResponse.ProtoReflect.Descriptor instead. +func (*GetCommandResponse) Descriptor() ([]byte, []int) { + return file_rvbox_v1_control_proto_rawDescGZIP(), []int{8} +} + +func (x *GetCommandResponse) GetCommand() *CommandRecord { + if x != nil { + return x.Command + } + return nil +} + +func (x *GetCommandResponse) GetLatestResource() *ResourceSnapshot { + if x != nil { + return x.LatestResource + } + return nil +} + +// For script execution, script_content contains the bytes whose descriptor is +// placed in spec.script. The server chunks it for the Agent protocol. +type RunCommandRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + TargetClientId string `protobuf:"bytes,1,opt,name=target_client_id,json=targetClientId,proto3" json:"target_client_id,omitempty"` + Spec *ExecutionSpec `protobuf:"bytes,2,opt,name=spec,proto3" json:"spec,omitempty"` + ScriptContent []byte `protobuf:"bytes,3,opt,name=script_content,json=scriptContent,proto3" json:"script_content,omitempty"` + // Becomes issue_uuid when supplied; generated by the server when omitted. + RequestId string `protobuf:"bytes,4,opt,name=request_id,json=requestId,proto3" json:"request_id,omitempty"` + // Omitted uses the server default; zero explicitly requests no expiry. + QueueTtl *durationpb.Duration `protobuf:"bytes,5,opt,name=queue_ttl,json=queueTtl,proto3" json:"queue_ttl,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *RunCommandRequest) Reset() { + *x = RunCommandRequest{} + mi := &file_rvbox_v1_control_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RunCommandRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RunCommandRequest) ProtoMessage() {} + +func (x *RunCommandRequest) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_control_proto_msgTypes[9] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RunCommandRequest.ProtoReflect.Descriptor instead. +func (*RunCommandRequest) Descriptor() ([]byte, []int) { + return file_rvbox_v1_control_proto_rawDescGZIP(), []int{9} +} + +func (x *RunCommandRequest) GetTargetClientId() string { + if x != nil { + return x.TargetClientId + } + return "" +} + +func (x *RunCommandRequest) GetSpec() *ExecutionSpec { + if x != nil { + return x.Spec + } + return nil +} + +func (x *RunCommandRequest) GetScriptContent() []byte { + if x != nil { + return x.ScriptContent + } + return nil +} + +func (x *RunCommandRequest) GetRequestId() string { + if x != nil { + return x.RequestId + } + return "" +} + +func (x *RunCommandRequest) GetQueueTtl() *durationpb.Duration { + if x != nil { + return x.QueueTtl + } + return nil +} + +type RunCommandResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + IssueUuid string `protobuf:"bytes,1,opt,name=issue_uuid,json=issueUuid,proto3" json:"issue_uuid,omitempty"` + Lifecycle CommandLifecycle `protobuf:"varint,2,opt,name=lifecycle,proto3,enum=rvbox.v1.CommandLifecycle" json:"lifecycle,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *RunCommandResponse) Reset() { + *x = RunCommandResponse{} + mi := &file_rvbox_v1_control_proto_msgTypes[10] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RunCommandResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RunCommandResponse) ProtoMessage() {} + +func (x *RunCommandResponse) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_control_proto_msgTypes[10] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RunCommandResponse.ProtoReflect.Descriptor instead. +func (*RunCommandResponse) Descriptor() ([]byte, []int) { + return file_rvbox_v1_control_proto_rawDescGZIP(), []int{10} +} + +func (x *RunCommandResponse) GetIssueUuid() string { + if x != nil { + return x.IssueUuid + } + return "" +} + +func (x *RunCommandResponse) GetLifecycle() CommandLifecycle { + if x != nil { + return x.Lifecycle + } + return CommandLifecycle_COMMAND_LIFECYCLE_UNSPECIFIED +} + +type FollowCommandRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + ClientId string `protobuf:"bytes,1,opt,name=client_id,json=clientId,proto3" json:"client_id,omitempty"` + IssueUuid string `protobuf:"bytes,2,opt,name=issue_uuid,json=issueUuid,proto3" json:"issue_uuid,omitempty"` + AfterEventSeq uint64 `protobuf:"varint,3,opt,name=after_event_seq,json=afterEventSeq,proto3" json:"after_event_seq,omitempty"` + IncludeExisting bool `protobuf:"varint,4,opt,name=include_existing,json=includeExisting,proto3" json:"include_existing,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *FollowCommandRequest) Reset() { + *x = FollowCommandRequest{} + mi := &file_rvbox_v1_control_proto_msgTypes[11] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *FollowCommandRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*FollowCommandRequest) ProtoMessage() {} + +func (x *FollowCommandRequest) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_control_proto_msgTypes[11] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use FollowCommandRequest.ProtoReflect.Descriptor instead. +func (*FollowCommandRequest) Descriptor() ([]byte, []int) { + return file_rvbox_v1_control_proto_rawDescGZIP(), []int{11} +} + +func (x *FollowCommandRequest) GetClientId() string { + if x != nil { + return x.ClientId + } + return "" +} + +func (x *FollowCommandRequest) GetIssueUuid() string { + if x != nil { + return x.IssueUuid + } + return "" +} + +func (x *FollowCommandRequest) GetAfterEventSeq() uint64 { + if x != nil { + return x.AfterEventSeq + } + return 0 +} + +func (x *FollowCommandRequest) GetIncludeExisting() bool { + if x != nil { + return x.IncludeExisting + } + return false +} + +type FollowCommandResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Types that are valid to be assigned to Item: + // + // *FollowCommandResponse_Event + // *FollowCommandResponse_RetentionTruncation + Item isFollowCommandResponse_Item `protobuf_oneof:"item"` + // Set for a client event; server-created retention uses its own recorded_at. + ServerReceiptTime *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=server_receipt_time,json=serverReceiptTime,proto3" json:"server_receipt_time,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *FollowCommandResponse) Reset() { + *x = FollowCommandResponse{} + mi := &file_rvbox_v1_control_proto_msgTypes[12] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *FollowCommandResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*FollowCommandResponse) ProtoMessage() {} + +func (x *FollowCommandResponse) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_control_proto_msgTypes[12] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use FollowCommandResponse.ProtoReflect.Descriptor instead. +func (*FollowCommandResponse) Descriptor() ([]byte, []int) { + return file_rvbox_v1_control_proto_rawDescGZIP(), []int{12} +} + +func (x *FollowCommandResponse) GetItem() isFollowCommandResponse_Item { + if x != nil { + return x.Item + } + return nil +} + +func (x *FollowCommandResponse) GetEvent() *CommandEvent { + if x != nil { + if x, ok := x.Item.(*FollowCommandResponse_Event); ok { + return x.Event + } + } + return nil +} + +func (x *FollowCommandResponse) GetRetentionTruncation() *RetentionTruncation { + if x != nil { + if x, ok := x.Item.(*FollowCommandResponse_RetentionTruncation); ok { + return x.RetentionTruncation + } + } + return nil +} + +func (x *FollowCommandResponse) GetServerReceiptTime() *timestamppb.Timestamp { + if x != nil { + return x.ServerReceiptTime + } + return nil +} + +type isFollowCommandResponse_Item interface { + isFollowCommandResponse_Item() +} + +type FollowCommandResponse_Event struct { + Event *CommandEvent `protobuf:"bytes,1,opt,name=event,proto3,oneof"` +} + +type FollowCommandResponse_RetentionTruncation struct { + // Server retention metadata; does not advance the client event cursor. + RetentionTruncation *RetentionTruncation `protobuf:"bytes,2,opt,name=retention_truncation,json=retentionTruncation,proto3,oneof"` +} + +func (*FollowCommandResponse_Event) isFollowCommandResponse_Item() {} + +func (*FollowCommandResponse_RetentionTruncation) isFollowCommandResponse_Item() {} + +type AppendStdinRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + ClientId string `protobuf:"bytes,1,opt,name=client_id,json=clientId,proto3" json:"client_id,omitempty"` + IssueUuid string `protobuf:"bytes,2,opt,name=issue_uuid,json=issueUuid,proto3" json:"issue_uuid,omitempty"` + Data []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"` + AppendNewline bool `protobuf:"varint,4,opt,name=append_newline,json=appendNewline,proto3" json:"append_newline,omitempty"` + RequestId string `protobuf:"bytes,5,opt,name=request_id,json=requestId,proto3" json:"request_id,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *AppendStdinRequest) Reset() { + *x = AppendStdinRequest{} + mi := &file_rvbox_v1_control_proto_msgTypes[13] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *AppendStdinRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AppendStdinRequest) ProtoMessage() {} + +func (x *AppendStdinRequest) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_control_proto_msgTypes[13] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use AppendStdinRequest.ProtoReflect.Descriptor instead. +func (*AppendStdinRequest) Descriptor() ([]byte, []int) { + return file_rvbox_v1_control_proto_rawDescGZIP(), []int{13} +} + +func (x *AppendStdinRequest) GetClientId() string { + if x != nil { + return x.ClientId + } + return "" +} + +func (x *AppendStdinRequest) GetIssueUuid() string { + if x != nil { + return x.IssueUuid + } + return "" +} + +func (x *AppendStdinRequest) GetData() []byte { + if x != nil { + return x.Data + } + return nil +} + +func (x *AppendStdinRequest) GetAppendNewline() bool { + if x != nil { + return x.AppendNewline + } + return false +} + +func (x *AppendStdinRequest) GetRequestId() string { + if x != nil { + return x.RequestId + } + return "" +} + +type AppendStdinResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + WriteSeq uint64 `protobuf:"varint,1,opt,name=write_seq,json=writeSeq,proto3" json:"write_seq,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *AppendStdinResponse) Reset() { + *x = AppendStdinResponse{} + mi := &file_rvbox_v1_control_proto_msgTypes[14] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *AppendStdinResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AppendStdinResponse) ProtoMessage() {} + +func (x *AppendStdinResponse) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_control_proto_msgTypes[14] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use AppendStdinResponse.ProtoReflect.Descriptor instead. +func (*AppendStdinResponse) Descriptor() ([]byte, []int) { + return file_rvbox_v1_control_proto_rawDescGZIP(), []int{14} +} + +func (x *AppendStdinResponse) GetWriteSeq() uint64 { + if x != nil { + return x.WriteSeq + } + return 0 +} + +type CloseStdinRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + ClientId string `protobuf:"bytes,1,opt,name=client_id,json=clientId,proto3" json:"client_id,omitempty"` + IssueUuid string `protobuf:"bytes,2,opt,name=issue_uuid,json=issueUuid,proto3" json:"issue_uuid,omitempty"` + RequestId string `protobuf:"bytes,3,opt,name=request_id,json=requestId,proto3" json:"request_id,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *CloseStdinRequest) Reset() { + *x = CloseStdinRequest{} + mi := &file_rvbox_v1_control_proto_msgTypes[15] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *CloseStdinRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CloseStdinRequest) ProtoMessage() {} + +func (x *CloseStdinRequest) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_control_proto_msgTypes[15] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CloseStdinRequest.ProtoReflect.Descriptor instead. +func (*CloseStdinRequest) Descriptor() ([]byte, []int) { + return file_rvbox_v1_control_proto_rawDescGZIP(), []int{15} +} + +func (x *CloseStdinRequest) GetClientId() string { + if x != nil { + return x.ClientId + } + return "" +} + +func (x *CloseStdinRequest) GetIssueUuid() string { + if x != nil { + return x.IssueUuid + } + return "" +} + +func (x *CloseStdinRequest) GetRequestId() string { + if x != nil { + return x.RequestId + } + return "" +} + +type CloseStdinResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + WriteSeq uint64 `protobuf:"varint,1,opt,name=write_seq,json=writeSeq,proto3" json:"write_seq,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *CloseStdinResponse) Reset() { + *x = CloseStdinResponse{} + mi := &file_rvbox_v1_control_proto_msgTypes[16] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *CloseStdinResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CloseStdinResponse) ProtoMessage() {} + +func (x *CloseStdinResponse) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_control_proto_msgTypes[16] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CloseStdinResponse.ProtoReflect.Descriptor instead. +func (*CloseStdinResponse) Descriptor() ([]byte, []int) { + return file_rvbox_v1_control_proto_rawDescGZIP(), []int{16} +} + +func (x *CloseStdinResponse) GetWriteSeq() uint64 { + if x != nil { + return x.WriteSeq + } + return 0 +} + +type ControlSignalCommandRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + ClientId string `protobuf:"bytes,1,opt,name=client_id,json=clientId,proto3" json:"client_id,omitempty"` + IssueUuid string `protobuf:"bytes,2,opt,name=issue_uuid,json=issueUuid,proto3" json:"issue_uuid,omitempty"` + Signal SignalKind `protobuf:"varint,3,opt,name=signal,proto3,enum=rvbox.v1.SignalKind" json:"signal,omitempty"` + RequestId string `protobuf:"bytes,4,opt,name=request_id,json=requestId,proto3" json:"request_id,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ControlSignalCommandRequest) Reset() { + *x = ControlSignalCommandRequest{} + mi := &file_rvbox_v1_control_proto_msgTypes[17] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ControlSignalCommandRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ControlSignalCommandRequest) ProtoMessage() {} + +func (x *ControlSignalCommandRequest) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_control_proto_msgTypes[17] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ControlSignalCommandRequest.ProtoReflect.Descriptor instead. +func (*ControlSignalCommandRequest) Descriptor() ([]byte, []int) { + return file_rvbox_v1_control_proto_rawDescGZIP(), []int{17} +} + +func (x *ControlSignalCommandRequest) GetClientId() string { + if x != nil { + return x.ClientId + } + return "" +} + +func (x *ControlSignalCommandRequest) GetIssueUuid() string { + if x != nil { + return x.IssueUuid + } + return "" +} + +func (x *ControlSignalCommandRequest) GetSignal() SignalKind { + if x != nil { + return x.Signal + } + return SignalKind_SIGNAL_KIND_UNSPECIFIED +} + +func (x *ControlSignalCommandRequest) GetRequestId() string { + if x != nil { + return x.RequestId + } + return "" +} + +type ControlSignalCommandResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + CommandRevision uint64 `protobuf:"varint,1,opt,name=command_revision,json=commandRevision,proto3" json:"command_revision,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ControlSignalCommandResponse) Reset() { + *x = ControlSignalCommandResponse{} + mi := &file_rvbox_v1_control_proto_msgTypes[18] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ControlSignalCommandResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ControlSignalCommandResponse) ProtoMessage() {} + +func (x *ControlSignalCommandResponse) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_control_proto_msgTypes[18] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ControlSignalCommandResponse.ProtoReflect.Descriptor instead. +func (*ControlSignalCommandResponse) Descriptor() ([]byte, []int) { + return file_rvbox_v1_control_proto_rawDescGZIP(), []int{18} +} + +func (x *ControlSignalCommandResponse) GetCommandRevision() uint64 { + if x != nil { + return x.CommandRevision + } + return 0 +} + +type GetOutputRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + ClientId string `protobuf:"bytes,1,opt,name=client_id,json=clientId,proto3" json:"client_id,omitempty"` + IssueUuid string `protobuf:"bytes,2,opt,name=issue_uuid,json=issueUuid,proto3" json:"issue_uuid,omitempty"` + Streams []StreamKind `protobuf:"varint,3,rep,packed,name=streams,proto3,enum=rvbox.v1.StreamKind" json:"streams,omitempty"` + AfterEventSeq uint64 `protobuf:"varint,4,opt,name=after_event_seq,json=afterEventSeq,proto3" json:"after_event_seq,omitempty"` + MaxBytes uint64 `protobuf:"varint,5,opt,name=max_bytes,json=maxBytes,proto3" json:"max_bytes,omitempty"` + PageToken string `protobuf:"bytes,6,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *GetOutputRequest) Reset() { + *x = GetOutputRequest{} + mi := &file_rvbox_v1_control_proto_msgTypes[19] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GetOutputRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetOutputRequest) ProtoMessage() {} + +func (x *GetOutputRequest) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_control_proto_msgTypes[19] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetOutputRequest.ProtoReflect.Descriptor instead. +func (*GetOutputRequest) Descriptor() ([]byte, []int) { + return file_rvbox_v1_control_proto_rawDescGZIP(), []int{19} +} + +func (x *GetOutputRequest) GetClientId() string { + if x != nil { + return x.ClientId + } + return "" +} + +func (x *GetOutputRequest) GetIssueUuid() string { + if x != nil { + return x.IssueUuid + } + return "" +} + +func (x *GetOutputRequest) GetStreams() []StreamKind { + if x != nil { + return x.Streams + } + return nil +} + +func (x *GetOutputRequest) GetAfterEventSeq() uint64 { + if x != nil { + return x.AfterEventSeq + } + return 0 +} + +func (x *GetOutputRequest) GetMaxBytes() uint64 { + if x != nil { + return x.MaxBytes + } + return 0 +} + +func (x *GetOutputRequest) GetPageToken() string { + if x != nil { + return x.PageToken + } + return "" +} + +// An uncompressed slice of one persisted output event. Opaque pagination may +// resume within an event; event_byte_offset identifies that position. +type OutputSlice struct { + state protoimpl.MessageState `protogen:"open.v1"` + EventSeq uint64 `protobuf:"varint,1,opt,name=event_seq,json=eventSeq,proto3" json:"event_seq,omitempty"` + ObservedAt *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=observed_at,json=observedAt,proto3" json:"observed_at,omitempty"` + Stream StreamKind `protobuf:"varint,3,opt,name=stream,proto3,enum=rvbox.v1.StreamKind" json:"stream,omitempty"` + Data []byte `protobuf:"bytes,4,opt,name=data,proto3" json:"data,omitempty"` + EventByteOffset uint64 `protobuf:"varint,5,opt,name=event_byte_offset,json=eventByteOffset,proto3" json:"event_byte_offset,omitempty"` + EndOfEvent bool `protobuf:"varint,6,opt,name=end_of_event,json=endOfEvent,proto3" json:"end_of_event,omitempty"` + ServerReceiptTime *timestamppb.Timestamp `protobuf:"bytes,7,opt,name=server_receipt_time,json=serverReceiptTime,proto3" json:"server_receipt_time,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *OutputSlice) Reset() { + *x = OutputSlice{} + mi := &file_rvbox_v1_control_proto_msgTypes[20] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *OutputSlice) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*OutputSlice) ProtoMessage() {} + +func (x *OutputSlice) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_control_proto_msgTypes[20] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use OutputSlice.ProtoReflect.Descriptor instead. +func (*OutputSlice) Descriptor() ([]byte, []int) { + return file_rvbox_v1_control_proto_rawDescGZIP(), []int{20} +} + +func (x *OutputSlice) GetEventSeq() uint64 { + if x != nil { + return x.EventSeq + } + return 0 +} + +func (x *OutputSlice) GetObservedAt() *timestamppb.Timestamp { + if x != nil { + return x.ObservedAt + } + return nil +} + +func (x *OutputSlice) GetStream() StreamKind { + if x != nil { + return x.Stream + } + return StreamKind_STREAM_KIND_UNSPECIFIED +} + +func (x *OutputSlice) GetData() []byte { + if x != nil { + return x.Data + } + return nil +} + +func (x *OutputSlice) GetEventByteOffset() uint64 { + if x != nil { + return x.EventByteOffset + } + return 0 +} + +func (x *OutputSlice) GetEndOfEvent() bool { + if x != nil { + return x.EndOfEvent + } + return false +} + +func (x *OutputSlice) GetServerReceiptTime() *timestamppb.Timestamp { + if x != nil { + return x.ServerReceiptTime + } + return nil +} + +type RetentionTruncation struct { + state protoimpl.MessageState `protogen:"open.v1"` + Truncation *OutputTruncation `protobuf:"bytes,1,opt,name=truncation,proto3" json:"truncation,omitempty"` + ServerRecordedAt *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=server_recorded_at,json=serverRecordedAt,proto3" json:"server_recorded_at,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *RetentionTruncation) Reset() { + *x = RetentionTruncation{} + mi := &file_rvbox_v1_control_proto_msgTypes[21] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RetentionTruncation) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RetentionTruncation) ProtoMessage() {} + +func (x *RetentionTruncation) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_control_proto_msgTypes[21] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RetentionTruncation.ProtoReflect.Descriptor instead. +func (*RetentionTruncation) Descriptor() ([]byte, []int) { + return file_rvbox_v1_control_proto_rawDescGZIP(), []int{21} +} + +func (x *RetentionTruncation) GetTruncation() *OutputTruncation { + if x != nil { + return x.Truncation + } + return nil +} + +func (x *RetentionTruncation) GetServerRecordedAt() *timestamppb.Timestamp { + if x != nil { + return x.ServerRecordedAt + } + return nil +} + +type GetOutputResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Output []*OutputSlice `protobuf:"bytes,1,rep,name=output,proto3" json:"output,omitempty"` + NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"` + OutputTruncated bool `protobuf:"varint,3,opt,name=output_truncated,json=outputTruncated,proto3" json:"output_truncated,omitempty"` + Truncations []*RetentionTruncation `protobuf:"bytes,4,rep,name=truncations,proto3" json:"truncations,omitempty"` + Incomplete *OutputIncomplete `protobuf:"bytes,5,opt,name=incomplete,proto3" json:"incomplete,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *GetOutputResponse) Reset() { + *x = GetOutputResponse{} + mi := &file_rvbox_v1_control_proto_msgTypes[22] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GetOutputResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetOutputResponse) ProtoMessage() {} + +func (x *GetOutputResponse) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_control_proto_msgTypes[22] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetOutputResponse.ProtoReflect.Descriptor instead. +func (*GetOutputResponse) Descriptor() ([]byte, []int) { + return file_rvbox_v1_control_proto_rawDescGZIP(), []int{22} +} + +func (x *GetOutputResponse) GetOutput() []*OutputSlice { + if x != nil { + return x.Output + } + return nil +} + +func (x *GetOutputResponse) GetNextPageToken() string { + if x != nil { + return x.NextPageToken + } + return "" +} + +func (x *GetOutputResponse) GetOutputTruncated() bool { + if x != nil { + return x.OutputTruncated + } + return false +} + +func (x *GetOutputResponse) GetTruncations() []*RetentionTruncation { + if x != nil { + return x.Truncations + } + return nil +} + +func (x *GetOutputResponse) GetIncomplete() *OutputIncomplete { + if x != nil { + return x.Incomplete + } + return nil +} + +type StorageIncident struct { + state protoimpl.MessageState `protogen:"open.v1"` + IncidentId string `protobuf:"bytes,1,opt,name=incident_id,json=incidentId,proto3" json:"incident_id,omitempty"` + DetectedAt *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=detected_at,json=detectedAt,proto3" json:"detected_at,omitempty"` + ResolvedAt *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=resolved_at,json=resolvedAt,proto3" json:"resolved_at,omitempty"` + State StorageIncidentState `protobuf:"varint,4,opt,name=state,proto3,enum=rvbox.v1.StorageIncidentState" json:"state,omitempty"` + Scope string `protobuf:"bytes,5,opt,name=scope,proto3" json:"scope,omitempty"` + ClientId string `protobuf:"bytes,6,opt,name=client_id,json=clientId,proto3" json:"client_id,omitempty"` + IssueUuid string `protobuf:"bytes,7,opt,name=issue_uuid,json=issueUuid,proto3" json:"issue_uuid,omitempty"` + Summary string `protobuf:"bytes,8,opt,name=summary,proto3" json:"summary,omitempty"` + DataLoss bool `protobuf:"varint,9,opt,name=data_loss,json=dataLoss,proto3" json:"data_loss,omitempty"` + AutomaticallyRepairable bool `protobuf:"varint,10,opt,name=automatically_repairable,json=automaticallyRepairable,proto3" json:"automatically_repairable,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *StorageIncident) Reset() { + *x = StorageIncident{} + mi := &file_rvbox_v1_control_proto_msgTypes[23] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *StorageIncident) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*StorageIncident) ProtoMessage() {} + +func (x *StorageIncident) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_control_proto_msgTypes[23] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use StorageIncident.ProtoReflect.Descriptor instead. +func (*StorageIncident) Descriptor() ([]byte, []int) { + return file_rvbox_v1_control_proto_rawDescGZIP(), []int{23} +} + +func (x *StorageIncident) GetIncidentId() string { + if x != nil { + return x.IncidentId + } + return "" +} + +func (x *StorageIncident) GetDetectedAt() *timestamppb.Timestamp { + if x != nil { + return x.DetectedAt + } + return nil +} + +func (x *StorageIncident) GetResolvedAt() *timestamppb.Timestamp { + if x != nil { + return x.ResolvedAt + } + return nil +} + +func (x *StorageIncident) GetState() StorageIncidentState { + if x != nil { + return x.State + } + return StorageIncidentState_STORAGE_INCIDENT_STATE_UNSPECIFIED +} + +func (x *StorageIncident) GetScope() string { + if x != nil { + return x.Scope + } + return "" +} + +func (x *StorageIncident) GetClientId() string { + if x != nil { + return x.ClientId + } + return "" +} + +func (x *StorageIncident) GetIssueUuid() string { + if x != nil { + return x.IssueUuid + } + return "" +} + +func (x *StorageIncident) GetSummary() string { + if x != nil { + return x.Summary + } + return "" +} + +func (x *StorageIncident) GetDataLoss() bool { + if x != nil { + return x.DataLoss + } + return false +} + +func (x *StorageIncident) GetAutomaticallyRepairable() bool { + if x != nil { + return x.AutomaticallyRepairable + } + return false +} + +type ListStorageIncidentsRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + IncludeResolved bool `protobuf:"varint,1,opt,name=include_resolved,json=includeResolved,proto3" json:"include_resolved,omitempty"` + PageSize uint32 `protobuf:"varint,2,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"` + PageToken string `protobuf:"bytes,3,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ListStorageIncidentsRequest) Reset() { + *x = ListStorageIncidentsRequest{} + mi := &file_rvbox_v1_control_proto_msgTypes[24] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ListStorageIncidentsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListStorageIncidentsRequest) ProtoMessage() {} + +func (x *ListStorageIncidentsRequest) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_control_proto_msgTypes[24] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ListStorageIncidentsRequest.ProtoReflect.Descriptor instead. +func (*ListStorageIncidentsRequest) Descriptor() ([]byte, []int) { + return file_rvbox_v1_control_proto_rawDescGZIP(), []int{24} +} + +func (x *ListStorageIncidentsRequest) GetIncludeResolved() bool { + if x != nil { + return x.IncludeResolved + } + return false +} + +func (x *ListStorageIncidentsRequest) GetPageSize() uint32 { + if x != nil { + return x.PageSize + } + return 0 +} + +func (x *ListStorageIncidentsRequest) GetPageToken() string { + if x != nil { + return x.PageToken + } + return "" +} + +type ListStorageIncidentsResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Incidents []*StorageIncident `protobuf:"bytes,1,rep,name=incidents,proto3" json:"incidents,omitempty"` + NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ListStorageIncidentsResponse) Reset() { + *x = ListStorageIncidentsResponse{} + mi := &file_rvbox_v1_control_proto_msgTypes[25] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ListStorageIncidentsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListStorageIncidentsResponse) ProtoMessage() {} + +func (x *ListStorageIncidentsResponse) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_control_proto_msgTypes[25] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ListStorageIncidentsResponse.ProtoReflect.Descriptor instead. +func (*ListStorageIncidentsResponse) Descriptor() ([]byte, []int) { + return file_rvbox_v1_control_proto_rawDescGZIP(), []int{25} +} + +func (x *ListStorageIncidentsResponse) GetIncidents() []*StorageIncident { + if x != nil { + return x.Incidents + } + return nil +} + +func (x *ListStorageIncidentsResponse) GetNextPageToken() string { + if x != nil { + return x.NextPageToken + } + return "" +} + +type RepairStorageIncidentRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + IncidentId string `protobuf:"bytes,1,opt,name=incident_id,json=incidentId,proto3" json:"incident_id,omitempty"` + RequestId string `protobuf:"bytes,2,opt,name=request_id,json=requestId,proto3" json:"request_id,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *RepairStorageIncidentRequest) Reset() { + *x = RepairStorageIncidentRequest{} + mi := &file_rvbox_v1_control_proto_msgTypes[26] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RepairStorageIncidentRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RepairStorageIncidentRequest) ProtoMessage() {} + +func (x *RepairStorageIncidentRequest) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_control_proto_msgTypes[26] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RepairStorageIncidentRequest.ProtoReflect.Descriptor instead. +func (*RepairStorageIncidentRequest) Descriptor() ([]byte, []int) { + return file_rvbox_v1_control_proto_rawDescGZIP(), []int{26} +} + +func (x *RepairStorageIncidentRequest) GetIncidentId() string { + if x != nil { + return x.IncidentId + } + return "" +} + +func (x *RepairStorageIncidentRequest) GetRequestId() string { + if x != nil { + return x.RequestId + } + return "" +} + +type RepairStorageIncidentResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Incident *StorageIncident `protobuf:"bytes,1,opt,name=incident,proto3" json:"incident,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *RepairStorageIncidentResponse) Reset() { + *x = RepairStorageIncidentResponse{} + mi := &file_rvbox_v1_control_proto_msgTypes[27] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RepairStorageIncidentResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RepairStorageIncidentResponse) ProtoMessage() {} + +func (x *RepairStorageIncidentResponse) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_control_proto_msgTypes[27] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use RepairStorageIncidentResponse.ProtoReflect.Descriptor instead. +func (*RepairStorageIncidentResponse) Descriptor() ([]byte, []int) { + return file_rvbox_v1_control_proto_rawDescGZIP(), []int{27} +} + +func (x *RepairStorageIncidentResponse) GetIncident() *StorageIncident { + if x != nil { + return x.Incident + } + return nil +} + +type AcknowledgeStorageIncidentRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + IncidentId string `protobuf:"bytes,1,opt,name=incident_id,json=incidentId,proto3" json:"incident_id,omitempty"` + Note string `protobuf:"bytes,2,opt,name=note,proto3" json:"note,omitempty"` + RequestId string `protobuf:"bytes,3,opt,name=request_id,json=requestId,proto3" json:"request_id,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *AcknowledgeStorageIncidentRequest) Reset() { + *x = AcknowledgeStorageIncidentRequest{} + mi := &file_rvbox_v1_control_proto_msgTypes[28] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *AcknowledgeStorageIncidentRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AcknowledgeStorageIncidentRequest) ProtoMessage() {} + +func (x *AcknowledgeStorageIncidentRequest) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_control_proto_msgTypes[28] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use AcknowledgeStorageIncidentRequest.ProtoReflect.Descriptor instead. +func (*AcknowledgeStorageIncidentRequest) Descriptor() ([]byte, []int) { + return file_rvbox_v1_control_proto_rawDescGZIP(), []int{28} +} + +func (x *AcknowledgeStorageIncidentRequest) GetIncidentId() string { + if x != nil { + return x.IncidentId + } + return "" +} + +func (x *AcknowledgeStorageIncidentRequest) GetNote() string { + if x != nil { + return x.Note + } + return "" +} + +func (x *AcknowledgeStorageIncidentRequest) GetRequestId() string { + if x != nil { + return x.RequestId + } + return "" +} + +type AcknowledgeStorageIncidentResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Incident *StorageIncident `protobuf:"bytes,1,opt,name=incident,proto3" json:"incident,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *AcknowledgeStorageIncidentResponse) Reset() { + *x = AcknowledgeStorageIncidentResponse{} + mi := &file_rvbox_v1_control_proto_msgTypes[29] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *AcknowledgeStorageIncidentResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AcknowledgeStorageIncidentResponse) ProtoMessage() {} + +func (x *AcknowledgeStorageIncidentResponse) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_control_proto_msgTypes[29] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use AcknowledgeStorageIncidentResponse.ProtoReflect.Descriptor instead. +func (*AcknowledgeStorageIncidentResponse) Descriptor() ([]byte, []int) { + return file_rvbox_v1_control_proto_rawDescGZIP(), []int{29} +} + +func (x *AcknowledgeStorageIncidentResponse) GetIncident() *StorageIncident { + if x != nil { + return x.Incident + } + return nil +} + +type AuthorizeClientTakeoverRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + ClientId string `protobuf:"bytes,1,opt,name=client_id,json=clientId,proto3" json:"client_id,omitempty"` + ClientInstanceId string `protobuf:"bytes,2,opt,name=client_instance_id,json=clientInstanceId,proto3" json:"client_instance_id,omitempty"` + RequestId string `protobuf:"bytes,3,opt,name=request_id,json=requestId,proto3" json:"request_id,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *AuthorizeClientTakeoverRequest) Reset() { + *x = AuthorizeClientTakeoverRequest{} + mi := &file_rvbox_v1_control_proto_msgTypes[30] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *AuthorizeClientTakeoverRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AuthorizeClientTakeoverRequest) ProtoMessage() {} + +func (x *AuthorizeClientTakeoverRequest) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_control_proto_msgTypes[30] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use AuthorizeClientTakeoverRequest.ProtoReflect.Descriptor instead. +func (*AuthorizeClientTakeoverRequest) Descriptor() ([]byte, []int) { + return file_rvbox_v1_control_proto_rawDescGZIP(), []int{30} +} + +func (x *AuthorizeClientTakeoverRequest) GetClientId() string { + if x != nil { + return x.ClientId + } + return "" +} + +func (x *AuthorizeClientTakeoverRequest) GetClientInstanceId() string { + if x != nil { + return x.ClientInstanceId + } + return "" +} + +func (x *AuthorizeClientTakeoverRequest) GetRequestId() string { + if x != nil { + return x.RequestId + } + return "" +} + +type AuthorizeClientTakeoverResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + ExpiresAt *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=expires_at,json=expiresAt,proto3" json:"expires_at,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *AuthorizeClientTakeoverResponse) Reset() { + *x = AuthorizeClientTakeoverResponse{} + mi := &file_rvbox_v1_control_proto_msgTypes[31] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *AuthorizeClientTakeoverResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AuthorizeClientTakeoverResponse) ProtoMessage() {} + +func (x *AuthorizeClientTakeoverResponse) ProtoReflect() protoreflect.Message { + mi := &file_rvbox_v1_control_proto_msgTypes[31] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use AuthorizeClientTakeoverResponse.ProtoReflect.Descriptor instead. +func (*AuthorizeClientTakeoverResponse) Descriptor() ([]byte, []int) { + return file_rvbox_v1_control_proto_rawDescGZIP(), []int{31} +} + +func (x *AuthorizeClientTakeoverResponse) GetExpiresAt() *timestamppb.Timestamp { + if x != nil { + return x.ExpiresAt + } + return nil +} + +var File_rvbox_v1_control_proto protoreflect.FileDescriptor + +const file_rvbox_v1_control_proto_rawDesc = "" + + "\n" + + "\x16rvbox/v1/control.proto\x12\brvbox.v1\x1a\x1egoogle/protobuf/duration.proto\x1a\x1fgoogle/protobuf/timestamp.proto\x1a\x15rvbox/v1/common.proto\"\xa8\x05\n" + + "\rClientSummary\x12\x1b\n" + + "\tclient_id\x18\x01 \x01(\tR\bclientId\x12\x1c\n" + + "\tconnected\x18\x02 \x01(\bR\tconnected\x12=\n" + + "\fconnected_at\x18\x03 \x01(\v2\x1a.google.protobuf.TimestampR\vconnectedAt\x12<\n" + + "\flast_seen_at\x18\x04 \x01(\v2\x1a.google.protobuf.TimestampR\n" + + "lastSeenAt\x12)\n" + + "\x10running_commands\x18\x05 \x01(\rR\x0frunningCommands\x12'\n" + + "\x0fqueued_commands\x18\x06 \x01(\rR\x0equeuedCommands\x12.\n" + + "\bplatform\x18\a \x01(\x0e2\x12.rvbox.v1.PlatformR\bplatform\x12\"\n" + + "\farchitecture\x18\b \x01(\tR\farchitecture\x12%\n" + + "\x0edaemon_version\x18\t \x01(\tR\rdaemonVersion\x12\x1d\n" + + "\n" + + "daemon_cwd\x18\n" + + " \x01(\tR\tdaemonCwd\x12>\n" + + "\x10supported_shells\x18\v \x03(\x0e2\x13.rvbox.v1.ShellTypeR\x0fsupportedShells\x12,\n" + + "\x12client_instance_id\x18\f \x01(\tR\x10clientInstanceId\x12.\n" + + "\x13pending_instance_id\x18\r \x01(\tR\x11pendingInstanceId\x12S\n" + + "\x18pending_instance_seen_at\x18\x0e \x01(\v2\x1a.google.protobuf.TimestampR\x15pendingInstanceSeenAt\"P\n" + + "\x12ListClientsRequest\x12\x1b\n" + + "\tpage_size\x18\x01 \x01(\rR\bpageSize\x12\x1d\n" + + "\n" + + "page_token\x18\x02 \x01(\tR\tpageToken\"p\n" + + "\x13ListClientsResponse\x121\n" + + "\aclients\x18\x01 \x03(\v2\x17.rvbox.v1.ClientSummaryR\aclients\x12&\n" + + "\x0fnext_page_token\x18\x02 \x01(\tR\rnextPageToken\"/\n" + + "\x10GetClientRequest\x12\x1b\n" + + "\tclient_id\x18\x01 \x01(\tR\bclientId\"D\n" + + "\x11GetClientResponse\x12/\n" + + "\x06client\x18\x01 \x01(\v2\x17.rvbox.v1.ClientSummaryR\x06client\"\x99\x01\n" + + "\x13ListCommandsRequest\x12\x1b\n" + + "\tclient_id\x18\x01 \x01(\tR\bclientId\x12)\n" + + "\x10include_terminal\x18\x02 \x01(\bR\x0fincludeTerminal\x12\x1b\n" + + "\tpage_size\x18\x03 \x01(\rR\bpageSize\x12\x1d\n" + + "\n" + + "page_token\x18\x04 \x01(\tR\tpageToken\"s\n" + + "\x14ListCommandsResponse\x123\n" + + "\bcommands\x18\x01 \x03(\v2\x17.rvbox.v1.CommandRecordR\bcommands\x12&\n" + + "\x0fnext_page_token\x18\x02 \x01(\tR\rnextPageToken\"O\n" + + "\x11GetCommandRequest\x12\x1b\n" + + "\tclient_id\x18\x01 \x01(\tR\bclientId\x12\x1d\n" + + "\n" + + "issue_uuid\x18\x02 \x01(\tR\tissueUuid\"\x8c\x01\n" + + "\x12GetCommandResponse\x121\n" + + "\acommand\x18\x01 \x01(\v2\x17.rvbox.v1.CommandRecordR\acommand\x12C\n" + + "\x0flatest_resource\x18\x02 \x01(\v2\x1a.rvbox.v1.ResourceSnapshotR\x0elatestResource\"\xe8\x01\n" + + "\x11RunCommandRequest\x12(\n" + + "\x10target_client_id\x18\x01 \x01(\tR\x0etargetClientId\x12+\n" + + "\x04spec\x18\x02 \x01(\v2\x17.rvbox.v1.ExecutionSpecR\x04spec\x12%\n" + + "\x0escript_content\x18\x03 \x01(\fR\rscriptContent\x12\x1d\n" + + "\n" + + "request_id\x18\x04 \x01(\tR\trequestId\x126\n" + + "\tqueue_ttl\x18\x05 \x01(\v2\x19.google.protobuf.DurationR\bqueueTtl\"m\n" + + "\x12RunCommandResponse\x12\x1d\n" + + "\n" + + "issue_uuid\x18\x01 \x01(\tR\tissueUuid\x128\n" + + "\tlifecycle\x18\x02 \x01(\x0e2\x1a.rvbox.v1.CommandLifecycleR\tlifecycle\"\xa5\x01\n" + + "\x14FollowCommandRequest\x12\x1b\n" + + "\tclient_id\x18\x01 \x01(\tR\bclientId\x12\x1d\n" + + "\n" + + "issue_uuid\x18\x02 \x01(\tR\tissueUuid\x12&\n" + + "\x0fafter_event_seq\x18\x03 \x01(\x04R\rafterEventSeq\x12)\n" + + "\x10include_existing\x18\x04 \x01(\bR\x0fincludeExisting\"\xef\x01\n" + + "\x15FollowCommandResponse\x12.\n" + + "\x05event\x18\x01 \x01(\v2\x16.rvbox.v1.CommandEventH\x00R\x05event\x12R\n" + + "\x14retention_truncation\x18\x02 \x01(\v2\x1d.rvbox.v1.RetentionTruncationH\x00R\x13retentionTruncation\x12J\n" + + "\x13server_receipt_time\x18\x03 \x01(\v2\x1a.google.protobuf.TimestampR\x11serverReceiptTimeB\x06\n" + + "\x04item\"\xaa\x01\n" + + "\x12AppendStdinRequest\x12\x1b\n" + + "\tclient_id\x18\x01 \x01(\tR\bclientId\x12\x1d\n" + + "\n" + + "issue_uuid\x18\x02 \x01(\tR\tissueUuid\x12\x12\n" + + "\x04data\x18\x03 \x01(\fR\x04data\x12%\n" + + "\x0eappend_newline\x18\x04 \x01(\bR\rappendNewline\x12\x1d\n" + + "\n" + + "request_id\x18\x05 \x01(\tR\trequestId\"2\n" + + "\x13AppendStdinResponse\x12\x1b\n" + + "\twrite_seq\x18\x01 \x01(\x04R\bwriteSeq\"n\n" + + "\x11CloseStdinRequest\x12\x1b\n" + + "\tclient_id\x18\x01 \x01(\tR\bclientId\x12\x1d\n" + + "\n" + + "issue_uuid\x18\x02 \x01(\tR\tissueUuid\x12\x1d\n" + + "\n" + + "request_id\x18\x03 \x01(\tR\trequestId\"1\n" + + "\x12CloseStdinResponse\x12\x1b\n" + + "\twrite_seq\x18\x01 \x01(\x04R\bwriteSeq\"\xa6\x01\n" + + "\x1bControlSignalCommandRequest\x12\x1b\n" + + "\tclient_id\x18\x01 \x01(\tR\bclientId\x12\x1d\n" + + "\n" + + "issue_uuid\x18\x02 \x01(\tR\tissueUuid\x12,\n" + + "\x06signal\x18\x03 \x01(\x0e2\x14.rvbox.v1.SignalKindR\x06signal\x12\x1d\n" + + "\n" + + "request_id\x18\x04 \x01(\tR\trequestId\"I\n" + + "\x1cControlSignalCommandResponse\x12)\n" + + "\x10command_revision\x18\x01 \x01(\x04R\x0fcommandRevision\"\xe2\x01\n" + + "\x10GetOutputRequest\x12\x1b\n" + + "\tclient_id\x18\x01 \x01(\tR\bclientId\x12\x1d\n" + + "\n" + + "issue_uuid\x18\x02 \x01(\tR\tissueUuid\x12.\n" + + "\astreams\x18\x03 \x03(\x0e2\x14.rvbox.v1.StreamKindR\astreams\x12&\n" + + "\x0fafter_event_seq\x18\x04 \x01(\x04R\rafterEventSeq\x12\x1b\n" + + "\tmax_bytes\x18\x05 \x01(\x04R\bmaxBytes\x12\x1d\n" + + "\n" + + "page_token\x18\x06 \x01(\tR\tpageToken\"\xc3\x02\n" + + "\vOutputSlice\x12\x1b\n" + + "\tevent_seq\x18\x01 \x01(\x04R\beventSeq\x12;\n" + + "\vobserved_at\x18\x02 \x01(\v2\x1a.google.protobuf.TimestampR\n" + + "observedAt\x12,\n" + + "\x06stream\x18\x03 \x01(\x0e2\x14.rvbox.v1.StreamKindR\x06stream\x12\x12\n" + + "\x04data\x18\x04 \x01(\fR\x04data\x12*\n" + + "\x11event_byte_offset\x18\x05 \x01(\x04R\x0feventByteOffset\x12 \n" + + "\fend_of_event\x18\x06 \x01(\bR\n" + + "endOfEvent\x12J\n" + + "\x13server_receipt_time\x18\a \x01(\v2\x1a.google.protobuf.TimestampR\x11serverReceiptTime\"\x9b\x01\n" + + "\x13RetentionTruncation\x12:\n" + + "\n" + + "truncation\x18\x01 \x01(\v2\x1a.rvbox.v1.OutputTruncationR\n" + + "truncation\x12H\n" + + "\x12server_recorded_at\x18\x02 \x01(\v2\x1a.google.protobuf.TimestampR\x10serverRecordedAt\"\x92\x02\n" + + "\x11GetOutputResponse\x12-\n" + + "\x06output\x18\x01 \x03(\v2\x15.rvbox.v1.OutputSliceR\x06output\x12&\n" + + "\x0fnext_page_token\x18\x02 \x01(\tR\rnextPageToken\x12)\n" + + "\x10output_truncated\x18\x03 \x01(\bR\x0foutputTruncated\x12?\n" + + "\vtruncations\x18\x04 \x03(\v2\x1d.rvbox.v1.RetentionTruncationR\vtruncations\x12:\n" + + "\n" + + "incomplete\x18\x05 \x01(\v2\x1a.rvbox.v1.OutputIncompleteR\n" + + "incomplete\"\xa6\x03\n" + + "\x0fStorageIncident\x12\x1f\n" + + "\vincident_id\x18\x01 \x01(\tR\n" + + "incidentId\x12;\n" + + "\vdetected_at\x18\x02 \x01(\v2\x1a.google.protobuf.TimestampR\n" + + "detectedAt\x12;\n" + + "\vresolved_at\x18\x03 \x01(\v2\x1a.google.protobuf.TimestampR\n" + + "resolvedAt\x124\n" + + "\x05state\x18\x04 \x01(\x0e2\x1e.rvbox.v1.StorageIncidentStateR\x05state\x12\x14\n" + + "\x05scope\x18\x05 \x01(\tR\x05scope\x12\x1b\n" + + "\tclient_id\x18\x06 \x01(\tR\bclientId\x12\x1d\n" + + "\n" + + "issue_uuid\x18\a \x01(\tR\tissueUuid\x12\x18\n" + + "\asummary\x18\b \x01(\tR\asummary\x12\x1b\n" + + "\tdata_loss\x18\t \x01(\bR\bdataLoss\x129\n" + + "\x18automatically_repairable\x18\n" + + " \x01(\bR\x17automaticallyRepairable\"\x84\x01\n" + + "\x1bListStorageIncidentsRequest\x12)\n" + + "\x10include_resolved\x18\x01 \x01(\bR\x0fincludeResolved\x12\x1b\n" + + "\tpage_size\x18\x02 \x01(\rR\bpageSize\x12\x1d\n" + + "\n" + + "page_token\x18\x03 \x01(\tR\tpageToken\"\x7f\n" + + "\x1cListStorageIncidentsResponse\x127\n" + + "\tincidents\x18\x01 \x03(\v2\x19.rvbox.v1.StorageIncidentR\tincidents\x12&\n" + + "\x0fnext_page_token\x18\x02 \x01(\tR\rnextPageToken\"^\n" + + "\x1cRepairStorageIncidentRequest\x12\x1f\n" + + "\vincident_id\x18\x01 \x01(\tR\n" + + "incidentId\x12\x1d\n" + + "\n" + + "request_id\x18\x02 \x01(\tR\trequestId\"V\n" + + "\x1dRepairStorageIncidentResponse\x125\n" + + "\bincident\x18\x01 \x01(\v2\x19.rvbox.v1.StorageIncidentR\bincident\"w\n" + + "!AcknowledgeStorageIncidentRequest\x12\x1f\n" + + "\vincident_id\x18\x01 \x01(\tR\n" + + "incidentId\x12\x12\n" + + "\x04note\x18\x02 \x01(\tR\x04note\x12\x1d\n" + + "\n" + + "request_id\x18\x03 \x01(\tR\trequestId\"[\n" + + "\"AcknowledgeStorageIncidentResponse\x125\n" + + "\bincident\x18\x01 \x01(\v2\x19.rvbox.v1.StorageIncidentR\bincident\"\x8a\x01\n" + + "\x1eAuthorizeClientTakeoverRequest\x12\x1b\n" + + "\tclient_id\x18\x01 \x01(\tR\bclientId\x12,\n" + + "\x12client_instance_id\x18\x02 \x01(\tR\x10clientInstanceId\x12\x1d\n" + + "\n" + + "request_id\x18\x03 \x01(\tR\trequestId\"\\\n" + + "\x1fAuthorizeClientTakeoverResponse\x129\n" + + "\n" + + "expires_at\x18\x01 \x01(\v2\x1a.google.protobuf.TimestampR\texpiresAt*\xad\x01\n" + + "\x14StorageIncidentState\x12&\n" + + "\"STORAGE_INCIDENT_STATE_UNSPECIFIED\x10\x00\x12\x1f\n" + + "\x1bSTORAGE_INCIDENT_STATE_OPEN\x10\x01\x12#\n" + + "\x1fSTORAGE_INCIDENT_STATE_REPAIRED\x10\x02\x12'\n" + + "#STORAGE_INCIDENT_STATE_ACKNOWLEDGED\x10\x032\xc5\t\n" + + "\aControl\x12J\n" + + "\vListClients\x12\x1c.rvbox.v1.ListClientsRequest\x1a\x1d.rvbox.v1.ListClientsResponse\x12D\n" + + "\tGetClient\x12\x1a.rvbox.v1.GetClientRequest\x1a\x1b.rvbox.v1.GetClientResponse\x12M\n" + + "\fListCommands\x12\x1d.rvbox.v1.ListCommandsRequest\x1a\x1e.rvbox.v1.ListCommandsResponse\x12G\n" + + "\n" + + "GetCommand\x12\x1b.rvbox.v1.GetCommandRequest\x1a\x1c.rvbox.v1.GetCommandResponse\x12G\n" + + "\n" + + "RunCommand\x12\x1b.rvbox.v1.RunCommandRequest\x1a\x1c.rvbox.v1.RunCommandResponse\x12R\n" + + "\rFollowCommand\x12\x1e.rvbox.v1.FollowCommandRequest\x1a\x1f.rvbox.v1.FollowCommandResponse0\x01\x12J\n" + + "\vAppendStdin\x12\x1c.rvbox.v1.AppendStdinRequest\x1a\x1d.rvbox.v1.AppendStdinResponse\x12G\n" + + "\n" + + "CloseStdin\x12\x1b.rvbox.v1.CloseStdinRequest\x1a\x1c.rvbox.v1.CloseStdinResponse\x12^\n" + + "\rSignalCommand\x12%.rvbox.v1.ControlSignalCommandRequest\x1a&.rvbox.v1.ControlSignalCommandResponse\x12D\n" + + "\tGetOutput\x12\x1a.rvbox.v1.GetOutputRequest\x1a\x1b.rvbox.v1.GetOutputResponse\x12e\n" + + "\x14ListStorageIncidents\x12%.rvbox.v1.ListStorageIncidentsRequest\x1a&.rvbox.v1.ListStorageIncidentsResponse\x12h\n" + + "\x15RepairStorageIncident\x12&.rvbox.v1.RepairStorageIncidentRequest\x1a'.rvbox.v1.RepairStorageIncidentResponse\x12w\n" + + "\x1aAcknowledgeStorageIncident\x12+.rvbox.v1.AcknowledgeStorageIncidentRequest\x1a,.rvbox.v1.AcknowledgeStorageIncidentResponse\x12n\n" + + "\x17AuthorizeClientTakeover\x12(.rvbox.v1.AuthorizeClientTakeoverRequest\x1a).rvbox.v1.AuthorizeClientTakeoverResponseB0Z.github.com/rvbox/rvbox/gen/go/rvbox/v1;rvboxv1b\x06proto3" + +var ( + file_rvbox_v1_control_proto_rawDescOnce sync.Once + file_rvbox_v1_control_proto_rawDescData []byte +) + +func file_rvbox_v1_control_proto_rawDescGZIP() []byte { + file_rvbox_v1_control_proto_rawDescOnce.Do(func() { + file_rvbox_v1_control_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_rvbox_v1_control_proto_rawDesc), len(file_rvbox_v1_control_proto_rawDesc))) + }) + return file_rvbox_v1_control_proto_rawDescData +} + +var file_rvbox_v1_control_proto_enumTypes = make([]protoimpl.EnumInfo, 1) +var file_rvbox_v1_control_proto_msgTypes = make([]protoimpl.MessageInfo, 32) +var file_rvbox_v1_control_proto_goTypes = []any{ + (StorageIncidentState)(0), // 0: rvbox.v1.StorageIncidentState + (*ClientSummary)(nil), // 1: rvbox.v1.ClientSummary + (*ListClientsRequest)(nil), // 2: rvbox.v1.ListClientsRequest + (*ListClientsResponse)(nil), // 3: rvbox.v1.ListClientsResponse + (*GetClientRequest)(nil), // 4: rvbox.v1.GetClientRequest + (*GetClientResponse)(nil), // 5: rvbox.v1.GetClientResponse + (*ListCommandsRequest)(nil), // 6: rvbox.v1.ListCommandsRequest + (*ListCommandsResponse)(nil), // 7: rvbox.v1.ListCommandsResponse + (*GetCommandRequest)(nil), // 8: rvbox.v1.GetCommandRequest + (*GetCommandResponse)(nil), // 9: rvbox.v1.GetCommandResponse + (*RunCommandRequest)(nil), // 10: rvbox.v1.RunCommandRequest + (*RunCommandResponse)(nil), // 11: rvbox.v1.RunCommandResponse + (*FollowCommandRequest)(nil), // 12: rvbox.v1.FollowCommandRequest + (*FollowCommandResponse)(nil), // 13: rvbox.v1.FollowCommandResponse + (*AppendStdinRequest)(nil), // 14: rvbox.v1.AppendStdinRequest + (*AppendStdinResponse)(nil), // 15: rvbox.v1.AppendStdinResponse + (*CloseStdinRequest)(nil), // 16: rvbox.v1.CloseStdinRequest + (*CloseStdinResponse)(nil), // 17: rvbox.v1.CloseStdinResponse + (*ControlSignalCommandRequest)(nil), // 18: rvbox.v1.ControlSignalCommandRequest + (*ControlSignalCommandResponse)(nil), // 19: rvbox.v1.ControlSignalCommandResponse + (*GetOutputRequest)(nil), // 20: rvbox.v1.GetOutputRequest + (*OutputSlice)(nil), // 21: rvbox.v1.OutputSlice + (*RetentionTruncation)(nil), // 22: rvbox.v1.RetentionTruncation + (*GetOutputResponse)(nil), // 23: rvbox.v1.GetOutputResponse + (*StorageIncident)(nil), // 24: rvbox.v1.StorageIncident + (*ListStorageIncidentsRequest)(nil), // 25: rvbox.v1.ListStorageIncidentsRequest + (*ListStorageIncidentsResponse)(nil), // 26: rvbox.v1.ListStorageIncidentsResponse + (*RepairStorageIncidentRequest)(nil), // 27: rvbox.v1.RepairStorageIncidentRequest + (*RepairStorageIncidentResponse)(nil), // 28: rvbox.v1.RepairStorageIncidentResponse + (*AcknowledgeStorageIncidentRequest)(nil), // 29: rvbox.v1.AcknowledgeStorageIncidentRequest + (*AcknowledgeStorageIncidentResponse)(nil), // 30: rvbox.v1.AcknowledgeStorageIncidentResponse + (*AuthorizeClientTakeoverRequest)(nil), // 31: rvbox.v1.AuthorizeClientTakeoverRequest + (*AuthorizeClientTakeoverResponse)(nil), // 32: rvbox.v1.AuthorizeClientTakeoverResponse + (*timestamppb.Timestamp)(nil), // 33: google.protobuf.Timestamp + (Platform)(0), // 34: rvbox.v1.Platform + (ShellType)(0), // 35: rvbox.v1.ShellType + (*CommandRecord)(nil), // 36: rvbox.v1.CommandRecord + (*ResourceSnapshot)(nil), // 37: rvbox.v1.ResourceSnapshot + (*ExecutionSpec)(nil), // 38: rvbox.v1.ExecutionSpec + (*durationpb.Duration)(nil), // 39: google.protobuf.Duration + (CommandLifecycle)(0), // 40: rvbox.v1.CommandLifecycle + (*CommandEvent)(nil), // 41: rvbox.v1.CommandEvent + (SignalKind)(0), // 42: rvbox.v1.SignalKind + (StreamKind)(0), // 43: rvbox.v1.StreamKind + (*OutputTruncation)(nil), // 44: rvbox.v1.OutputTruncation + (*OutputIncomplete)(nil), // 45: rvbox.v1.OutputIncomplete +} +var file_rvbox_v1_control_proto_depIdxs = []int32{ + 33, // 0: rvbox.v1.ClientSummary.connected_at:type_name -> google.protobuf.Timestamp + 33, // 1: rvbox.v1.ClientSummary.last_seen_at:type_name -> google.protobuf.Timestamp + 34, // 2: rvbox.v1.ClientSummary.platform:type_name -> rvbox.v1.Platform + 35, // 3: rvbox.v1.ClientSummary.supported_shells:type_name -> rvbox.v1.ShellType + 33, // 4: rvbox.v1.ClientSummary.pending_instance_seen_at:type_name -> google.protobuf.Timestamp + 1, // 5: rvbox.v1.ListClientsResponse.clients:type_name -> rvbox.v1.ClientSummary + 1, // 6: rvbox.v1.GetClientResponse.client:type_name -> rvbox.v1.ClientSummary + 36, // 7: rvbox.v1.ListCommandsResponse.commands:type_name -> rvbox.v1.CommandRecord + 36, // 8: rvbox.v1.GetCommandResponse.command:type_name -> rvbox.v1.CommandRecord + 37, // 9: rvbox.v1.GetCommandResponse.latest_resource:type_name -> rvbox.v1.ResourceSnapshot + 38, // 10: rvbox.v1.RunCommandRequest.spec:type_name -> rvbox.v1.ExecutionSpec + 39, // 11: rvbox.v1.RunCommandRequest.queue_ttl:type_name -> google.protobuf.Duration + 40, // 12: rvbox.v1.RunCommandResponse.lifecycle:type_name -> rvbox.v1.CommandLifecycle + 41, // 13: rvbox.v1.FollowCommandResponse.event:type_name -> rvbox.v1.CommandEvent + 22, // 14: rvbox.v1.FollowCommandResponse.retention_truncation:type_name -> rvbox.v1.RetentionTruncation + 33, // 15: rvbox.v1.FollowCommandResponse.server_receipt_time:type_name -> google.protobuf.Timestamp + 42, // 16: rvbox.v1.ControlSignalCommandRequest.signal:type_name -> rvbox.v1.SignalKind + 43, // 17: rvbox.v1.GetOutputRequest.streams:type_name -> rvbox.v1.StreamKind + 33, // 18: rvbox.v1.OutputSlice.observed_at:type_name -> google.protobuf.Timestamp + 43, // 19: rvbox.v1.OutputSlice.stream:type_name -> rvbox.v1.StreamKind + 33, // 20: rvbox.v1.OutputSlice.server_receipt_time:type_name -> google.protobuf.Timestamp + 44, // 21: rvbox.v1.RetentionTruncation.truncation:type_name -> rvbox.v1.OutputTruncation + 33, // 22: rvbox.v1.RetentionTruncation.server_recorded_at:type_name -> google.protobuf.Timestamp + 21, // 23: rvbox.v1.GetOutputResponse.output:type_name -> rvbox.v1.OutputSlice + 22, // 24: rvbox.v1.GetOutputResponse.truncations:type_name -> rvbox.v1.RetentionTruncation + 45, // 25: rvbox.v1.GetOutputResponse.incomplete:type_name -> rvbox.v1.OutputIncomplete + 33, // 26: rvbox.v1.StorageIncident.detected_at:type_name -> google.protobuf.Timestamp + 33, // 27: rvbox.v1.StorageIncident.resolved_at:type_name -> google.protobuf.Timestamp + 0, // 28: rvbox.v1.StorageIncident.state:type_name -> rvbox.v1.StorageIncidentState + 24, // 29: rvbox.v1.ListStorageIncidentsResponse.incidents:type_name -> rvbox.v1.StorageIncident + 24, // 30: rvbox.v1.RepairStorageIncidentResponse.incident:type_name -> rvbox.v1.StorageIncident + 24, // 31: rvbox.v1.AcknowledgeStorageIncidentResponse.incident:type_name -> rvbox.v1.StorageIncident + 33, // 32: rvbox.v1.AuthorizeClientTakeoverResponse.expires_at:type_name -> google.protobuf.Timestamp + 2, // 33: rvbox.v1.Control.ListClients:input_type -> rvbox.v1.ListClientsRequest + 4, // 34: rvbox.v1.Control.GetClient:input_type -> rvbox.v1.GetClientRequest + 6, // 35: rvbox.v1.Control.ListCommands:input_type -> rvbox.v1.ListCommandsRequest + 8, // 36: rvbox.v1.Control.GetCommand:input_type -> rvbox.v1.GetCommandRequest + 10, // 37: rvbox.v1.Control.RunCommand:input_type -> rvbox.v1.RunCommandRequest + 12, // 38: rvbox.v1.Control.FollowCommand:input_type -> rvbox.v1.FollowCommandRequest + 14, // 39: rvbox.v1.Control.AppendStdin:input_type -> rvbox.v1.AppendStdinRequest + 16, // 40: rvbox.v1.Control.CloseStdin:input_type -> rvbox.v1.CloseStdinRequest + 18, // 41: rvbox.v1.Control.SignalCommand:input_type -> rvbox.v1.ControlSignalCommandRequest + 20, // 42: rvbox.v1.Control.GetOutput:input_type -> rvbox.v1.GetOutputRequest + 25, // 43: rvbox.v1.Control.ListStorageIncidents:input_type -> rvbox.v1.ListStorageIncidentsRequest + 27, // 44: rvbox.v1.Control.RepairStorageIncident:input_type -> rvbox.v1.RepairStorageIncidentRequest + 29, // 45: rvbox.v1.Control.AcknowledgeStorageIncident:input_type -> rvbox.v1.AcknowledgeStorageIncidentRequest + 31, // 46: rvbox.v1.Control.AuthorizeClientTakeover:input_type -> rvbox.v1.AuthorizeClientTakeoverRequest + 3, // 47: rvbox.v1.Control.ListClients:output_type -> rvbox.v1.ListClientsResponse + 5, // 48: rvbox.v1.Control.GetClient:output_type -> rvbox.v1.GetClientResponse + 7, // 49: rvbox.v1.Control.ListCommands:output_type -> rvbox.v1.ListCommandsResponse + 9, // 50: rvbox.v1.Control.GetCommand:output_type -> rvbox.v1.GetCommandResponse + 11, // 51: rvbox.v1.Control.RunCommand:output_type -> rvbox.v1.RunCommandResponse + 13, // 52: rvbox.v1.Control.FollowCommand:output_type -> rvbox.v1.FollowCommandResponse + 15, // 53: rvbox.v1.Control.AppendStdin:output_type -> rvbox.v1.AppendStdinResponse + 17, // 54: rvbox.v1.Control.CloseStdin:output_type -> rvbox.v1.CloseStdinResponse + 19, // 55: rvbox.v1.Control.SignalCommand:output_type -> rvbox.v1.ControlSignalCommandResponse + 23, // 56: rvbox.v1.Control.GetOutput:output_type -> rvbox.v1.GetOutputResponse + 26, // 57: rvbox.v1.Control.ListStorageIncidents:output_type -> rvbox.v1.ListStorageIncidentsResponse + 28, // 58: rvbox.v1.Control.RepairStorageIncident:output_type -> rvbox.v1.RepairStorageIncidentResponse + 30, // 59: rvbox.v1.Control.AcknowledgeStorageIncident:output_type -> rvbox.v1.AcknowledgeStorageIncidentResponse + 32, // 60: rvbox.v1.Control.AuthorizeClientTakeover:output_type -> rvbox.v1.AuthorizeClientTakeoverResponse + 47, // [47:61] is the sub-list for method output_type + 33, // [33:47] is the sub-list for method input_type + 33, // [33:33] is the sub-list for extension type_name + 33, // [33:33] is the sub-list for extension extendee + 0, // [0:33] is the sub-list for field type_name +} + +func init() { file_rvbox_v1_control_proto_init() } +func file_rvbox_v1_control_proto_init() { + if File_rvbox_v1_control_proto != nil { + return + } + file_rvbox_v1_common_proto_init() + file_rvbox_v1_control_proto_msgTypes[12].OneofWrappers = []any{ + (*FollowCommandResponse_Event)(nil), + (*FollowCommandResponse_RetentionTruncation)(nil), + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: unsafe.Slice(unsafe.StringData(file_rvbox_v1_control_proto_rawDesc), len(file_rvbox_v1_control_proto_rawDesc)), + NumEnums: 1, + NumMessages: 32, + NumExtensions: 0, + NumServices: 1, + }, + GoTypes: file_rvbox_v1_control_proto_goTypes, + DependencyIndexes: file_rvbox_v1_control_proto_depIdxs, + EnumInfos: file_rvbox_v1_control_proto_enumTypes, + MessageInfos: file_rvbox_v1_control_proto_msgTypes, + }.Build() + File_rvbox_v1_control_proto = out.File + file_rvbox_v1_control_proto_goTypes = nil + file_rvbox_v1_control_proto_depIdxs = nil +} diff --git a/gen/go/rvbox/v1/control_grpc.pb.go b/gen/go/rvbox/v1/control_grpc.pb.go new file mode 100644 index 0000000..c81ea57 --- /dev/null +++ b/gen/go/rvbox/v1/control_grpc.pb.go @@ -0,0 +1,619 @@ +// Code generated by protoc-gen-go-grpc. DO NOT EDIT. +// versions: +// - protoc-gen-go-grpc v1.6.2 +// - protoc (unknown) +// source: rvbox/v1/control.proto + +package rvboxv1 + +import ( + context "context" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" +) + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +// Requires gRPC-Go v1.64.0 or later. +const _ = grpc.SupportPackageIsVersion9 + +const ( + Control_ListClients_FullMethodName = "/rvbox.v1.Control/ListClients" + Control_GetClient_FullMethodName = "/rvbox.v1.Control/GetClient" + Control_ListCommands_FullMethodName = "/rvbox.v1.Control/ListCommands" + Control_GetCommand_FullMethodName = "/rvbox.v1.Control/GetCommand" + Control_RunCommand_FullMethodName = "/rvbox.v1.Control/RunCommand" + Control_FollowCommand_FullMethodName = "/rvbox.v1.Control/FollowCommand" + Control_AppendStdin_FullMethodName = "/rvbox.v1.Control/AppendStdin" + Control_CloseStdin_FullMethodName = "/rvbox.v1.Control/CloseStdin" + Control_SignalCommand_FullMethodName = "/rvbox.v1.Control/SignalCommand" + Control_GetOutput_FullMethodName = "/rvbox.v1.Control/GetOutput" + Control_ListStorageIncidents_FullMethodName = "/rvbox.v1.Control/ListStorageIncidents" + Control_RepairStorageIncident_FullMethodName = "/rvbox.v1.Control/RepairStorageIncident" + Control_AcknowledgeStorageIncident_FullMethodName = "/rvbox.v1.Control/AcknowledgeStorageIncident" + Control_AuthorizeClientTakeover_FullMethodName = "/rvbox.v1.Control/AuthorizeClientTakeover" +) + +// ControlClient is the client API for Control service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. +type ControlClient interface { + ListClients(ctx context.Context, in *ListClientsRequest, opts ...grpc.CallOption) (*ListClientsResponse, error) + GetClient(ctx context.Context, in *GetClientRequest, opts ...grpc.CallOption) (*GetClientResponse, error) + ListCommands(ctx context.Context, in *ListCommandsRequest, opts ...grpc.CallOption) (*ListCommandsResponse, error) + GetCommand(ctx context.Context, in *GetCommandRequest, opts ...grpc.CallOption) (*GetCommandResponse, error) + RunCommand(ctx context.Context, in *RunCommandRequest, opts ...grpc.CallOption) (*RunCommandResponse, error) + FollowCommand(ctx context.Context, in *FollowCommandRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[FollowCommandResponse], error) + AppendStdin(ctx context.Context, in *AppendStdinRequest, opts ...grpc.CallOption) (*AppendStdinResponse, error) + CloseStdin(ctx context.Context, in *CloseStdinRequest, opts ...grpc.CallOption) (*CloseStdinResponse, error) + SignalCommand(ctx context.Context, in *ControlSignalCommandRequest, opts ...grpc.CallOption) (*ControlSignalCommandResponse, error) + GetOutput(ctx context.Context, in *GetOutputRequest, opts ...grpc.CallOption) (*GetOutputResponse, error) + ListStorageIncidents(ctx context.Context, in *ListStorageIncidentsRequest, opts ...grpc.CallOption) (*ListStorageIncidentsResponse, error) + RepairStorageIncident(ctx context.Context, in *RepairStorageIncidentRequest, opts ...grpc.CallOption) (*RepairStorageIncidentResponse, error) + AcknowledgeStorageIncident(ctx context.Context, in *AcknowledgeStorageIncidentRequest, opts ...grpc.CallOption) (*AcknowledgeStorageIncidentResponse, error) + AuthorizeClientTakeover(ctx context.Context, in *AuthorizeClientTakeoverRequest, opts ...grpc.CallOption) (*AuthorizeClientTakeoverResponse, error) +} + +type controlClient struct { + cc grpc.ClientConnInterface +} + +func NewControlClient(cc grpc.ClientConnInterface) ControlClient { + return &controlClient{cc} +} + +func (c *controlClient) ListClients(ctx context.Context, in *ListClientsRequest, opts ...grpc.CallOption) (*ListClientsResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(ListClientsResponse) + err := c.cc.Invoke(ctx, Control_ListClients_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *controlClient) GetClient(ctx context.Context, in *GetClientRequest, opts ...grpc.CallOption) (*GetClientResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(GetClientResponse) + err := c.cc.Invoke(ctx, Control_GetClient_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *controlClient) ListCommands(ctx context.Context, in *ListCommandsRequest, opts ...grpc.CallOption) (*ListCommandsResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(ListCommandsResponse) + err := c.cc.Invoke(ctx, Control_ListCommands_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *controlClient) GetCommand(ctx context.Context, in *GetCommandRequest, opts ...grpc.CallOption) (*GetCommandResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(GetCommandResponse) + err := c.cc.Invoke(ctx, Control_GetCommand_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *controlClient) RunCommand(ctx context.Context, in *RunCommandRequest, opts ...grpc.CallOption) (*RunCommandResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(RunCommandResponse) + err := c.cc.Invoke(ctx, Control_RunCommand_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *controlClient) FollowCommand(ctx context.Context, in *FollowCommandRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[FollowCommandResponse], error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + stream, err := c.cc.NewStream(ctx, &Control_ServiceDesc.Streams[0], Control_FollowCommand_FullMethodName, cOpts...) + if err != nil { + return nil, err + } + x := &grpc.GenericClientStream[FollowCommandRequest, FollowCommandResponse]{ClientStream: stream} + if err := x.ClientStream.SendMsg(in); err != nil { + return nil, err + } + if err := x.ClientStream.CloseSend(); err != nil { + return nil, err + } + return x, nil +} + +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type Control_FollowCommandClient = grpc.ServerStreamingClient[FollowCommandResponse] + +func (c *controlClient) AppendStdin(ctx context.Context, in *AppendStdinRequest, opts ...grpc.CallOption) (*AppendStdinResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(AppendStdinResponse) + err := c.cc.Invoke(ctx, Control_AppendStdin_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *controlClient) CloseStdin(ctx context.Context, in *CloseStdinRequest, opts ...grpc.CallOption) (*CloseStdinResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(CloseStdinResponse) + err := c.cc.Invoke(ctx, Control_CloseStdin_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *controlClient) SignalCommand(ctx context.Context, in *ControlSignalCommandRequest, opts ...grpc.CallOption) (*ControlSignalCommandResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(ControlSignalCommandResponse) + err := c.cc.Invoke(ctx, Control_SignalCommand_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *controlClient) GetOutput(ctx context.Context, in *GetOutputRequest, opts ...grpc.CallOption) (*GetOutputResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(GetOutputResponse) + err := c.cc.Invoke(ctx, Control_GetOutput_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *controlClient) ListStorageIncidents(ctx context.Context, in *ListStorageIncidentsRequest, opts ...grpc.CallOption) (*ListStorageIncidentsResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(ListStorageIncidentsResponse) + err := c.cc.Invoke(ctx, Control_ListStorageIncidents_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *controlClient) RepairStorageIncident(ctx context.Context, in *RepairStorageIncidentRequest, opts ...grpc.CallOption) (*RepairStorageIncidentResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(RepairStorageIncidentResponse) + err := c.cc.Invoke(ctx, Control_RepairStorageIncident_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *controlClient) AcknowledgeStorageIncident(ctx context.Context, in *AcknowledgeStorageIncidentRequest, opts ...grpc.CallOption) (*AcknowledgeStorageIncidentResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(AcknowledgeStorageIncidentResponse) + err := c.cc.Invoke(ctx, Control_AcknowledgeStorageIncident_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *controlClient) AuthorizeClientTakeover(ctx context.Context, in *AuthorizeClientTakeoverRequest, opts ...grpc.CallOption) (*AuthorizeClientTakeoverResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(AuthorizeClientTakeoverResponse) + err := c.cc.Invoke(ctx, Control_AuthorizeClientTakeover_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +// ControlServer is the server API for Control service. +// All implementations must embed UnimplementedControlServer +// for forward compatibility. +type ControlServer interface { + ListClients(context.Context, *ListClientsRequest) (*ListClientsResponse, error) + GetClient(context.Context, *GetClientRequest) (*GetClientResponse, error) + ListCommands(context.Context, *ListCommandsRequest) (*ListCommandsResponse, error) + GetCommand(context.Context, *GetCommandRequest) (*GetCommandResponse, error) + RunCommand(context.Context, *RunCommandRequest) (*RunCommandResponse, error) + FollowCommand(*FollowCommandRequest, grpc.ServerStreamingServer[FollowCommandResponse]) error + AppendStdin(context.Context, *AppendStdinRequest) (*AppendStdinResponse, error) + CloseStdin(context.Context, *CloseStdinRequest) (*CloseStdinResponse, error) + SignalCommand(context.Context, *ControlSignalCommandRequest) (*ControlSignalCommandResponse, error) + GetOutput(context.Context, *GetOutputRequest) (*GetOutputResponse, error) + ListStorageIncidents(context.Context, *ListStorageIncidentsRequest) (*ListStorageIncidentsResponse, error) + RepairStorageIncident(context.Context, *RepairStorageIncidentRequest) (*RepairStorageIncidentResponse, error) + AcknowledgeStorageIncident(context.Context, *AcknowledgeStorageIncidentRequest) (*AcknowledgeStorageIncidentResponse, error) + AuthorizeClientTakeover(context.Context, *AuthorizeClientTakeoverRequest) (*AuthorizeClientTakeoverResponse, error) + mustEmbedUnimplementedControlServer() +} + +// UnimplementedControlServer must be embedded to have +// forward compatible implementations. +// +// NOTE: this should be embedded by value instead of pointer to avoid a nil +// pointer dereference when methods are called. +type UnimplementedControlServer struct{} + +func (UnimplementedControlServer) ListClients(context.Context, *ListClientsRequest) (*ListClientsResponse, error) { + return nil, status.Error(codes.Unimplemented, "method ListClients not implemented") +} +func (UnimplementedControlServer) GetClient(context.Context, *GetClientRequest) (*GetClientResponse, error) { + return nil, status.Error(codes.Unimplemented, "method GetClient not implemented") +} +func (UnimplementedControlServer) ListCommands(context.Context, *ListCommandsRequest) (*ListCommandsResponse, error) { + return nil, status.Error(codes.Unimplemented, "method ListCommands not implemented") +} +func (UnimplementedControlServer) GetCommand(context.Context, *GetCommandRequest) (*GetCommandResponse, error) { + return nil, status.Error(codes.Unimplemented, "method GetCommand not implemented") +} +func (UnimplementedControlServer) RunCommand(context.Context, *RunCommandRequest) (*RunCommandResponse, error) { + return nil, status.Error(codes.Unimplemented, "method RunCommand not implemented") +} +func (UnimplementedControlServer) FollowCommand(*FollowCommandRequest, grpc.ServerStreamingServer[FollowCommandResponse]) error { + return status.Error(codes.Unimplemented, "method FollowCommand not implemented") +} +func (UnimplementedControlServer) AppendStdin(context.Context, *AppendStdinRequest) (*AppendStdinResponse, error) { + return nil, status.Error(codes.Unimplemented, "method AppendStdin not implemented") +} +func (UnimplementedControlServer) CloseStdin(context.Context, *CloseStdinRequest) (*CloseStdinResponse, error) { + return nil, status.Error(codes.Unimplemented, "method CloseStdin not implemented") +} +func (UnimplementedControlServer) SignalCommand(context.Context, *ControlSignalCommandRequest) (*ControlSignalCommandResponse, error) { + return nil, status.Error(codes.Unimplemented, "method SignalCommand not implemented") +} +func (UnimplementedControlServer) GetOutput(context.Context, *GetOutputRequest) (*GetOutputResponse, error) { + return nil, status.Error(codes.Unimplemented, "method GetOutput not implemented") +} +func (UnimplementedControlServer) ListStorageIncidents(context.Context, *ListStorageIncidentsRequest) (*ListStorageIncidentsResponse, error) { + return nil, status.Error(codes.Unimplemented, "method ListStorageIncidents not implemented") +} +func (UnimplementedControlServer) RepairStorageIncident(context.Context, *RepairStorageIncidentRequest) (*RepairStorageIncidentResponse, error) { + return nil, status.Error(codes.Unimplemented, "method RepairStorageIncident not implemented") +} +func (UnimplementedControlServer) AcknowledgeStorageIncident(context.Context, *AcknowledgeStorageIncidentRequest) (*AcknowledgeStorageIncidentResponse, error) { + return nil, status.Error(codes.Unimplemented, "method AcknowledgeStorageIncident not implemented") +} +func (UnimplementedControlServer) AuthorizeClientTakeover(context.Context, *AuthorizeClientTakeoverRequest) (*AuthorizeClientTakeoverResponse, error) { + return nil, status.Error(codes.Unimplemented, "method AuthorizeClientTakeover not implemented") +} +func (UnimplementedControlServer) mustEmbedUnimplementedControlServer() {} +func (UnimplementedControlServer) testEmbeddedByValue() {} + +// UnsafeControlServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to ControlServer will +// result in compilation errors. +type UnsafeControlServer interface { + mustEmbedUnimplementedControlServer() +} + +func RegisterControlServer(s grpc.ServiceRegistrar, srv ControlServer) { + // If the following call panics, it indicates UnimplementedControlServer was + // embedded by pointer and is nil. This will cause panics if an + // unimplemented method is ever invoked, so we test this at initialization + // time to prevent it from happening at runtime later due to I/O. + if t, ok := srv.(interface{ testEmbeddedByValue() }); ok { + t.testEmbeddedByValue() + } + s.RegisterService(&Control_ServiceDesc, srv) +} + +func _Control_ListClients_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ListClientsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ControlServer).ListClients(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Control_ListClients_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ControlServer).ListClients(ctx, req.(*ListClientsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Control_GetClient_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetClientRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ControlServer).GetClient(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Control_GetClient_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ControlServer).GetClient(ctx, req.(*GetClientRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Control_ListCommands_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ListCommandsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ControlServer).ListCommands(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Control_ListCommands_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ControlServer).ListCommands(ctx, req.(*ListCommandsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Control_GetCommand_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetCommandRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ControlServer).GetCommand(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Control_GetCommand_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ControlServer).GetCommand(ctx, req.(*GetCommandRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Control_RunCommand_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(RunCommandRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ControlServer).RunCommand(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Control_RunCommand_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ControlServer).RunCommand(ctx, req.(*RunCommandRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Control_FollowCommand_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(FollowCommandRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(ControlServer).FollowCommand(m, &grpc.GenericServerStream[FollowCommandRequest, FollowCommandResponse]{ServerStream: stream}) +} + +// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name. +type Control_FollowCommandServer = grpc.ServerStreamingServer[FollowCommandResponse] + +func _Control_AppendStdin_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(AppendStdinRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ControlServer).AppendStdin(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Control_AppendStdin_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ControlServer).AppendStdin(ctx, req.(*AppendStdinRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Control_CloseStdin_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(CloseStdinRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ControlServer).CloseStdin(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Control_CloseStdin_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ControlServer).CloseStdin(ctx, req.(*CloseStdinRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Control_SignalCommand_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ControlSignalCommandRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ControlServer).SignalCommand(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Control_SignalCommand_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ControlServer).SignalCommand(ctx, req.(*ControlSignalCommandRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Control_GetOutput_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetOutputRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ControlServer).GetOutput(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Control_GetOutput_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ControlServer).GetOutput(ctx, req.(*GetOutputRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Control_ListStorageIncidents_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ListStorageIncidentsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ControlServer).ListStorageIncidents(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Control_ListStorageIncidents_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ControlServer).ListStorageIncidents(ctx, req.(*ListStorageIncidentsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Control_RepairStorageIncident_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(RepairStorageIncidentRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ControlServer).RepairStorageIncident(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Control_RepairStorageIncident_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ControlServer).RepairStorageIncident(ctx, req.(*RepairStorageIncidentRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Control_AcknowledgeStorageIncident_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(AcknowledgeStorageIncidentRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ControlServer).AcknowledgeStorageIncident(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Control_AcknowledgeStorageIncident_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ControlServer).AcknowledgeStorageIncident(ctx, req.(*AcknowledgeStorageIncidentRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Control_AuthorizeClientTakeover_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(AuthorizeClientTakeoverRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ControlServer).AuthorizeClientTakeover(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Control_AuthorizeClientTakeover_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ControlServer).AuthorizeClientTakeover(ctx, req.(*AuthorizeClientTakeoverRequest)) + } + return interceptor(ctx, in, info, handler) +} + +// Control_ServiceDesc is the grpc.ServiceDesc for Control service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +var Control_ServiceDesc = grpc.ServiceDesc{ + ServiceName: "rvbox.v1.Control", + HandlerType: (*ControlServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "ListClients", + Handler: _Control_ListClients_Handler, + }, + { + MethodName: "GetClient", + Handler: _Control_GetClient_Handler, + }, + { + MethodName: "ListCommands", + Handler: _Control_ListCommands_Handler, + }, + { + MethodName: "GetCommand", + Handler: _Control_GetCommand_Handler, + }, + { + MethodName: "RunCommand", + Handler: _Control_RunCommand_Handler, + }, + { + MethodName: "AppendStdin", + Handler: _Control_AppendStdin_Handler, + }, + { + MethodName: "CloseStdin", + Handler: _Control_CloseStdin_Handler, + }, + { + MethodName: "SignalCommand", + Handler: _Control_SignalCommand_Handler, + }, + { + MethodName: "GetOutput", + Handler: _Control_GetOutput_Handler, + }, + { + MethodName: "ListStorageIncidents", + Handler: _Control_ListStorageIncidents_Handler, + }, + { + MethodName: "RepairStorageIncident", + Handler: _Control_RepairStorageIncident_Handler, + }, + { + MethodName: "AcknowledgeStorageIncident", + Handler: _Control_AcknowledgeStorageIncident_Handler, + }, + { + MethodName: "AuthorizeClientTakeover", + Handler: _Control_AuthorizeClientTakeover_Handler, + }, + }, + Streams: []grpc.StreamDesc{ + { + StreamName: "FollowCommand", + Handler: _Control_FollowCommand_Handler, + ServerStreams: true, + }, + }, + Metadata: "rvbox/v1/control.proto", +} diff --git a/go.mod b/go.mod new file mode 100644 index 0000000..ea46290 --- /dev/null +++ b/go.mod @@ -0,0 +1,15 @@ +module github.com/rvbox/rvbox + +go 1.27.0 + +require ( + google.golang.org/grpc v1.83.2 + google.golang.org/protobuf v1.36.12 +) + +require ( + golang.org/x/net v0.58.0 // indirect + golang.org/x/sys v0.47.0 // indirect + golang.org/x/text v0.41.0 // indirect + google.golang.org/genproto/googleapis/rpc v0.0.0-20260526163538-3dc84a4a5aaa // indirect +) diff --git a/go.sum b/go.sum new file mode 100644 index 0000000..1371e12 --- /dev/null +++ b/go.sum @@ -0,0 +1,38 @@ +github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= +github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= +github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI= +github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= +github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= +github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= +github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek= +github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps= +github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8= +github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU= +github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= +github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64= +go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y= +go.opentelemetry.io/otel v1.44.0 h1:JjwHmHpA4iZ3wBxluu2fbbE7j4kqlE8jXyAyPXH7HqU= +go.opentelemetry.io/otel v1.44.0/go.mod h1:BMgjTHL9WPRlRjL2oZCBTL4whCGtXch2H4BhOPIAyYc= +go.opentelemetry.io/otel/metric v1.44.0 h1:1w0gILTcHdr3YI+ixLyjemwrVnsMURbTZFrSYCdDdmc= +go.opentelemetry.io/otel/metric v1.44.0/go.mod h1:8O7hanEPBNgEMmybD3s2VBKcgWOCsA6tzHBPODAiquo= +go.opentelemetry.io/otel/sdk v1.44.0 h1:nHYwb9lK+fJPU/dnT6s7W7Z8itMWyqrnVfbheVYrZ58= +go.opentelemetry.io/otel/sdk v1.44.0/go.mod h1:Osuydd3Se74nqjAKxid74N5eC+jfEqfTegHRnq58oK0= +go.opentelemetry.io/otel/sdk/metric v1.44.0 h1:3LlKgI+VjbVsjNRFZJZAJ30WjXC5VkNRks6si09iEfI= +go.opentelemetry.io/otel/sdk/metric v1.44.0/go.mod h1:5B5pMARnXxKhltooO4xUuCBorl65a4EpnTalObqOigA= +go.opentelemetry.io/otel/trace v1.44.0 h1:jxF5CsGYCe74MCRx2X4g7WsY/VBKRqqpNvXlX/6gtIk= +go.opentelemetry.io/otel/trace v1.44.0/go.mod h1:oLl1jrMQAVo6v3GAggN+1VH9VIz9iUSvW53sW1Q8PIE= +golang.org/x/net v0.58.0 h1:ynWG7rqYi4ccpTEuPZ2QGWHktVEM9DMCj9yzDE0Q7To= +golang.org/x/net v0.58.0/go.mod h1:YwCddHnFlT7eLQqVprV19OnhLGtc5xOKgE0RyqgfWAU= +golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs= +golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= +golang.org/x/text v0.41.0 h1:vz/seA0lnX87Othu2f/0L24RcgrXD9/YFTSuGjj3rH8= +golang.org/x/text v0.41.0/go.mod h1:jvf1O8ajNzZqhSrQBPbutR/EB83Cc0CFrezNQIwbb5M= +gonum.org/v1/gonum v0.17.0 h1:VbpOemQlsSMrYmn7T2OUvQ4dqxQXU+ouZFQsZOx50z4= +gonum.org/v1/gonum v0.17.0/go.mod h1:El3tOrEuMpv2UdMrbNlKEh9vd86bmQ6vqIcDwxEOc1E= +google.golang.org/genproto/googleapis/rpc v0.0.0-20260526163538-3dc84a4a5aaa h1:mZHHdPZl0dbGHCflZgAq/Q468DWVFcU2whhB2KAo8fk= +google.golang.org/genproto/googleapis/rpc v0.0.0-20260526163538-3dc84a4a5aaa/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8= +google.golang.org/grpc v1.83.2 h1:EManeRomTObA0BU7I8vXgg/78uE5MJ9M8B39EX2WscU= +google.golang.org/grpc v1.83.2/go.mod h1:YPI1hK3kDked6iHvgX3tR0y+nX/qpMFKhPgFsokw1S8= +google.golang.org/protobuf v1.36.12 h1:pJOKDDOyeXErUroCihFAd5LQuwXBSpVnKGrj5o/fwxc= +google.golang.org/protobuf v1.36.12/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco= diff --git a/scripts/check-buf-lint b/scripts/check-buf-lint new file mode 100755 index 0000000..3614a3f --- /dev/null +++ b/scripts/check-buf-lint @@ -0,0 +1,15 @@ +#!/bin/sh +set -eu + +repo_root=$(CDPATH= cd -- "$(dirname -- "$0")/.." && pwd) +actual=$(mktemp) +trap 'rm -f "$actual"' EXIT HUP INT TERM + +cd "$repo_root" +buf lint --error-format=text >"$actual" 2>&1 || true +LC_ALL=C sort -o "$actual" "$actual" + +if ! diff -u config/buf-lint-baseline.txt "$actual"; then + echo "Buf lint findings changed; only the reviewed first-draft findings are accepted." >&2 + exit 1 +fi diff --git a/scripts/test-e2e b/scripts/test-e2e new file mode 100755 index 0000000..78dfa67 --- /dev/null +++ b/scripts/test-e2e @@ -0,0 +1,6 @@ +#!/bin/sh +set -eu + +echo "E2E requires the production server plus a native Windows host; that host is currently unavailable" >&2 +exit 2 + diff --git a/scripts/test-env b/scripts/test-env new file mode 100755 index 0000000..01c5016 --- /dev/null +++ b/scripts/test-env @@ -0,0 +1,20 @@ +#!/bin/sh +set -eu + +command=${1:-} +case "$command" in + doctor) + docker version >/dev/null + docker compose version >/dev/null + echo "Docker and Docker Compose are available." + ;; + status) + echo "No test run has been created; the shared harness is not implemented yet." + ;; + *) + echo "usage: scripts/test-env doctor|status" >&2 + echo "recover/reuse/collect/reset/purge arrive with the Phase 0 harness implementation" >&2 + exit 2 + ;; +esac + diff --git a/scripts/test-integration b/scripts/test-integration new file mode 100755 index 0000000..9068a33 --- /dev/null +++ b/scripts/test-integration @@ -0,0 +1,6 @@ +#!/bin/sh +set -eu + +echo "integration harness is not implemented yet; use scripts/test-unit for the current Phase 0/1 scope" >&2 +exit 2 + diff --git a/scripts/test-unit b/scripts/test-unit new file mode 100755 index 0000000..7a962b7 --- /dev/null +++ b/scripts/test-unit @@ -0,0 +1,25 @@ +#!/bin/sh +set -eu + +repo_root=$(CDPATH= cd -- "$(dirname -- "$0")/.." && pwd) +package=./... +run= +race=false + +while [ "$#" -gt 0 ]; do + case "$1" in + --package) package=$2; shift 2 ;; + --run) run=$2; shift 2 ;; + --race) race=true; shift ;; + *) echo "usage: scripts/test-unit [--package PATTERN] [--run REGEXP] [--race]" >&2; exit 2 ;; + esac +done + +set -- go test -shuffle=on +if [ "$race" = true ]; then set -- "$@" -race; fi +if [ -n "$run" ]; then set -- "$@" -run "$run"; fi +set -- "$@" "$package" + +cd "$repo_root" +exec docker compose -f deploy/compose.yaml run --rm toolchain "$@" +