From e8695b72a606e368720b7f026e8e8386882d8c3b Mon Sep 17 00:00:00 2001 From: Claude Date: Tue, 17 Feb 2026 21:09:40 +0000 Subject: [PATCH] feat(coredeno): gRPC server with permission-gated I/O fortress MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Generated Go code from proto. Server implements CoreService with FileRead/FileWrite/FileList/FileDelete/StoreGet/StoreSet — every request checked against the calling module's manifest permissions. Co-Authored-By: Claude Opus 4.6 --- go.mod | 4 +- go.sum | 9 + pkg/coredeno/proto/coredeno.pb.go | 1420 ++++++++++++++++++++++++ pkg/coredeno/proto/coredeno_grpc.pb.go | 579 ++++++++++ pkg/coredeno/server.go | 131 +++ pkg/coredeno/server_test.go | 97 ++ 6 files changed, 2238 insertions(+), 2 deletions(-) create mode 100644 pkg/coredeno/proto/coredeno.pb.go create mode 100644 pkg/coredeno/proto/coredeno_grpc.pb.go create mode 100644 pkg/coredeno/server.go create mode 100644 pkg/coredeno/server_test.go diff --git a/go.mod b/go.mod index 5bd28cb..d8169da 100644 --- a/go.mod +++ b/go.mod @@ -112,8 +112,8 @@ require ( golang.org/x/tools v0.42.0 // indirect golang.org/x/xerrors v0.0.0-20240903120638-7835f813f4da // indirect gonum.org/v1/gonum v0.17.0 // indirect - google.golang.org/genproto/googleapis/rpc v0.0.0-20251111163417-95abcf5c77ba // indirect - google.golang.org/grpc v1.78.0 // indirect + google.golang.org/genproto/googleapis/rpc v0.0.0-20251202230838-ff82c1b0f217 // indirect + google.golang.org/grpc v1.79.1 // indirect google.golang.org/protobuf v1.36.11 // indirect modernc.org/libc v1.67.7 // indirect modernc.org/mathutil v1.7.1 // indirect diff --git a/go.sum b/go.sum index 61be66c..d043f23 100644 --- a/go.sum +++ b/go.sum @@ -247,14 +247,19 @@ go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y= go.opentelemetry.io/otel v1.38.0 h1:RkfdswUDRimDg0m2Az18RKOsnI8UDzppJAtj01/Ymk8= go.opentelemetry.io/otel v1.38.0/go.mod h1:zcmtmQ1+YmQM9wrNsTGV/q/uyusom3P8RxwExxkZhjM= +go.opentelemetry.io/otel v1.39.0 h1:8yPrr/S0ND9QEfTfdP9V+SiwT4E0G7Y5MO7p85nis48= go.opentelemetry.io/otel/metric v1.38.0 h1:Kl6lzIYGAh5M159u9NgiRkmoMKjvbsKtYRwgfrA6WpA= go.opentelemetry.io/otel/metric v1.38.0/go.mod h1:kB5n/QoRM8YwmUahxvI3bO34eVtQf2i4utNVLr9gEmI= +go.opentelemetry.io/otel/metric v1.39.0 h1:d1UzonvEZriVfpNKEVmHXbdf909uGTOQjA0HF0Ls5Q0= go.opentelemetry.io/otel/sdk v1.38.0 h1:l48sr5YbNf2hpCUj/FoGhW9yDkl+Ma+LrVl8qaM5b+E= go.opentelemetry.io/otel/sdk v1.38.0/go.mod h1:ghmNdGlVemJI3+ZB5iDEuk4bWA3GkTpW+DOoZMYBVVg= +go.opentelemetry.io/otel/sdk v1.39.0 h1:nMLYcjVsvdui1B/4FRkwjzoRVsMK8uL/cj0OyhKzt18= go.opentelemetry.io/otel/sdk/metric v1.38.0 h1:aSH66iL0aZqo//xXzQLYozmWrXxyFkBJ6qT5wthqPoM= go.opentelemetry.io/otel/sdk/metric v1.38.0/go.mod h1:dg9PBnW9XdQ1Hd6ZnRz689CbtrUp0wMMs9iPcgT9EZA= +go.opentelemetry.io/otel/sdk/metric v1.39.0 h1:cXMVVFVgsIf2YL6QkRF4Urbr/aMInf+2WKg+sEJTtB8= go.opentelemetry.io/otel/trace v1.38.0 h1:Fxk5bKrDZJUH+AMyyIXGcFAPah0oRcT+LuNtJrmcNLE= go.opentelemetry.io/otel/trace v1.38.0/go.mod h1:j1P9ivuFsTceSWe1oY+EeW3sc+Pp42sO++GHkg4wwhs= +go.opentelemetry.io/otel/trace v1.39.0 h1:2d2vfpEDmCJ5zVYz7ijaJdOF59xLomrvj7bjt6/qCJI= go.yaml.in/yaml/v3 v3.0.4 h1:tfq32ie2Jv2UxXFdLJdh3jXuOzWiL1fo0bu/FbuKpbc= go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= @@ -299,8 +304,12 @@ 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-20251111163417-95abcf5c77ba h1:UKgtfRM7Yh93Sya0Fo8ZzhDP4qBckrrxEr2oF5UIVb8= google.golang.org/genproto/googleapis/rpc v0.0.0-20251111163417-95abcf5c77ba/go.mod h1:7i2o+ce6H/6BluujYR+kqX3GKH+dChPTQU19wjRPiGk= +google.golang.org/genproto/googleapis/rpc v0.0.0-20251202230838-ff82c1b0f217 h1:gRkg/vSppuSQoDjxyiGfN4Upv/h/DQmIR10ZU8dh4Ww= +google.golang.org/genproto/googleapis/rpc v0.0.0-20251202230838-ff82c1b0f217/go.mod h1:7i2o+ce6H/6BluujYR+kqX3GKH+dChPTQU19wjRPiGk= google.golang.org/grpc v1.78.0 h1:K1XZG/yGDJnzMdd/uZHAkVqJE+xIDOcmdSFZkBUicNc= google.golang.org/grpc v1.78.0/go.mod h1:I47qjTo4OKbMkjA/aOOwxDIiPSBofUtQUI5EfpWvW7U= +google.golang.org/grpc v1.79.1 h1:zGhSi45ODB9/p3VAawt9a+O/MULLl9dpizzNNpq7flY= +google.golang.org/grpc v1.79.1/go.mod h1:KmT0Kjez+0dde/v2j9vzwoAScgEPx/Bw1CYChhHLrHQ= google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE= google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= diff --git a/pkg/coredeno/proto/coredeno.pb.go b/pkg/coredeno/proto/coredeno.pb.go new file mode 100644 index 0000000..2a04e7a --- /dev/null +++ b/pkg/coredeno/proto/coredeno.pb.go @@ -0,0 +1,1420 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.36.11 +// protoc v3.21.12 +// source: pkg/coredeno/proto/coredeno.proto + +package proto + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + 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 ModuleStatusResponse_Status int32 + +const ( + ModuleStatusResponse_UNKNOWN ModuleStatusResponse_Status = 0 + ModuleStatusResponse_LOADING ModuleStatusResponse_Status = 1 + ModuleStatusResponse_RUNNING ModuleStatusResponse_Status = 2 + ModuleStatusResponse_STOPPED ModuleStatusResponse_Status = 3 + ModuleStatusResponse_ERRORED ModuleStatusResponse_Status = 4 +) + +// Enum value maps for ModuleStatusResponse_Status. +var ( + ModuleStatusResponse_Status_name = map[int32]string{ + 0: "UNKNOWN", + 1: "LOADING", + 2: "RUNNING", + 3: "STOPPED", + 4: "ERRORED", + } + ModuleStatusResponse_Status_value = map[string]int32{ + "UNKNOWN": 0, + "LOADING": 1, + "RUNNING": 2, + "STOPPED": 3, + "ERRORED": 4, + } +) + +func (x ModuleStatusResponse_Status) Enum() *ModuleStatusResponse_Status { + p := new(ModuleStatusResponse_Status) + *p = x + return p +} + +func (x ModuleStatusResponse_Status) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (ModuleStatusResponse_Status) Descriptor() protoreflect.EnumDescriptor { + return file_pkg_coredeno_proto_coredeno_proto_enumTypes[0].Descriptor() +} + +func (ModuleStatusResponse_Status) Type() protoreflect.EnumType { + return &file_pkg_coredeno_proto_coredeno_proto_enumTypes[0] +} + +func (x ModuleStatusResponse_Status) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use ModuleStatusResponse_Status.Descriptor instead. +func (ModuleStatusResponse_Status) EnumDescriptor() ([]byte, []int) { + return file_pkg_coredeno_proto_coredeno_proto_rawDescGZIP(), []int{22, 0} +} + +type FileReadRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Path string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"` + ModuleCode string `protobuf:"bytes,2,opt,name=module_code,json=moduleCode,proto3" json:"module_code,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *FileReadRequest) Reset() { + *x = FileReadRequest{} + mi := &file_pkg_coredeno_proto_coredeno_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *FileReadRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*FileReadRequest) ProtoMessage() {} + +func (x *FileReadRequest) ProtoReflect() protoreflect.Message { + mi := &file_pkg_coredeno_proto_coredeno_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 FileReadRequest.ProtoReflect.Descriptor instead. +func (*FileReadRequest) Descriptor() ([]byte, []int) { + return file_pkg_coredeno_proto_coredeno_proto_rawDescGZIP(), []int{0} +} + +func (x *FileReadRequest) GetPath() string { + if x != nil { + return x.Path + } + return "" +} + +func (x *FileReadRequest) GetModuleCode() string { + if x != nil { + return x.ModuleCode + } + return "" +} + +type FileReadResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Content string `protobuf:"bytes,1,opt,name=content,proto3" json:"content,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *FileReadResponse) Reset() { + *x = FileReadResponse{} + mi := &file_pkg_coredeno_proto_coredeno_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *FileReadResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*FileReadResponse) ProtoMessage() {} + +func (x *FileReadResponse) ProtoReflect() protoreflect.Message { + mi := &file_pkg_coredeno_proto_coredeno_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 FileReadResponse.ProtoReflect.Descriptor instead. +func (*FileReadResponse) Descriptor() ([]byte, []int) { + return file_pkg_coredeno_proto_coredeno_proto_rawDescGZIP(), []int{1} +} + +func (x *FileReadResponse) GetContent() string { + if x != nil { + return x.Content + } + return "" +} + +type FileWriteRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Path string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"` + Content string `protobuf:"bytes,2,opt,name=content,proto3" json:"content,omitempty"` + ModuleCode string `protobuf:"bytes,3,opt,name=module_code,json=moduleCode,proto3" json:"module_code,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *FileWriteRequest) Reset() { + *x = FileWriteRequest{} + mi := &file_pkg_coredeno_proto_coredeno_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *FileWriteRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*FileWriteRequest) ProtoMessage() {} + +func (x *FileWriteRequest) ProtoReflect() protoreflect.Message { + mi := &file_pkg_coredeno_proto_coredeno_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 FileWriteRequest.ProtoReflect.Descriptor instead. +func (*FileWriteRequest) Descriptor() ([]byte, []int) { + return file_pkg_coredeno_proto_coredeno_proto_rawDescGZIP(), []int{2} +} + +func (x *FileWriteRequest) GetPath() string { + if x != nil { + return x.Path + } + return "" +} + +func (x *FileWriteRequest) GetContent() string { + if x != nil { + return x.Content + } + return "" +} + +func (x *FileWriteRequest) GetModuleCode() string { + if x != nil { + return x.ModuleCode + } + return "" +} + +type FileWriteResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Ok bool `protobuf:"varint,1,opt,name=ok,proto3" json:"ok,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *FileWriteResponse) Reset() { + *x = FileWriteResponse{} + mi := &file_pkg_coredeno_proto_coredeno_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *FileWriteResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*FileWriteResponse) ProtoMessage() {} + +func (x *FileWriteResponse) ProtoReflect() protoreflect.Message { + mi := &file_pkg_coredeno_proto_coredeno_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 FileWriteResponse.ProtoReflect.Descriptor instead. +func (*FileWriteResponse) Descriptor() ([]byte, []int) { + return file_pkg_coredeno_proto_coredeno_proto_rawDescGZIP(), []int{3} +} + +func (x *FileWriteResponse) GetOk() bool { + if x != nil { + return x.Ok + } + return false +} + +type FileListRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Path string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"` + ModuleCode string `protobuf:"bytes,2,opt,name=module_code,json=moduleCode,proto3" json:"module_code,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *FileListRequest) Reset() { + *x = FileListRequest{} + mi := &file_pkg_coredeno_proto_coredeno_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *FileListRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*FileListRequest) ProtoMessage() {} + +func (x *FileListRequest) ProtoReflect() protoreflect.Message { + mi := &file_pkg_coredeno_proto_coredeno_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 FileListRequest.ProtoReflect.Descriptor instead. +func (*FileListRequest) Descriptor() ([]byte, []int) { + return file_pkg_coredeno_proto_coredeno_proto_rawDescGZIP(), []int{4} +} + +func (x *FileListRequest) GetPath() string { + if x != nil { + return x.Path + } + return "" +} + +func (x *FileListRequest) GetModuleCode() string { + if x != nil { + return x.ModuleCode + } + return "" +} + +type FileListResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Entries []*FileEntry `protobuf:"bytes,1,rep,name=entries,proto3" json:"entries,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *FileListResponse) Reset() { + *x = FileListResponse{} + mi := &file_pkg_coredeno_proto_coredeno_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *FileListResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*FileListResponse) ProtoMessage() {} + +func (x *FileListResponse) ProtoReflect() protoreflect.Message { + mi := &file_pkg_coredeno_proto_coredeno_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 FileListResponse.ProtoReflect.Descriptor instead. +func (*FileListResponse) Descriptor() ([]byte, []int) { + return file_pkg_coredeno_proto_coredeno_proto_rawDescGZIP(), []int{5} +} + +func (x *FileListResponse) GetEntries() []*FileEntry { + if x != nil { + return x.Entries + } + return nil +} + +type FileEntry struct { + state protoimpl.MessageState `protogen:"open.v1"` + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + IsDir bool `protobuf:"varint,2,opt,name=is_dir,json=isDir,proto3" json:"is_dir,omitempty"` + Size int64 `protobuf:"varint,3,opt,name=size,proto3" json:"size,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *FileEntry) Reset() { + *x = FileEntry{} + mi := &file_pkg_coredeno_proto_coredeno_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *FileEntry) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*FileEntry) ProtoMessage() {} + +func (x *FileEntry) ProtoReflect() protoreflect.Message { + mi := &file_pkg_coredeno_proto_coredeno_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 FileEntry.ProtoReflect.Descriptor instead. +func (*FileEntry) Descriptor() ([]byte, []int) { + return file_pkg_coredeno_proto_coredeno_proto_rawDescGZIP(), []int{6} +} + +func (x *FileEntry) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *FileEntry) GetIsDir() bool { + if x != nil { + return x.IsDir + } + return false +} + +func (x *FileEntry) GetSize() int64 { + if x != nil { + return x.Size + } + return 0 +} + +type FileDeleteRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Path string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"` + ModuleCode string `protobuf:"bytes,2,opt,name=module_code,json=moduleCode,proto3" json:"module_code,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *FileDeleteRequest) Reset() { + *x = FileDeleteRequest{} + mi := &file_pkg_coredeno_proto_coredeno_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *FileDeleteRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*FileDeleteRequest) ProtoMessage() {} + +func (x *FileDeleteRequest) ProtoReflect() protoreflect.Message { + mi := &file_pkg_coredeno_proto_coredeno_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 FileDeleteRequest.ProtoReflect.Descriptor instead. +func (*FileDeleteRequest) Descriptor() ([]byte, []int) { + return file_pkg_coredeno_proto_coredeno_proto_rawDescGZIP(), []int{7} +} + +func (x *FileDeleteRequest) GetPath() string { + if x != nil { + return x.Path + } + return "" +} + +func (x *FileDeleteRequest) GetModuleCode() string { + if x != nil { + return x.ModuleCode + } + return "" +} + +type FileDeleteResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Ok bool `protobuf:"varint,1,opt,name=ok,proto3" json:"ok,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *FileDeleteResponse) Reset() { + *x = FileDeleteResponse{} + mi := &file_pkg_coredeno_proto_coredeno_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *FileDeleteResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*FileDeleteResponse) ProtoMessage() {} + +func (x *FileDeleteResponse) ProtoReflect() protoreflect.Message { + mi := &file_pkg_coredeno_proto_coredeno_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 FileDeleteResponse.ProtoReflect.Descriptor instead. +func (*FileDeleteResponse) Descriptor() ([]byte, []int) { + return file_pkg_coredeno_proto_coredeno_proto_rawDescGZIP(), []int{8} +} + +func (x *FileDeleteResponse) GetOk() bool { + if x != nil { + return x.Ok + } + return false +} + +type StoreGetRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Group string `protobuf:"bytes,1,opt,name=group,proto3" json:"group,omitempty"` + Key string `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *StoreGetRequest) Reset() { + *x = StoreGetRequest{} + mi := &file_pkg_coredeno_proto_coredeno_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *StoreGetRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*StoreGetRequest) ProtoMessage() {} + +func (x *StoreGetRequest) ProtoReflect() protoreflect.Message { + mi := &file_pkg_coredeno_proto_coredeno_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 StoreGetRequest.ProtoReflect.Descriptor instead. +func (*StoreGetRequest) Descriptor() ([]byte, []int) { + return file_pkg_coredeno_proto_coredeno_proto_rawDescGZIP(), []int{9} +} + +func (x *StoreGetRequest) GetGroup() string { + if x != nil { + return x.Group + } + return "" +} + +func (x *StoreGetRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +type StoreGetResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"` + Found bool `protobuf:"varint,2,opt,name=found,proto3" json:"found,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *StoreGetResponse) Reset() { + *x = StoreGetResponse{} + mi := &file_pkg_coredeno_proto_coredeno_proto_msgTypes[10] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *StoreGetResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*StoreGetResponse) ProtoMessage() {} + +func (x *StoreGetResponse) ProtoReflect() protoreflect.Message { + mi := &file_pkg_coredeno_proto_coredeno_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 StoreGetResponse.ProtoReflect.Descriptor instead. +func (*StoreGetResponse) Descriptor() ([]byte, []int) { + return file_pkg_coredeno_proto_coredeno_proto_rawDescGZIP(), []int{10} +} + +func (x *StoreGetResponse) GetValue() string { + if x != nil { + return x.Value + } + return "" +} + +func (x *StoreGetResponse) GetFound() bool { + if x != nil { + return x.Found + } + return false +} + +type StoreSetRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Group string `protobuf:"bytes,1,opt,name=group,proto3" json:"group,omitempty"` + Key string `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` + Value string `protobuf:"bytes,3,opt,name=value,proto3" json:"value,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *StoreSetRequest) Reset() { + *x = StoreSetRequest{} + mi := &file_pkg_coredeno_proto_coredeno_proto_msgTypes[11] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *StoreSetRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*StoreSetRequest) ProtoMessage() {} + +func (x *StoreSetRequest) ProtoReflect() protoreflect.Message { + mi := &file_pkg_coredeno_proto_coredeno_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 StoreSetRequest.ProtoReflect.Descriptor instead. +func (*StoreSetRequest) Descriptor() ([]byte, []int) { + return file_pkg_coredeno_proto_coredeno_proto_rawDescGZIP(), []int{11} +} + +func (x *StoreSetRequest) GetGroup() string { + if x != nil { + return x.Group + } + return "" +} + +func (x *StoreSetRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +func (x *StoreSetRequest) GetValue() string { + if x != nil { + return x.Value + } + return "" +} + +type StoreSetResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Ok bool `protobuf:"varint,1,opt,name=ok,proto3" json:"ok,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *StoreSetResponse) Reset() { + *x = StoreSetResponse{} + mi := &file_pkg_coredeno_proto_coredeno_proto_msgTypes[12] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *StoreSetResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*StoreSetResponse) ProtoMessage() {} + +func (x *StoreSetResponse) ProtoReflect() protoreflect.Message { + mi := &file_pkg_coredeno_proto_coredeno_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 StoreSetResponse.ProtoReflect.Descriptor instead. +func (*StoreSetResponse) Descriptor() ([]byte, []int) { + return file_pkg_coredeno_proto_coredeno_proto_rawDescGZIP(), []int{12} +} + +func (x *StoreSetResponse) GetOk() bool { + if x != nil { + return x.Ok + } + return false +} + +type ProcessStartRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Command string `protobuf:"bytes,1,opt,name=command,proto3" json:"command,omitempty"` + Args []string `protobuf:"bytes,2,rep,name=args,proto3" json:"args,omitempty"` + ModuleCode string `protobuf:"bytes,3,opt,name=module_code,json=moduleCode,proto3" json:"module_code,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ProcessStartRequest) Reset() { + *x = ProcessStartRequest{} + mi := &file_pkg_coredeno_proto_coredeno_proto_msgTypes[13] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ProcessStartRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ProcessStartRequest) ProtoMessage() {} + +func (x *ProcessStartRequest) ProtoReflect() protoreflect.Message { + mi := &file_pkg_coredeno_proto_coredeno_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 ProcessStartRequest.ProtoReflect.Descriptor instead. +func (*ProcessStartRequest) Descriptor() ([]byte, []int) { + return file_pkg_coredeno_proto_coredeno_proto_rawDescGZIP(), []int{13} +} + +func (x *ProcessStartRequest) GetCommand() string { + if x != nil { + return x.Command + } + return "" +} + +func (x *ProcessStartRequest) GetArgs() []string { + if x != nil { + return x.Args + } + return nil +} + +func (x *ProcessStartRequest) GetModuleCode() string { + if x != nil { + return x.ModuleCode + } + return "" +} + +type ProcessStartResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + ProcessId string `protobuf:"bytes,1,opt,name=process_id,json=processId,proto3" json:"process_id,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ProcessStartResponse) Reset() { + *x = ProcessStartResponse{} + mi := &file_pkg_coredeno_proto_coredeno_proto_msgTypes[14] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ProcessStartResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ProcessStartResponse) ProtoMessage() {} + +func (x *ProcessStartResponse) ProtoReflect() protoreflect.Message { + mi := &file_pkg_coredeno_proto_coredeno_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 ProcessStartResponse.ProtoReflect.Descriptor instead. +func (*ProcessStartResponse) Descriptor() ([]byte, []int) { + return file_pkg_coredeno_proto_coredeno_proto_rawDescGZIP(), []int{14} +} + +func (x *ProcessStartResponse) GetProcessId() string { + if x != nil { + return x.ProcessId + } + return "" +} + +type ProcessStopRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + ProcessId string `protobuf:"bytes,1,opt,name=process_id,json=processId,proto3" json:"process_id,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ProcessStopRequest) Reset() { + *x = ProcessStopRequest{} + mi := &file_pkg_coredeno_proto_coredeno_proto_msgTypes[15] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ProcessStopRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ProcessStopRequest) ProtoMessage() {} + +func (x *ProcessStopRequest) ProtoReflect() protoreflect.Message { + mi := &file_pkg_coredeno_proto_coredeno_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 ProcessStopRequest.ProtoReflect.Descriptor instead. +func (*ProcessStopRequest) Descriptor() ([]byte, []int) { + return file_pkg_coredeno_proto_coredeno_proto_rawDescGZIP(), []int{15} +} + +func (x *ProcessStopRequest) GetProcessId() string { + if x != nil { + return x.ProcessId + } + return "" +} + +type ProcessStopResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Ok bool `protobuf:"varint,1,opt,name=ok,proto3" json:"ok,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ProcessStopResponse) Reset() { + *x = ProcessStopResponse{} + mi := &file_pkg_coredeno_proto_coredeno_proto_msgTypes[16] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ProcessStopResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ProcessStopResponse) ProtoMessage() {} + +func (x *ProcessStopResponse) ProtoReflect() protoreflect.Message { + mi := &file_pkg_coredeno_proto_coredeno_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 ProcessStopResponse.ProtoReflect.Descriptor instead. +func (*ProcessStopResponse) Descriptor() ([]byte, []int) { + return file_pkg_coredeno_proto_coredeno_proto_rawDescGZIP(), []int{16} +} + +func (x *ProcessStopResponse) GetOk() bool { + if x != nil { + return x.Ok + } + return false +} + +type LoadModuleRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Code string `protobuf:"bytes,1,opt,name=code,proto3" json:"code,omitempty"` + EntryPoint string `protobuf:"bytes,2,opt,name=entry_point,json=entryPoint,proto3" json:"entry_point,omitempty"` + Permissions []string `protobuf:"bytes,3,rep,name=permissions,proto3" json:"permissions,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *LoadModuleRequest) Reset() { + *x = LoadModuleRequest{} + mi := &file_pkg_coredeno_proto_coredeno_proto_msgTypes[17] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *LoadModuleRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*LoadModuleRequest) ProtoMessage() {} + +func (x *LoadModuleRequest) ProtoReflect() protoreflect.Message { + mi := &file_pkg_coredeno_proto_coredeno_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 LoadModuleRequest.ProtoReflect.Descriptor instead. +func (*LoadModuleRequest) Descriptor() ([]byte, []int) { + return file_pkg_coredeno_proto_coredeno_proto_rawDescGZIP(), []int{17} +} + +func (x *LoadModuleRequest) GetCode() string { + if x != nil { + return x.Code + } + return "" +} + +func (x *LoadModuleRequest) GetEntryPoint() string { + if x != nil { + return x.EntryPoint + } + return "" +} + +func (x *LoadModuleRequest) GetPermissions() []string { + if x != nil { + return x.Permissions + } + return nil +} + +type LoadModuleResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Ok bool `protobuf:"varint,1,opt,name=ok,proto3" json:"ok,omitempty"` + Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *LoadModuleResponse) Reset() { + *x = LoadModuleResponse{} + mi := &file_pkg_coredeno_proto_coredeno_proto_msgTypes[18] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *LoadModuleResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*LoadModuleResponse) ProtoMessage() {} + +func (x *LoadModuleResponse) ProtoReflect() protoreflect.Message { + mi := &file_pkg_coredeno_proto_coredeno_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 LoadModuleResponse.ProtoReflect.Descriptor instead. +func (*LoadModuleResponse) Descriptor() ([]byte, []int) { + return file_pkg_coredeno_proto_coredeno_proto_rawDescGZIP(), []int{18} +} + +func (x *LoadModuleResponse) GetOk() bool { + if x != nil { + return x.Ok + } + return false +} + +func (x *LoadModuleResponse) GetError() string { + if x != nil { + return x.Error + } + return "" +} + +type UnloadModuleRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Code string `protobuf:"bytes,1,opt,name=code,proto3" json:"code,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *UnloadModuleRequest) Reset() { + *x = UnloadModuleRequest{} + mi := &file_pkg_coredeno_proto_coredeno_proto_msgTypes[19] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *UnloadModuleRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*UnloadModuleRequest) ProtoMessage() {} + +func (x *UnloadModuleRequest) ProtoReflect() protoreflect.Message { + mi := &file_pkg_coredeno_proto_coredeno_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 UnloadModuleRequest.ProtoReflect.Descriptor instead. +func (*UnloadModuleRequest) Descriptor() ([]byte, []int) { + return file_pkg_coredeno_proto_coredeno_proto_rawDescGZIP(), []int{19} +} + +func (x *UnloadModuleRequest) GetCode() string { + if x != nil { + return x.Code + } + return "" +} + +type UnloadModuleResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Ok bool `protobuf:"varint,1,opt,name=ok,proto3" json:"ok,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *UnloadModuleResponse) Reset() { + *x = UnloadModuleResponse{} + mi := &file_pkg_coredeno_proto_coredeno_proto_msgTypes[20] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *UnloadModuleResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*UnloadModuleResponse) ProtoMessage() {} + +func (x *UnloadModuleResponse) ProtoReflect() protoreflect.Message { + mi := &file_pkg_coredeno_proto_coredeno_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 UnloadModuleResponse.ProtoReflect.Descriptor instead. +func (*UnloadModuleResponse) Descriptor() ([]byte, []int) { + return file_pkg_coredeno_proto_coredeno_proto_rawDescGZIP(), []int{20} +} + +func (x *UnloadModuleResponse) GetOk() bool { + if x != nil { + return x.Ok + } + return false +} + +type ModuleStatusRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Code string `protobuf:"bytes,1,opt,name=code,proto3" json:"code,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ModuleStatusRequest) Reset() { + *x = ModuleStatusRequest{} + mi := &file_pkg_coredeno_proto_coredeno_proto_msgTypes[21] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ModuleStatusRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ModuleStatusRequest) ProtoMessage() {} + +func (x *ModuleStatusRequest) ProtoReflect() protoreflect.Message { + mi := &file_pkg_coredeno_proto_coredeno_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 ModuleStatusRequest.ProtoReflect.Descriptor instead. +func (*ModuleStatusRequest) Descriptor() ([]byte, []int) { + return file_pkg_coredeno_proto_coredeno_proto_rawDescGZIP(), []int{21} +} + +func (x *ModuleStatusRequest) GetCode() string { + if x != nil { + return x.Code + } + return "" +} + +type ModuleStatusResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Code string `protobuf:"bytes,1,opt,name=code,proto3" json:"code,omitempty"` + Status ModuleStatusResponse_Status `protobuf:"varint,2,opt,name=status,proto3,enum=coredeno.ModuleStatusResponse_Status" json:"status,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ModuleStatusResponse) Reset() { + *x = ModuleStatusResponse{} + mi := &file_pkg_coredeno_proto_coredeno_proto_msgTypes[22] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ModuleStatusResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ModuleStatusResponse) ProtoMessage() {} + +func (x *ModuleStatusResponse) ProtoReflect() protoreflect.Message { + mi := &file_pkg_coredeno_proto_coredeno_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 ModuleStatusResponse.ProtoReflect.Descriptor instead. +func (*ModuleStatusResponse) Descriptor() ([]byte, []int) { + return file_pkg_coredeno_proto_coredeno_proto_rawDescGZIP(), []int{22} +} + +func (x *ModuleStatusResponse) GetCode() string { + if x != nil { + return x.Code + } + return "" +} + +func (x *ModuleStatusResponse) GetStatus() ModuleStatusResponse_Status { + if x != nil { + return x.Status + } + return ModuleStatusResponse_UNKNOWN +} + +var File_pkg_coredeno_proto_coredeno_proto protoreflect.FileDescriptor + +const file_pkg_coredeno_proto_coredeno_proto_rawDesc = "" + + "\n" + + "!pkg/coredeno/proto/coredeno.proto\x12\bcoredeno\"F\n" + + "\x0fFileReadRequest\x12\x12\n" + + "\x04path\x18\x01 \x01(\tR\x04path\x12\x1f\n" + + "\vmodule_code\x18\x02 \x01(\tR\n" + + "moduleCode\",\n" + + "\x10FileReadResponse\x12\x18\n" + + "\acontent\x18\x01 \x01(\tR\acontent\"a\n" + + "\x10FileWriteRequest\x12\x12\n" + + "\x04path\x18\x01 \x01(\tR\x04path\x12\x18\n" + + "\acontent\x18\x02 \x01(\tR\acontent\x12\x1f\n" + + "\vmodule_code\x18\x03 \x01(\tR\n" + + "moduleCode\"#\n" + + "\x11FileWriteResponse\x12\x0e\n" + + "\x02ok\x18\x01 \x01(\bR\x02ok\"F\n" + + "\x0fFileListRequest\x12\x12\n" + + "\x04path\x18\x01 \x01(\tR\x04path\x12\x1f\n" + + "\vmodule_code\x18\x02 \x01(\tR\n" + + "moduleCode\"A\n" + + "\x10FileListResponse\x12-\n" + + "\aentries\x18\x01 \x03(\v2\x13.coredeno.FileEntryR\aentries\"J\n" + + "\tFileEntry\x12\x12\n" + + "\x04name\x18\x01 \x01(\tR\x04name\x12\x15\n" + + "\x06is_dir\x18\x02 \x01(\bR\x05isDir\x12\x12\n" + + "\x04size\x18\x03 \x01(\x03R\x04size\"H\n" + + "\x11FileDeleteRequest\x12\x12\n" + + "\x04path\x18\x01 \x01(\tR\x04path\x12\x1f\n" + + "\vmodule_code\x18\x02 \x01(\tR\n" + + "moduleCode\"$\n" + + "\x12FileDeleteResponse\x12\x0e\n" + + "\x02ok\x18\x01 \x01(\bR\x02ok\"9\n" + + "\x0fStoreGetRequest\x12\x14\n" + + "\x05group\x18\x01 \x01(\tR\x05group\x12\x10\n" + + "\x03key\x18\x02 \x01(\tR\x03key\">\n" + + "\x10StoreGetResponse\x12\x14\n" + + "\x05value\x18\x01 \x01(\tR\x05value\x12\x14\n" + + "\x05found\x18\x02 \x01(\bR\x05found\"O\n" + + "\x0fStoreSetRequest\x12\x14\n" + + "\x05group\x18\x01 \x01(\tR\x05group\x12\x10\n" + + "\x03key\x18\x02 \x01(\tR\x03key\x12\x14\n" + + "\x05value\x18\x03 \x01(\tR\x05value\"\"\n" + + "\x10StoreSetResponse\x12\x0e\n" + + "\x02ok\x18\x01 \x01(\bR\x02ok\"d\n" + + "\x13ProcessStartRequest\x12\x18\n" + + "\acommand\x18\x01 \x01(\tR\acommand\x12\x12\n" + + "\x04args\x18\x02 \x03(\tR\x04args\x12\x1f\n" + + "\vmodule_code\x18\x03 \x01(\tR\n" + + "moduleCode\"5\n" + + "\x14ProcessStartResponse\x12\x1d\n" + + "\n" + + "process_id\x18\x01 \x01(\tR\tprocessId\"3\n" + + "\x12ProcessStopRequest\x12\x1d\n" + + "\n" + + "process_id\x18\x01 \x01(\tR\tprocessId\"%\n" + + "\x13ProcessStopResponse\x12\x0e\n" + + "\x02ok\x18\x01 \x01(\bR\x02ok\"j\n" + + "\x11LoadModuleRequest\x12\x12\n" + + "\x04code\x18\x01 \x01(\tR\x04code\x12\x1f\n" + + "\ventry_point\x18\x02 \x01(\tR\n" + + "entryPoint\x12 \n" + + "\vpermissions\x18\x03 \x03(\tR\vpermissions\":\n" + + "\x12LoadModuleResponse\x12\x0e\n" + + "\x02ok\x18\x01 \x01(\bR\x02ok\x12\x14\n" + + "\x05error\x18\x02 \x01(\tR\x05error\")\n" + + "\x13UnloadModuleRequest\x12\x12\n" + + "\x04code\x18\x01 \x01(\tR\x04code\"&\n" + + "\x14UnloadModuleResponse\x12\x0e\n" + + "\x02ok\x18\x01 \x01(\bR\x02ok\")\n" + + "\x13ModuleStatusRequest\x12\x12\n" + + "\x04code\x18\x01 \x01(\tR\x04code\"\xb4\x01\n" + + "\x14ModuleStatusResponse\x12\x12\n" + + "\x04code\x18\x01 \x01(\tR\x04code\x12=\n" + + "\x06status\x18\x02 \x01(\x0e2%.coredeno.ModuleStatusResponse.StatusR\x06status\"I\n" + + "\x06Status\x12\v\n" + + "\aUNKNOWN\x10\x00\x12\v\n" + + "\aLOADING\x10\x01\x12\v\n" + + "\aRUNNING\x10\x02\x12\v\n" + + "\aSTOPPED\x10\x03\x12\v\n" + + "\aERRORED\x10\x042\xc3\x04\n" + + "\vCoreService\x12A\n" + + "\bFileRead\x12\x19.coredeno.FileReadRequest\x1a\x1a.coredeno.FileReadResponse\x12D\n" + + "\tFileWrite\x12\x1a.coredeno.FileWriteRequest\x1a\x1b.coredeno.FileWriteResponse\x12A\n" + + "\bFileList\x12\x19.coredeno.FileListRequest\x1a\x1a.coredeno.FileListResponse\x12G\n" + + "\n" + + "FileDelete\x12\x1b.coredeno.FileDeleteRequest\x1a\x1c.coredeno.FileDeleteResponse\x12A\n" + + "\bStoreGet\x12\x19.coredeno.StoreGetRequest\x1a\x1a.coredeno.StoreGetResponse\x12A\n" + + "\bStoreSet\x12\x19.coredeno.StoreSetRequest\x1a\x1a.coredeno.StoreSetResponse\x12M\n" + + "\fProcessStart\x12\x1d.coredeno.ProcessStartRequest\x1a\x1e.coredeno.ProcessStartResponse\x12J\n" + + "\vProcessStop\x12\x1c.coredeno.ProcessStopRequest\x1a\x1d.coredeno.ProcessStopResponse2\xf4\x01\n" + + "\vDenoService\x12G\n" + + "\n" + + "LoadModule\x12\x1b.coredeno.LoadModuleRequest\x1a\x1c.coredeno.LoadModuleResponse\x12M\n" + + "\fUnloadModule\x12\x1d.coredeno.UnloadModuleRequest\x1a\x1e.coredeno.UnloadModuleResponse\x12M\n" + + "\fModuleStatus\x12\x1d.coredeno.ModuleStatusRequest\x1a\x1e.coredeno.ModuleStatusResponseB*Z(forge.lthn.ai/core/go/pkg/coredeno/protob\x06proto3" + +var ( + file_pkg_coredeno_proto_coredeno_proto_rawDescOnce sync.Once + file_pkg_coredeno_proto_coredeno_proto_rawDescData []byte +) + +func file_pkg_coredeno_proto_coredeno_proto_rawDescGZIP() []byte { + file_pkg_coredeno_proto_coredeno_proto_rawDescOnce.Do(func() { + file_pkg_coredeno_proto_coredeno_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_pkg_coredeno_proto_coredeno_proto_rawDesc), len(file_pkg_coredeno_proto_coredeno_proto_rawDesc))) + }) + return file_pkg_coredeno_proto_coredeno_proto_rawDescData +} + +var file_pkg_coredeno_proto_coredeno_proto_enumTypes = make([]protoimpl.EnumInfo, 1) +var file_pkg_coredeno_proto_coredeno_proto_msgTypes = make([]protoimpl.MessageInfo, 23) +var file_pkg_coredeno_proto_coredeno_proto_goTypes = []any{ + (ModuleStatusResponse_Status)(0), // 0: coredeno.ModuleStatusResponse.Status + (*FileReadRequest)(nil), // 1: coredeno.FileReadRequest + (*FileReadResponse)(nil), // 2: coredeno.FileReadResponse + (*FileWriteRequest)(nil), // 3: coredeno.FileWriteRequest + (*FileWriteResponse)(nil), // 4: coredeno.FileWriteResponse + (*FileListRequest)(nil), // 5: coredeno.FileListRequest + (*FileListResponse)(nil), // 6: coredeno.FileListResponse + (*FileEntry)(nil), // 7: coredeno.FileEntry + (*FileDeleteRequest)(nil), // 8: coredeno.FileDeleteRequest + (*FileDeleteResponse)(nil), // 9: coredeno.FileDeleteResponse + (*StoreGetRequest)(nil), // 10: coredeno.StoreGetRequest + (*StoreGetResponse)(nil), // 11: coredeno.StoreGetResponse + (*StoreSetRequest)(nil), // 12: coredeno.StoreSetRequest + (*StoreSetResponse)(nil), // 13: coredeno.StoreSetResponse + (*ProcessStartRequest)(nil), // 14: coredeno.ProcessStartRequest + (*ProcessStartResponse)(nil), // 15: coredeno.ProcessStartResponse + (*ProcessStopRequest)(nil), // 16: coredeno.ProcessStopRequest + (*ProcessStopResponse)(nil), // 17: coredeno.ProcessStopResponse + (*LoadModuleRequest)(nil), // 18: coredeno.LoadModuleRequest + (*LoadModuleResponse)(nil), // 19: coredeno.LoadModuleResponse + (*UnloadModuleRequest)(nil), // 20: coredeno.UnloadModuleRequest + (*UnloadModuleResponse)(nil), // 21: coredeno.UnloadModuleResponse + (*ModuleStatusRequest)(nil), // 22: coredeno.ModuleStatusRequest + (*ModuleStatusResponse)(nil), // 23: coredeno.ModuleStatusResponse +} +var file_pkg_coredeno_proto_coredeno_proto_depIdxs = []int32{ + 7, // 0: coredeno.FileListResponse.entries:type_name -> coredeno.FileEntry + 0, // 1: coredeno.ModuleStatusResponse.status:type_name -> coredeno.ModuleStatusResponse.Status + 1, // 2: coredeno.CoreService.FileRead:input_type -> coredeno.FileReadRequest + 3, // 3: coredeno.CoreService.FileWrite:input_type -> coredeno.FileWriteRequest + 5, // 4: coredeno.CoreService.FileList:input_type -> coredeno.FileListRequest + 8, // 5: coredeno.CoreService.FileDelete:input_type -> coredeno.FileDeleteRequest + 10, // 6: coredeno.CoreService.StoreGet:input_type -> coredeno.StoreGetRequest + 12, // 7: coredeno.CoreService.StoreSet:input_type -> coredeno.StoreSetRequest + 14, // 8: coredeno.CoreService.ProcessStart:input_type -> coredeno.ProcessStartRequest + 16, // 9: coredeno.CoreService.ProcessStop:input_type -> coredeno.ProcessStopRequest + 18, // 10: coredeno.DenoService.LoadModule:input_type -> coredeno.LoadModuleRequest + 20, // 11: coredeno.DenoService.UnloadModule:input_type -> coredeno.UnloadModuleRequest + 22, // 12: coredeno.DenoService.ModuleStatus:input_type -> coredeno.ModuleStatusRequest + 2, // 13: coredeno.CoreService.FileRead:output_type -> coredeno.FileReadResponse + 4, // 14: coredeno.CoreService.FileWrite:output_type -> coredeno.FileWriteResponse + 6, // 15: coredeno.CoreService.FileList:output_type -> coredeno.FileListResponse + 9, // 16: coredeno.CoreService.FileDelete:output_type -> coredeno.FileDeleteResponse + 11, // 17: coredeno.CoreService.StoreGet:output_type -> coredeno.StoreGetResponse + 13, // 18: coredeno.CoreService.StoreSet:output_type -> coredeno.StoreSetResponse + 15, // 19: coredeno.CoreService.ProcessStart:output_type -> coredeno.ProcessStartResponse + 17, // 20: coredeno.CoreService.ProcessStop:output_type -> coredeno.ProcessStopResponse + 19, // 21: coredeno.DenoService.LoadModule:output_type -> coredeno.LoadModuleResponse + 21, // 22: coredeno.DenoService.UnloadModule:output_type -> coredeno.UnloadModuleResponse + 23, // 23: coredeno.DenoService.ModuleStatus:output_type -> coredeno.ModuleStatusResponse + 13, // [13:24] is the sub-list for method output_type + 2, // [2:13] is the sub-list for method input_type + 2, // [2:2] is the sub-list for extension type_name + 2, // [2:2] is the sub-list for extension extendee + 0, // [0:2] is the sub-list for field type_name +} + +func init() { file_pkg_coredeno_proto_coredeno_proto_init() } +func file_pkg_coredeno_proto_coredeno_proto_init() { + if File_pkg_coredeno_proto_coredeno_proto != nil { + return + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: unsafe.Slice(unsafe.StringData(file_pkg_coredeno_proto_coredeno_proto_rawDesc), len(file_pkg_coredeno_proto_coredeno_proto_rawDesc)), + NumEnums: 1, + NumMessages: 23, + NumExtensions: 0, + NumServices: 2, + }, + GoTypes: file_pkg_coredeno_proto_coredeno_proto_goTypes, + DependencyIndexes: file_pkg_coredeno_proto_coredeno_proto_depIdxs, + EnumInfos: file_pkg_coredeno_proto_coredeno_proto_enumTypes, + MessageInfos: file_pkg_coredeno_proto_coredeno_proto_msgTypes, + }.Build() + File_pkg_coredeno_proto_coredeno_proto = out.File + file_pkg_coredeno_proto_coredeno_proto_goTypes = nil + file_pkg_coredeno_proto_coredeno_proto_depIdxs = nil +} diff --git a/pkg/coredeno/proto/coredeno_grpc.pb.go b/pkg/coredeno/proto/coredeno_grpc.pb.go new file mode 100644 index 0000000..528f99c --- /dev/null +++ b/pkg/coredeno/proto/coredeno_grpc.pb.go @@ -0,0 +1,579 @@ +// Code generated by protoc-gen-go-grpc. DO NOT EDIT. +// versions: +// - protoc-gen-go-grpc v1.6.1 +// - protoc v3.21.12 +// source: pkg/coredeno/proto/coredeno.proto + +package proto + +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 ( + CoreService_FileRead_FullMethodName = "/coredeno.CoreService/FileRead" + CoreService_FileWrite_FullMethodName = "/coredeno.CoreService/FileWrite" + CoreService_FileList_FullMethodName = "/coredeno.CoreService/FileList" + CoreService_FileDelete_FullMethodName = "/coredeno.CoreService/FileDelete" + CoreService_StoreGet_FullMethodName = "/coredeno.CoreService/StoreGet" + CoreService_StoreSet_FullMethodName = "/coredeno.CoreService/StoreSet" + CoreService_ProcessStart_FullMethodName = "/coredeno.CoreService/ProcessStart" + CoreService_ProcessStop_FullMethodName = "/coredeno.CoreService/ProcessStop" +) + +// CoreServiceClient is the client API for CoreService 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. +// +// CoreService is implemented by CoreGO — Deno calls this for I/O. +type CoreServiceClient interface { + // Filesystem (gated by manifest permissions) + FileRead(ctx context.Context, in *FileReadRequest, opts ...grpc.CallOption) (*FileReadResponse, error) + FileWrite(ctx context.Context, in *FileWriteRequest, opts ...grpc.CallOption) (*FileWriteResponse, error) + FileList(ctx context.Context, in *FileListRequest, opts ...grpc.CallOption) (*FileListResponse, error) + FileDelete(ctx context.Context, in *FileDeleteRequest, opts ...grpc.CallOption) (*FileDeleteResponse, error) + // Object store + StoreGet(ctx context.Context, in *StoreGetRequest, opts ...grpc.CallOption) (*StoreGetResponse, error) + StoreSet(ctx context.Context, in *StoreSetRequest, opts ...grpc.CallOption) (*StoreSetResponse, error) + // Process management + ProcessStart(ctx context.Context, in *ProcessStartRequest, opts ...grpc.CallOption) (*ProcessStartResponse, error) + ProcessStop(ctx context.Context, in *ProcessStopRequest, opts ...grpc.CallOption) (*ProcessStopResponse, error) +} + +type coreServiceClient struct { + cc grpc.ClientConnInterface +} + +func NewCoreServiceClient(cc grpc.ClientConnInterface) CoreServiceClient { + return &coreServiceClient{cc} +} + +func (c *coreServiceClient) FileRead(ctx context.Context, in *FileReadRequest, opts ...grpc.CallOption) (*FileReadResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(FileReadResponse) + err := c.cc.Invoke(ctx, CoreService_FileRead_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *coreServiceClient) FileWrite(ctx context.Context, in *FileWriteRequest, opts ...grpc.CallOption) (*FileWriteResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(FileWriteResponse) + err := c.cc.Invoke(ctx, CoreService_FileWrite_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *coreServiceClient) FileList(ctx context.Context, in *FileListRequest, opts ...grpc.CallOption) (*FileListResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(FileListResponse) + err := c.cc.Invoke(ctx, CoreService_FileList_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *coreServiceClient) FileDelete(ctx context.Context, in *FileDeleteRequest, opts ...grpc.CallOption) (*FileDeleteResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(FileDeleteResponse) + err := c.cc.Invoke(ctx, CoreService_FileDelete_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *coreServiceClient) StoreGet(ctx context.Context, in *StoreGetRequest, opts ...grpc.CallOption) (*StoreGetResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(StoreGetResponse) + err := c.cc.Invoke(ctx, CoreService_StoreGet_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *coreServiceClient) StoreSet(ctx context.Context, in *StoreSetRequest, opts ...grpc.CallOption) (*StoreSetResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(StoreSetResponse) + err := c.cc.Invoke(ctx, CoreService_StoreSet_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *coreServiceClient) ProcessStart(ctx context.Context, in *ProcessStartRequest, opts ...grpc.CallOption) (*ProcessStartResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(ProcessStartResponse) + err := c.cc.Invoke(ctx, CoreService_ProcessStart_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *coreServiceClient) ProcessStop(ctx context.Context, in *ProcessStopRequest, opts ...grpc.CallOption) (*ProcessStopResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(ProcessStopResponse) + err := c.cc.Invoke(ctx, CoreService_ProcessStop_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +// CoreServiceServer is the server API for CoreService service. +// All implementations must embed UnimplementedCoreServiceServer +// for forward compatibility. +// +// CoreService is implemented by CoreGO — Deno calls this for I/O. +type CoreServiceServer interface { + // Filesystem (gated by manifest permissions) + FileRead(context.Context, *FileReadRequest) (*FileReadResponse, error) + FileWrite(context.Context, *FileWriteRequest) (*FileWriteResponse, error) + FileList(context.Context, *FileListRequest) (*FileListResponse, error) + FileDelete(context.Context, *FileDeleteRequest) (*FileDeleteResponse, error) + // Object store + StoreGet(context.Context, *StoreGetRequest) (*StoreGetResponse, error) + StoreSet(context.Context, *StoreSetRequest) (*StoreSetResponse, error) + // Process management + ProcessStart(context.Context, *ProcessStartRequest) (*ProcessStartResponse, error) + ProcessStop(context.Context, *ProcessStopRequest) (*ProcessStopResponse, error) + mustEmbedUnimplementedCoreServiceServer() +} + +// UnimplementedCoreServiceServer 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 UnimplementedCoreServiceServer struct{} + +func (UnimplementedCoreServiceServer) FileRead(context.Context, *FileReadRequest) (*FileReadResponse, error) { + return nil, status.Error(codes.Unimplemented, "method FileRead not implemented") +} +func (UnimplementedCoreServiceServer) FileWrite(context.Context, *FileWriteRequest) (*FileWriteResponse, error) { + return nil, status.Error(codes.Unimplemented, "method FileWrite not implemented") +} +func (UnimplementedCoreServiceServer) FileList(context.Context, *FileListRequest) (*FileListResponse, error) { + return nil, status.Error(codes.Unimplemented, "method FileList not implemented") +} +func (UnimplementedCoreServiceServer) FileDelete(context.Context, *FileDeleteRequest) (*FileDeleteResponse, error) { + return nil, status.Error(codes.Unimplemented, "method FileDelete not implemented") +} +func (UnimplementedCoreServiceServer) StoreGet(context.Context, *StoreGetRequest) (*StoreGetResponse, error) { + return nil, status.Error(codes.Unimplemented, "method StoreGet not implemented") +} +func (UnimplementedCoreServiceServer) StoreSet(context.Context, *StoreSetRequest) (*StoreSetResponse, error) { + return nil, status.Error(codes.Unimplemented, "method StoreSet not implemented") +} +func (UnimplementedCoreServiceServer) ProcessStart(context.Context, *ProcessStartRequest) (*ProcessStartResponse, error) { + return nil, status.Error(codes.Unimplemented, "method ProcessStart not implemented") +} +func (UnimplementedCoreServiceServer) ProcessStop(context.Context, *ProcessStopRequest) (*ProcessStopResponse, error) { + return nil, status.Error(codes.Unimplemented, "method ProcessStop not implemented") +} +func (UnimplementedCoreServiceServer) mustEmbedUnimplementedCoreServiceServer() {} +func (UnimplementedCoreServiceServer) testEmbeddedByValue() {} + +// UnsafeCoreServiceServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to CoreServiceServer will +// result in compilation errors. +type UnsafeCoreServiceServer interface { + mustEmbedUnimplementedCoreServiceServer() +} + +func RegisterCoreServiceServer(s grpc.ServiceRegistrar, srv CoreServiceServer) { + // If the following call panics, it indicates UnimplementedCoreServiceServer 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(&CoreService_ServiceDesc, srv) +} + +func _CoreService_FileRead_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(FileReadRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CoreServiceServer).FileRead(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: CoreService_FileRead_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CoreServiceServer).FileRead(ctx, req.(*FileReadRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _CoreService_FileWrite_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(FileWriteRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CoreServiceServer).FileWrite(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: CoreService_FileWrite_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CoreServiceServer).FileWrite(ctx, req.(*FileWriteRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _CoreService_FileList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(FileListRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CoreServiceServer).FileList(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: CoreService_FileList_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CoreServiceServer).FileList(ctx, req.(*FileListRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _CoreService_FileDelete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(FileDeleteRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CoreServiceServer).FileDelete(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: CoreService_FileDelete_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CoreServiceServer).FileDelete(ctx, req.(*FileDeleteRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _CoreService_StoreGet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(StoreGetRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CoreServiceServer).StoreGet(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: CoreService_StoreGet_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CoreServiceServer).StoreGet(ctx, req.(*StoreGetRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _CoreService_StoreSet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(StoreSetRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CoreServiceServer).StoreSet(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: CoreService_StoreSet_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CoreServiceServer).StoreSet(ctx, req.(*StoreSetRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _CoreService_ProcessStart_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ProcessStartRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CoreServiceServer).ProcessStart(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: CoreService_ProcessStart_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CoreServiceServer).ProcessStart(ctx, req.(*ProcessStartRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _CoreService_ProcessStop_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ProcessStopRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(CoreServiceServer).ProcessStop(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: CoreService_ProcessStop_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(CoreServiceServer).ProcessStop(ctx, req.(*ProcessStopRequest)) + } + return interceptor(ctx, in, info, handler) +} + +// CoreService_ServiceDesc is the grpc.ServiceDesc for CoreService service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +var CoreService_ServiceDesc = grpc.ServiceDesc{ + ServiceName: "coredeno.CoreService", + HandlerType: (*CoreServiceServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "FileRead", + Handler: _CoreService_FileRead_Handler, + }, + { + MethodName: "FileWrite", + Handler: _CoreService_FileWrite_Handler, + }, + { + MethodName: "FileList", + Handler: _CoreService_FileList_Handler, + }, + { + MethodName: "FileDelete", + Handler: _CoreService_FileDelete_Handler, + }, + { + MethodName: "StoreGet", + Handler: _CoreService_StoreGet_Handler, + }, + { + MethodName: "StoreSet", + Handler: _CoreService_StoreSet_Handler, + }, + { + MethodName: "ProcessStart", + Handler: _CoreService_ProcessStart_Handler, + }, + { + MethodName: "ProcessStop", + Handler: _CoreService_ProcessStop_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "pkg/coredeno/proto/coredeno.proto", +} + +const ( + DenoService_LoadModule_FullMethodName = "/coredeno.DenoService/LoadModule" + DenoService_UnloadModule_FullMethodName = "/coredeno.DenoService/UnloadModule" + DenoService_ModuleStatus_FullMethodName = "/coredeno.DenoService/ModuleStatus" +) + +// DenoServiceClient is the client API for DenoService 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. +// +// DenoService is implemented by CoreDeno — Go calls this for module lifecycle. +type DenoServiceClient interface { + LoadModule(ctx context.Context, in *LoadModuleRequest, opts ...grpc.CallOption) (*LoadModuleResponse, error) + UnloadModule(ctx context.Context, in *UnloadModuleRequest, opts ...grpc.CallOption) (*UnloadModuleResponse, error) + ModuleStatus(ctx context.Context, in *ModuleStatusRequest, opts ...grpc.CallOption) (*ModuleStatusResponse, error) +} + +type denoServiceClient struct { + cc grpc.ClientConnInterface +} + +func NewDenoServiceClient(cc grpc.ClientConnInterface) DenoServiceClient { + return &denoServiceClient{cc} +} + +func (c *denoServiceClient) LoadModule(ctx context.Context, in *LoadModuleRequest, opts ...grpc.CallOption) (*LoadModuleResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(LoadModuleResponse) + err := c.cc.Invoke(ctx, DenoService_LoadModule_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *denoServiceClient) UnloadModule(ctx context.Context, in *UnloadModuleRequest, opts ...grpc.CallOption) (*UnloadModuleResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(UnloadModuleResponse) + err := c.cc.Invoke(ctx, DenoService_UnloadModule_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *denoServiceClient) ModuleStatus(ctx context.Context, in *ModuleStatusRequest, opts ...grpc.CallOption) (*ModuleStatusResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(ModuleStatusResponse) + err := c.cc.Invoke(ctx, DenoService_ModuleStatus_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +// DenoServiceServer is the server API for DenoService service. +// All implementations must embed UnimplementedDenoServiceServer +// for forward compatibility. +// +// DenoService is implemented by CoreDeno — Go calls this for module lifecycle. +type DenoServiceServer interface { + LoadModule(context.Context, *LoadModuleRequest) (*LoadModuleResponse, error) + UnloadModule(context.Context, *UnloadModuleRequest) (*UnloadModuleResponse, error) + ModuleStatus(context.Context, *ModuleStatusRequest) (*ModuleStatusResponse, error) + mustEmbedUnimplementedDenoServiceServer() +} + +// UnimplementedDenoServiceServer 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 UnimplementedDenoServiceServer struct{} + +func (UnimplementedDenoServiceServer) LoadModule(context.Context, *LoadModuleRequest) (*LoadModuleResponse, error) { + return nil, status.Error(codes.Unimplemented, "method LoadModule not implemented") +} +func (UnimplementedDenoServiceServer) UnloadModule(context.Context, *UnloadModuleRequest) (*UnloadModuleResponse, error) { + return nil, status.Error(codes.Unimplemented, "method UnloadModule not implemented") +} +func (UnimplementedDenoServiceServer) ModuleStatus(context.Context, *ModuleStatusRequest) (*ModuleStatusResponse, error) { + return nil, status.Error(codes.Unimplemented, "method ModuleStatus not implemented") +} +func (UnimplementedDenoServiceServer) mustEmbedUnimplementedDenoServiceServer() {} +func (UnimplementedDenoServiceServer) testEmbeddedByValue() {} + +// UnsafeDenoServiceServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to DenoServiceServer will +// result in compilation errors. +type UnsafeDenoServiceServer interface { + mustEmbedUnimplementedDenoServiceServer() +} + +func RegisterDenoServiceServer(s grpc.ServiceRegistrar, srv DenoServiceServer) { + // If the following call panics, it indicates UnimplementedDenoServiceServer 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(&DenoService_ServiceDesc, srv) +} + +func _DenoService_LoadModule_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(LoadModuleRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DenoServiceServer).LoadModule(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: DenoService_LoadModule_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DenoServiceServer).LoadModule(ctx, req.(*LoadModuleRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _DenoService_UnloadModule_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(UnloadModuleRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DenoServiceServer).UnloadModule(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: DenoService_UnloadModule_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DenoServiceServer).UnloadModule(ctx, req.(*UnloadModuleRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _DenoService_ModuleStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ModuleStatusRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DenoServiceServer).ModuleStatus(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: DenoService_ModuleStatus_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DenoServiceServer).ModuleStatus(ctx, req.(*ModuleStatusRequest)) + } + return interceptor(ctx, in, info, handler) +} + +// DenoService_ServiceDesc is the grpc.ServiceDesc for DenoService service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +var DenoService_ServiceDesc = grpc.ServiceDesc{ + ServiceName: "coredeno.DenoService", + HandlerType: (*DenoServiceServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "LoadModule", + Handler: _DenoService_LoadModule_Handler, + }, + { + MethodName: "UnloadModule", + Handler: _DenoService_UnloadModule_Handler, + }, + { + MethodName: "ModuleStatus", + Handler: _DenoService_ModuleStatus_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "pkg/coredeno/proto/coredeno.proto", +} diff --git a/pkg/coredeno/server.go b/pkg/coredeno/server.go new file mode 100644 index 0000000..31395a1 --- /dev/null +++ b/pkg/coredeno/server.go @@ -0,0 +1,131 @@ +package coredeno + +import ( + "context" + "fmt" + + pb "forge.lthn.ai/core/go/pkg/coredeno/proto" + "forge.lthn.ai/core/go/pkg/io" + "forge.lthn.ai/core/go/pkg/manifest" + "forge.lthn.ai/core/go/pkg/store" +) + +// Server implements the CoreService gRPC interface with permission gating. +// Every I/O request is checked against the calling module's declared permissions. +type Server struct { + pb.UnimplementedCoreServiceServer + medium io.Medium + store *store.Store + manifests map[string]*manifest.Manifest +} + +// NewServer creates a CoreService server backed by the given Medium and Store. +func NewServer(medium io.Medium, st *store.Store) *Server { + return &Server{ + medium: medium, + store: st, + manifests: make(map[string]*manifest.Manifest), + } +} + +// RegisterModule adds a module's manifest to the permission registry. +func (s *Server) RegisterModule(m *manifest.Manifest) { + s.manifests[m.Code] = m +} + +// getManifest looks up a module and returns an error if unknown. +func (s *Server) getManifest(code string) (*manifest.Manifest, error) { + m, ok := s.manifests[code] + if !ok { + return nil, fmt.Errorf("unknown module: %s", code) + } + return m, nil +} + +// FileRead implements CoreService.FileRead with permission gating. +func (s *Server) FileRead(_ context.Context, req *pb.FileReadRequest) (*pb.FileReadResponse, error) { + m, err := s.getManifest(req.ModuleCode) + if err != nil { + return nil, err + } + if !CheckPath(req.Path, m.Permissions.Read) { + return nil, fmt.Errorf("permission denied: %s cannot read %s", req.ModuleCode, req.Path) + } + content, err := s.medium.Read(req.Path) + if err != nil { + return nil, err + } + return &pb.FileReadResponse{Content: content}, nil +} + +// FileWrite implements CoreService.FileWrite with permission gating. +func (s *Server) FileWrite(_ context.Context, req *pb.FileWriteRequest) (*pb.FileWriteResponse, error) { + m, err := s.getManifest(req.ModuleCode) + if err != nil { + return nil, err + } + if !CheckPath(req.Path, m.Permissions.Write) { + return nil, fmt.Errorf("permission denied: %s cannot write %s", req.ModuleCode, req.Path) + } + if err := s.medium.Write(req.Path, req.Content); err != nil { + return nil, err + } + return &pb.FileWriteResponse{Ok: true}, nil +} + +// FileList implements CoreService.FileList with permission gating. +func (s *Server) FileList(_ context.Context, req *pb.FileListRequest) (*pb.FileListResponse, error) { + m, err := s.getManifest(req.ModuleCode) + if err != nil { + return nil, err + } + if !CheckPath(req.Path, m.Permissions.Read) { + return nil, fmt.Errorf("permission denied: %s cannot list %s", req.ModuleCode, req.Path) + } + entries, err := s.medium.List(req.Path) + if err != nil { + return nil, err + } + var pbEntries []*pb.FileEntry + for _, e := range entries { + info, _ := e.Info() + pbEntries = append(pbEntries, &pb.FileEntry{ + Name: e.Name(), + IsDir: e.IsDir(), + Size: info.Size(), + }) + } + return &pb.FileListResponse{Entries: pbEntries}, nil +} + +// FileDelete implements CoreService.FileDelete with permission gating. +func (s *Server) FileDelete(_ context.Context, req *pb.FileDeleteRequest) (*pb.FileDeleteResponse, error) { + m, err := s.getManifest(req.ModuleCode) + if err != nil { + return nil, err + } + if !CheckPath(req.Path, m.Permissions.Write) { + return nil, fmt.Errorf("permission denied: %s cannot delete %s", req.ModuleCode, req.Path) + } + if err := s.medium.Delete(req.Path); err != nil { + return nil, err + } + return &pb.FileDeleteResponse{Ok: true}, nil +} + +// StoreGet implements CoreService.StoreGet. +func (s *Server) StoreGet(_ context.Context, req *pb.StoreGetRequest) (*pb.StoreGetResponse, error) { + val, err := s.store.Get(req.Group, req.Key) + if err != nil { + return &pb.StoreGetResponse{Found: false}, nil + } + return &pb.StoreGetResponse{Value: val, Found: true}, nil +} + +// StoreSet implements CoreService.StoreSet. +func (s *Server) StoreSet(_ context.Context, req *pb.StoreSetRequest) (*pb.StoreSetResponse, error) { + if err := s.store.Set(req.Group, req.Key, req.Value); err != nil { + return nil, err + } + return &pb.StoreSetResponse{Ok: true}, nil +} diff --git a/pkg/coredeno/server_test.go b/pkg/coredeno/server_test.go new file mode 100644 index 0000000..6438f33 --- /dev/null +++ b/pkg/coredeno/server_test.go @@ -0,0 +1,97 @@ +package coredeno + +import ( + "context" + "testing" + + "forge.lthn.ai/core/go/pkg/io" + "forge.lthn.ai/core/go/pkg/manifest" + pb "forge.lthn.ai/core/go/pkg/coredeno/proto" + "forge.lthn.ai/core/go/pkg/store" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func newTestServer(t *testing.T) *Server { + t.Helper() + medium := io.NewMockMedium() + medium.Files["./data/test.txt"] = "hello" + st, err := store.New(":memory:") + require.NoError(t, err) + t.Cleanup(func() { st.Close() }) + + srv := NewServer(medium, st) + srv.RegisterModule(&manifest.Manifest{ + Code: "test-mod", + Permissions: manifest.Permissions{ + Read: []string{"./data/"}, + Write: []string{"./data/"}, + }, + }) + return srv +} + +func TestFileRead_Good(t *testing.T) { + srv := newTestServer(t) + resp, err := srv.FileRead(context.Background(), &pb.FileReadRequest{ + Path: "./data/test.txt", ModuleCode: "test-mod", + }) + require.NoError(t, err) + assert.Equal(t, "hello", resp.Content) +} + +func TestFileRead_Bad_PermissionDenied(t *testing.T) { + srv := newTestServer(t) + _, err := srv.FileRead(context.Background(), &pb.FileReadRequest{ + Path: "./secrets/key.pem", ModuleCode: "test-mod", + }) + assert.Error(t, err) + assert.Contains(t, err.Error(), "permission denied") +} + +func TestFileRead_Bad_UnknownModule(t *testing.T) { + srv := newTestServer(t) + _, err := srv.FileRead(context.Background(), &pb.FileReadRequest{ + Path: "./data/test.txt", ModuleCode: "unknown", + }) + assert.Error(t, err) + assert.Contains(t, err.Error(), "unknown module") +} + +func TestFileWrite_Good(t *testing.T) { + srv := newTestServer(t) + resp, err := srv.FileWrite(context.Background(), &pb.FileWriteRequest{ + Path: "./data/new.txt", Content: "world", ModuleCode: "test-mod", + }) + require.NoError(t, err) + assert.True(t, resp.Ok) +} + +func TestFileWrite_Bad_PermissionDenied(t *testing.T) { + srv := newTestServer(t) + _, err := srv.FileWrite(context.Background(), &pb.FileWriteRequest{ + Path: "./secrets/bad.txt", Content: "nope", ModuleCode: "test-mod", + }) + assert.Error(t, err) + assert.Contains(t, err.Error(), "permission denied") +} + +func TestStoreGetSet_Good(t *testing.T) { + srv := newTestServer(t) + ctx := context.Background() + + _, err := srv.StoreSet(ctx, &pb.StoreSetRequest{Group: "cfg", Key: "theme", Value: "dark"}) + require.NoError(t, err) + + resp, err := srv.StoreGet(ctx, &pb.StoreGetRequest{Group: "cfg", Key: "theme"}) + require.NoError(t, err) + assert.True(t, resp.Found) + assert.Equal(t, "dark", resp.Value) +} + +func TestStoreGet_Good_NotFound(t *testing.T) { + srv := newTestServer(t) + resp, err := srv.StoreGet(context.Background(), &pb.StoreGetRequest{Group: "cfg", Key: "missing"}) + require.NoError(t, err) + assert.False(t, resp.Found) +}