feat(deploy): single-origin path-based deployment + project site
Serve the whole stack behind one host: site at /, game UI at /game/, gateway REST at /api + /healthz, Connect at /rpc (prefix stripped by the edge Caddy). The built artifact is domain-agnostic — the UI talks to the gateway same-origin via relative URLs, so the same bundle runs under any host with no rebuild and with CORS disabled. - Rename the Connect proto service galaxy.gateway.v1.EdgeGateway -> edge.v1.Gateway; regenerate Go + TS; public path /rpc/edge.v1.Gateway. - Move the game UI under base path /game (env BASE_PATH); make the manifest, service-worker scope, WASM loader, and all navigation base-aware via a withBase helper. - Relative API + /rpc Connect prefix; Vite dev proxy mirrors the strip. - Rewrite the edge Caddy (dev + prod) for path-based routing; empty CORS allow-lists (same-origin); single host. - New VitePress project site (site/): i18n en/ru with switcher, LaTeX math, minimal monospace theme; built and served at /. - dev-deploy compose/Makefile + CI (dev-deploy, prod-build, new site-build) build and seed the site; probes hit /, /game/, /healthz. - Sync docs (ARCHITECTURE, gateway README/openapi, dev-deploy & local-dev READMEs, CLAUDE.md, ui/PLAN). Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
This commit is contained in:
Ilia Denisov
+48
-48
@@ -2,9 +2,9 @@
|
||||
// versions:
|
||||
// protoc-gen-go v1.36.11
|
||||
// protoc (unknown)
|
||||
// source: galaxy/gateway/v1/edge_gateway.proto
|
||||
// source: edge/v1/edge_gateway.proto
|
||||
|
||||
package gatewayv1
|
||||
package edgev1
|
||||
|
||||
import (
|
||||
_ "buf.build/gen/go/bufbuild/protovalidate/protocolbuffers/go/buf/validate"
|
||||
@@ -42,7 +42,7 @@ type ExecuteCommandRequest struct {
|
||||
|
||||
func (x *ExecuteCommandRequest) Reset() {
|
||||
*x = ExecuteCommandRequest{}
|
||||
mi := &file_galaxy_gateway_v1_edge_gateway_proto_msgTypes[0]
|
||||
mi := &file_edge_v1_edge_gateway_proto_msgTypes[0]
|
||||
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
||||
ms.StoreMessageInfo(mi)
|
||||
}
|
||||
@@ -54,7 +54,7 @@ func (x *ExecuteCommandRequest) String() string {
|
||||
func (*ExecuteCommandRequest) ProtoMessage() {}
|
||||
|
||||
func (x *ExecuteCommandRequest) ProtoReflect() protoreflect.Message {
|
||||
mi := &file_galaxy_gateway_v1_edge_gateway_proto_msgTypes[0]
|
||||
mi := &file_edge_v1_edge_gateway_proto_msgTypes[0]
|
||||
if x != nil {
|
||||
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
||||
if ms.LoadMessageInfo() == nil {
|
||||
@@ -67,7 +67,7 @@ func (x *ExecuteCommandRequest) ProtoReflect() protoreflect.Message {
|
||||
|
||||
// Deprecated: Use ExecuteCommandRequest.ProtoReflect.Descriptor instead.
|
||||
func (*ExecuteCommandRequest) Descriptor() ([]byte, []int) {
|
||||
return file_galaxy_gateway_v1_edge_gateway_proto_rawDescGZIP(), []int{0}
|
||||
return file_edge_v1_edge_gateway_proto_rawDescGZIP(), []int{0}
|
||||
}
|
||||
|
||||
func (x *ExecuteCommandRequest) GetProtocolVersion() string {
|
||||
@@ -148,7 +148,7 @@ type ExecuteCommandResponse struct {
|
||||
|
||||
func (x *ExecuteCommandResponse) Reset() {
|
||||
*x = ExecuteCommandResponse{}
|
||||
mi := &file_galaxy_gateway_v1_edge_gateway_proto_msgTypes[1]
|
||||
mi := &file_edge_v1_edge_gateway_proto_msgTypes[1]
|
||||
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
||||
ms.StoreMessageInfo(mi)
|
||||
}
|
||||
@@ -160,7 +160,7 @@ func (x *ExecuteCommandResponse) String() string {
|
||||
func (*ExecuteCommandResponse) ProtoMessage() {}
|
||||
|
||||
func (x *ExecuteCommandResponse) ProtoReflect() protoreflect.Message {
|
||||
mi := &file_galaxy_gateway_v1_edge_gateway_proto_msgTypes[1]
|
||||
mi := &file_edge_v1_edge_gateway_proto_msgTypes[1]
|
||||
if x != nil {
|
||||
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
||||
if ms.LoadMessageInfo() == nil {
|
||||
@@ -173,7 +173,7 @@ func (x *ExecuteCommandResponse) ProtoReflect() protoreflect.Message {
|
||||
|
||||
// Deprecated: Use ExecuteCommandResponse.ProtoReflect.Descriptor instead.
|
||||
func (*ExecuteCommandResponse) Descriptor() ([]byte, []int) {
|
||||
return file_galaxy_gateway_v1_edge_gateway_proto_rawDescGZIP(), []int{1}
|
||||
return file_edge_v1_edge_gateway_proto_rawDescGZIP(), []int{1}
|
||||
}
|
||||
|
||||
func (x *ExecuteCommandResponse) GetProtocolVersion() string {
|
||||
@@ -246,7 +246,7 @@ type SubscribeEventsRequest struct {
|
||||
|
||||
func (x *SubscribeEventsRequest) Reset() {
|
||||
*x = SubscribeEventsRequest{}
|
||||
mi := &file_galaxy_gateway_v1_edge_gateway_proto_msgTypes[2]
|
||||
mi := &file_edge_v1_edge_gateway_proto_msgTypes[2]
|
||||
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
||||
ms.StoreMessageInfo(mi)
|
||||
}
|
||||
@@ -258,7 +258,7 @@ func (x *SubscribeEventsRequest) String() string {
|
||||
func (*SubscribeEventsRequest) ProtoMessage() {}
|
||||
|
||||
func (x *SubscribeEventsRequest) ProtoReflect() protoreflect.Message {
|
||||
mi := &file_galaxy_gateway_v1_edge_gateway_proto_msgTypes[2]
|
||||
mi := &file_edge_v1_edge_gateway_proto_msgTypes[2]
|
||||
if x != nil {
|
||||
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
||||
if ms.LoadMessageInfo() == nil {
|
||||
@@ -271,7 +271,7 @@ func (x *SubscribeEventsRequest) ProtoReflect() protoreflect.Message {
|
||||
|
||||
// Deprecated: Use SubscribeEventsRequest.ProtoReflect.Descriptor instead.
|
||||
func (*SubscribeEventsRequest) Descriptor() ([]byte, []int) {
|
||||
return file_galaxy_gateway_v1_edge_gateway_proto_rawDescGZIP(), []int{2}
|
||||
return file_edge_v1_edge_gateway_proto_rawDescGZIP(), []int{2}
|
||||
}
|
||||
|
||||
func (x *SubscribeEventsRequest) GetProtocolVersion() string {
|
||||
@@ -353,7 +353,7 @@ type GatewayEvent struct {
|
||||
|
||||
func (x *GatewayEvent) Reset() {
|
||||
*x = GatewayEvent{}
|
||||
mi := &file_galaxy_gateway_v1_edge_gateway_proto_msgTypes[3]
|
||||
mi := &file_edge_v1_edge_gateway_proto_msgTypes[3]
|
||||
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
||||
ms.StoreMessageInfo(mi)
|
||||
}
|
||||
@@ -365,7 +365,7 @@ func (x *GatewayEvent) String() string {
|
||||
func (*GatewayEvent) ProtoMessage() {}
|
||||
|
||||
func (x *GatewayEvent) ProtoReflect() protoreflect.Message {
|
||||
mi := &file_galaxy_gateway_v1_edge_gateway_proto_msgTypes[3]
|
||||
mi := &file_edge_v1_edge_gateway_proto_msgTypes[3]
|
||||
if x != nil {
|
||||
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
|
||||
if ms.LoadMessageInfo() == nil {
|
||||
@@ -378,7 +378,7 @@ func (x *GatewayEvent) ProtoReflect() protoreflect.Message {
|
||||
|
||||
// Deprecated: Use GatewayEvent.ProtoReflect.Descriptor instead.
|
||||
func (*GatewayEvent) Descriptor() ([]byte, []int) {
|
||||
return file_galaxy_gateway_v1_edge_gateway_proto_rawDescGZIP(), []int{3}
|
||||
return file_edge_v1_edge_gateway_proto_rawDescGZIP(), []int{3}
|
||||
}
|
||||
|
||||
func (x *GatewayEvent) GetEventType() string {
|
||||
@@ -437,11 +437,11 @@ func (x *GatewayEvent) GetTraceId() string {
|
||||
return ""
|
||||
}
|
||||
|
||||
var File_galaxy_gateway_v1_edge_gateway_proto protoreflect.FileDescriptor
|
||||
var File_edge_v1_edge_gateway_proto protoreflect.FileDescriptor
|
||||
|
||||
const file_galaxy_gateway_v1_edge_gateway_proto_rawDesc = "" +
|
||||
const file_edge_v1_edge_gateway_proto_rawDesc = "" +
|
||||
"\n" +
|
||||
"$galaxy/gateway/v1/edge_gateway.proto\x12\x11galaxy.gateway.v1\x1a\x1bbuf/validate/validate.proto\"\x9c\x03\n" +
|
||||
"\x1aedge/v1/edge_gateway.proto\x12\aedge.v1\x1a\x1bbuf/validate/validate.proto\"\x9c\x03\n" +
|
||||
"\x15ExecuteCommandRequest\x122\n" +
|
||||
"\x10protocol_version\x18\x01 \x01(\tB\a\xbaH\x04r\x02\x10\x01R\x0fprotocolVersion\x123\n" +
|
||||
"\x11device_session_id\x18\x02 \x01(\tB\a\xbaH\x04r\x02\x10\x01R\x0fdeviceSessionId\x12*\n" +
|
||||
@@ -484,35 +484,35 @@ const file_galaxy_gateway_v1_edge_gateway_proto_rawDesc = "" +
|
||||
"\tsignature\x18\x06 \x01(\fR\tsignature\x12\x1d\n" +
|
||||
"\n" +
|
||||
"request_id\x18\a \x01(\tR\trequestId\x12\x19\n" +
|
||||
"\btrace_id\x18\b \x01(\tR\atraceId2\xd5\x01\n" +
|
||||
"\vEdgeGateway\x12e\n" +
|
||||
"\x0eExecuteCommand\x12(.galaxy.gateway.v1.ExecuteCommandRequest\x1a).galaxy.gateway.v1.ExecuteCommandResponse\x12_\n" +
|
||||
"\x0fSubscribeEvents\x12).galaxy.gateway.v1.SubscribeEventsRequest\x1a\x1f.galaxy.gateway.v1.GatewayEvent0\x01B2Z0galaxy/gateway/proto/galaxy/gateway/v1;gatewayv1b\x06proto3"
|
||||
"\btrace_id\x18\b \x01(\tR\atraceId2\xa9\x01\n" +
|
||||
"\aGateway\x12Q\n" +
|
||||
"\x0eExecuteCommand\x12\x1e.edge.v1.ExecuteCommandRequest\x1a\x1f.edge.v1.ExecuteCommandResponse\x12K\n" +
|
||||
"\x0fSubscribeEvents\x12\x1f.edge.v1.SubscribeEventsRequest\x1a\x15.edge.v1.GatewayEvent0\x01B%Z#galaxy/gateway/proto/edge/v1;edgev1b\x06proto3"
|
||||
|
||||
var (
|
||||
file_galaxy_gateway_v1_edge_gateway_proto_rawDescOnce sync.Once
|
||||
file_galaxy_gateway_v1_edge_gateway_proto_rawDescData []byte
|
||||
file_edge_v1_edge_gateway_proto_rawDescOnce sync.Once
|
||||
file_edge_v1_edge_gateway_proto_rawDescData []byte
|
||||
)
|
||||
|
||||
func file_galaxy_gateway_v1_edge_gateway_proto_rawDescGZIP() []byte {
|
||||
file_galaxy_gateway_v1_edge_gateway_proto_rawDescOnce.Do(func() {
|
||||
file_galaxy_gateway_v1_edge_gateway_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_galaxy_gateway_v1_edge_gateway_proto_rawDesc), len(file_galaxy_gateway_v1_edge_gateway_proto_rawDesc)))
|
||||
func file_edge_v1_edge_gateway_proto_rawDescGZIP() []byte {
|
||||
file_edge_v1_edge_gateway_proto_rawDescOnce.Do(func() {
|
||||
file_edge_v1_edge_gateway_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_edge_v1_edge_gateway_proto_rawDesc), len(file_edge_v1_edge_gateway_proto_rawDesc)))
|
||||
})
|
||||
return file_galaxy_gateway_v1_edge_gateway_proto_rawDescData
|
||||
return file_edge_v1_edge_gateway_proto_rawDescData
|
||||
}
|
||||
|
||||
var file_galaxy_gateway_v1_edge_gateway_proto_msgTypes = make([]protoimpl.MessageInfo, 4)
|
||||
var file_galaxy_gateway_v1_edge_gateway_proto_goTypes = []any{
|
||||
(*ExecuteCommandRequest)(nil), // 0: galaxy.gateway.v1.ExecuteCommandRequest
|
||||
(*ExecuteCommandResponse)(nil), // 1: galaxy.gateway.v1.ExecuteCommandResponse
|
||||
(*SubscribeEventsRequest)(nil), // 2: galaxy.gateway.v1.SubscribeEventsRequest
|
||||
(*GatewayEvent)(nil), // 3: galaxy.gateway.v1.GatewayEvent
|
||||
var file_edge_v1_edge_gateway_proto_msgTypes = make([]protoimpl.MessageInfo, 4)
|
||||
var file_edge_v1_edge_gateway_proto_goTypes = []any{
|
||||
(*ExecuteCommandRequest)(nil), // 0: edge.v1.ExecuteCommandRequest
|
||||
(*ExecuteCommandResponse)(nil), // 1: edge.v1.ExecuteCommandResponse
|
||||
(*SubscribeEventsRequest)(nil), // 2: edge.v1.SubscribeEventsRequest
|
||||
(*GatewayEvent)(nil), // 3: edge.v1.GatewayEvent
|
||||
}
|
||||
var file_galaxy_gateway_v1_edge_gateway_proto_depIdxs = []int32{
|
||||
0, // 0: galaxy.gateway.v1.EdgeGateway.ExecuteCommand:input_type -> galaxy.gateway.v1.ExecuteCommandRequest
|
||||
2, // 1: galaxy.gateway.v1.EdgeGateway.SubscribeEvents:input_type -> galaxy.gateway.v1.SubscribeEventsRequest
|
||||
1, // 2: galaxy.gateway.v1.EdgeGateway.ExecuteCommand:output_type -> galaxy.gateway.v1.ExecuteCommandResponse
|
||||
3, // 3: galaxy.gateway.v1.EdgeGateway.SubscribeEvents:output_type -> galaxy.gateway.v1.GatewayEvent
|
||||
var file_edge_v1_edge_gateway_proto_depIdxs = []int32{
|
||||
0, // 0: edge.v1.Gateway.ExecuteCommand:input_type -> edge.v1.ExecuteCommandRequest
|
||||
2, // 1: edge.v1.Gateway.SubscribeEvents:input_type -> edge.v1.SubscribeEventsRequest
|
||||
1, // 2: edge.v1.Gateway.ExecuteCommand:output_type -> edge.v1.ExecuteCommandResponse
|
||||
3, // 3: edge.v1.Gateway.SubscribeEvents:output_type -> edge.v1.GatewayEvent
|
||||
2, // [2:4] is the sub-list for method output_type
|
||||
0, // [0:2] is the sub-list for method input_type
|
||||
0, // [0:0] is the sub-list for extension type_name
|
||||
@@ -520,26 +520,26 @@ var file_galaxy_gateway_v1_edge_gateway_proto_depIdxs = []int32{
|
||||
0, // [0:0] is the sub-list for field type_name
|
||||
}
|
||||
|
||||
func init() { file_galaxy_gateway_v1_edge_gateway_proto_init() }
|
||||
func file_galaxy_gateway_v1_edge_gateway_proto_init() {
|
||||
if File_galaxy_gateway_v1_edge_gateway_proto != nil {
|
||||
func init() { file_edge_v1_edge_gateway_proto_init() }
|
||||
func file_edge_v1_edge_gateway_proto_init() {
|
||||
if File_edge_v1_edge_gateway_proto != nil {
|
||||
return
|
||||
}
|
||||
type x struct{}
|
||||
out := protoimpl.TypeBuilder{
|
||||
File: protoimpl.DescBuilder{
|
||||
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
|
||||
RawDescriptor: unsafe.Slice(unsafe.StringData(file_galaxy_gateway_v1_edge_gateway_proto_rawDesc), len(file_galaxy_gateway_v1_edge_gateway_proto_rawDesc)),
|
||||
RawDescriptor: unsafe.Slice(unsafe.StringData(file_edge_v1_edge_gateway_proto_rawDesc), len(file_edge_v1_edge_gateway_proto_rawDesc)),
|
||||
NumEnums: 0,
|
||||
NumMessages: 4,
|
||||
NumExtensions: 0,
|
||||
NumServices: 1,
|
||||
},
|
||||
GoTypes: file_galaxy_gateway_v1_edge_gateway_proto_goTypes,
|
||||
DependencyIndexes: file_galaxy_gateway_v1_edge_gateway_proto_depIdxs,
|
||||
MessageInfos: file_galaxy_gateway_v1_edge_gateway_proto_msgTypes,
|
||||
GoTypes: file_edge_v1_edge_gateway_proto_goTypes,
|
||||
DependencyIndexes: file_edge_v1_edge_gateway_proto_depIdxs,
|
||||
MessageInfos: file_edge_v1_edge_gateway_proto_msgTypes,
|
||||
}.Build()
|
||||
File_galaxy_gateway_v1_edge_gateway_proto = out.File
|
||||
file_galaxy_gateway_v1_edge_gateway_proto_goTypes = nil
|
||||
file_galaxy_gateway_v1_edge_gateway_proto_depIdxs = nil
|
||||
File_edge_v1_edge_gateway_proto = out.File
|
||||
file_edge_v1_edge_gateway_proto_goTypes = nil
|
||||
file_edge_v1_edge_gateway_proto_depIdxs = nil
|
||||
}
|
||||
+3
-3
@@ -1,12 +1,12 @@
|
||||
syntax = "proto3";
|
||||
|
||||
package galaxy.gateway.v1;
|
||||
package edge.v1;
|
||||
|
||||
option go_package = "galaxy/gateway/proto/galaxy/gateway/v1;gatewayv1";
|
||||
option go_package = "galaxy/gateway/proto/edge/v1;edgev1";
|
||||
|
||||
import "buf/validate/validate.proto";
|
||||
|
||||
service EdgeGateway {
|
||||
service Gateway {
|
||||
rpc ExecuteCommand(ExecuteCommandRequest) returns (ExecuteCommandResponse);
|
||||
rpc SubscribeEvents(SubscribeEventsRequest) returns (stream GatewayEvent);
|
||||
}
|
||||
+45
-45
@@ -2,9 +2,9 @@
|
||||
// versions:
|
||||
// - protoc-gen-go-grpc v1.6.1
|
||||
// - protoc (unknown)
|
||||
// source: galaxy/gateway/v1/edge_gateway.proto
|
||||
// source: edge/v1/edge_gateway.proto
|
||||
|
||||
package gatewayv1
|
||||
package edgev1
|
||||
|
||||
import (
|
||||
context "context"
|
||||
@@ -19,39 +19,39 @@ import (
|
||||
const _ = grpc.SupportPackageIsVersion9
|
||||
|
||||
const (
|
||||
EdgeGateway_ExecuteCommand_FullMethodName = "/galaxy.gateway.v1.EdgeGateway/ExecuteCommand"
|
||||
EdgeGateway_SubscribeEvents_FullMethodName = "/galaxy.gateway.v1.EdgeGateway/SubscribeEvents"
|
||||
Gateway_ExecuteCommand_FullMethodName = "/edge.v1.Gateway/ExecuteCommand"
|
||||
Gateway_SubscribeEvents_FullMethodName = "/edge.v1.Gateway/SubscribeEvents"
|
||||
)
|
||||
|
||||
// EdgeGatewayClient is the client API for EdgeGateway service.
|
||||
// GatewayClient is the client API for Gateway 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 EdgeGatewayClient interface {
|
||||
type GatewayClient interface {
|
||||
ExecuteCommand(ctx context.Context, in *ExecuteCommandRequest, opts ...grpc.CallOption) (*ExecuteCommandResponse, error)
|
||||
SubscribeEvents(ctx context.Context, in *SubscribeEventsRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[GatewayEvent], error)
|
||||
}
|
||||
|
||||
type edgeGatewayClient struct {
|
||||
type gatewayClient struct {
|
||||
cc grpc.ClientConnInterface
|
||||
}
|
||||
|
||||
func NewEdgeGatewayClient(cc grpc.ClientConnInterface) EdgeGatewayClient {
|
||||
return &edgeGatewayClient{cc}
|
||||
func NewGatewayClient(cc grpc.ClientConnInterface) GatewayClient {
|
||||
return &gatewayClient{cc}
|
||||
}
|
||||
|
||||
func (c *edgeGatewayClient) ExecuteCommand(ctx context.Context, in *ExecuteCommandRequest, opts ...grpc.CallOption) (*ExecuteCommandResponse, error) {
|
||||
func (c *gatewayClient) ExecuteCommand(ctx context.Context, in *ExecuteCommandRequest, opts ...grpc.CallOption) (*ExecuteCommandResponse, error) {
|
||||
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
||||
out := new(ExecuteCommandResponse)
|
||||
err := c.cc.Invoke(ctx, EdgeGateway_ExecuteCommand_FullMethodName, in, out, cOpts...)
|
||||
err := c.cc.Invoke(ctx, Gateway_ExecuteCommand_FullMethodName, in, out, cOpts...)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
func (c *edgeGatewayClient) SubscribeEvents(ctx context.Context, in *SubscribeEventsRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[GatewayEvent], error) {
|
||||
func (c *gatewayClient) SubscribeEvents(ctx context.Context, in *SubscribeEventsRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[GatewayEvent], error) {
|
||||
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
||||
stream, err := c.cc.NewStream(ctx, &EdgeGateway_ServiceDesc.Streams[0], EdgeGateway_SubscribeEvents_FullMethodName, cOpts...)
|
||||
stream, err := c.cc.NewStream(ctx, &Gateway_ServiceDesc.Streams[0], Gateway_SubscribeEvents_FullMethodName, cOpts...)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
@@ -66,98 +66,98 @@ func (c *edgeGatewayClient) SubscribeEvents(ctx context.Context, in *SubscribeEv
|
||||
}
|
||||
|
||||
// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
|
||||
type EdgeGateway_SubscribeEventsClient = grpc.ServerStreamingClient[GatewayEvent]
|
||||
type Gateway_SubscribeEventsClient = grpc.ServerStreamingClient[GatewayEvent]
|
||||
|
||||
// EdgeGatewayServer is the server API for EdgeGateway service.
|
||||
// All implementations must embed UnimplementedEdgeGatewayServer
|
||||
// GatewayServer is the server API for Gateway service.
|
||||
// All implementations must embed UnimplementedGatewayServer
|
||||
// for forward compatibility.
|
||||
type EdgeGatewayServer interface {
|
||||
type GatewayServer interface {
|
||||
ExecuteCommand(context.Context, *ExecuteCommandRequest) (*ExecuteCommandResponse, error)
|
||||
SubscribeEvents(*SubscribeEventsRequest, grpc.ServerStreamingServer[GatewayEvent]) error
|
||||
mustEmbedUnimplementedEdgeGatewayServer()
|
||||
mustEmbedUnimplementedGatewayServer()
|
||||
}
|
||||
|
||||
// UnimplementedEdgeGatewayServer must be embedded to have
|
||||
// UnimplementedGatewayServer 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 UnimplementedEdgeGatewayServer struct{}
|
||||
type UnimplementedGatewayServer struct{}
|
||||
|
||||
func (UnimplementedEdgeGatewayServer) ExecuteCommand(context.Context, *ExecuteCommandRequest) (*ExecuteCommandResponse, error) {
|
||||
func (UnimplementedGatewayServer) ExecuteCommand(context.Context, *ExecuteCommandRequest) (*ExecuteCommandResponse, error) {
|
||||
return nil, status.Error(codes.Unimplemented, "method ExecuteCommand not implemented")
|
||||
}
|
||||
func (UnimplementedEdgeGatewayServer) SubscribeEvents(*SubscribeEventsRequest, grpc.ServerStreamingServer[GatewayEvent]) error {
|
||||
func (UnimplementedGatewayServer) SubscribeEvents(*SubscribeEventsRequest, grpc.ServerStreamingServer[GatewayEvent]) error {
|
||||
return status.Error(codes.Unimplemented, "method SubscribeEvents not implemented")
|
||||
}
|
||||
func (UnimplementedEdgeGatewayServer) mustEmbedUnimplementedEdgeGatewayServer() {}
|
||||
func (UnimplementedEdgeGatewayServer) testEmbeddedByValue() {}
|
||||
func (UnimplementedGatewayServer) mustEmbedUnimplementedGatewayServer() {}
|
||||
func (UnimplementedGatewayServer) testEmbeddedByValue() {}
|
||||
|
||||
// UnsafeEdgeGatewayServer may be embedded to opt out of forward compatibility for this service.
|
||||
// Use of this interface is not recommended, as added methods to EdgeGatewayServer will
|
||||
// UnsafeGatewayServer may be embedded to opt out of forward compatibility for this service.
|
||||
// Use of this interface is not recommended, as added methods to GatewayServer will
|
||||
// result in compilation errors.
|
||||
type UnsafeEdgeGatewayServer interface {
|
||||
mustEmbedUnimplementedEdgeGatewayServer()
|
||||
type UnsafeGatewayServer interface {
|
||||
mustEmbedUnimplementedGatewayServer()
|
||||
}
|
||||
|
||||
func RegisterEdgeGatewayServer(s grpc.ServiceRegistrar, srv EdgeGatewayServer) {
|
||||
// If the following call panics, it indicates UnimplementedEdgeGatewayServer was
|
||||
func RegisterGatewayServer(s grpc.ServiceRegistrar, srv GatewayServer) {
|
||||
// If the following call panics, it indicates UnimplementedGatewayServer 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(&EdgeGateway_ServiceDesc, srv)
|
||||
s.RegisterService(&Gateway_ServiceDesc, srv)
|
||||
}
|
||||
|
||||
func _EdgeGateway_ExecuteCommand_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
||||
func _Gateway_ExecuteCommand_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
||||
in := new(ExecuteCommandRequest)
|
||||
if err := dec(in); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if interceptor == nil {
|
||||
return srv.(EdgeGatewayServer).ExecuteCommand(ctx, in)
|
||||
return srv.(GatewayServer).ExecuteCommand(ctx, in)
|
||||
}
|
||||
info := &grpc.UnaryServerInfo{
|
||||
Server: srv,
|
||||
FullMethod: EdgeGateway_ExecuteCommand_FullMethodName,
|
||||
FullMethod: Gateway_ExecuteCommand_FullMethodName,
|
||||
}
|
||||
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
||||
return srv.(EdgeGatewayServer).ExecuteCommand(ctx, req.(*ExecuteCommandRequest))
|
||||
return srv.(GatewayServer).ExecuteCommand(ctx, req.(*ExecuteCommandRequest))
|
||||
}
|
||||
return interceptor(ctx, in, info, handler)
|
||||
}
|
||||
|
||||
func _EdgeGateway_SubscribeEvents_Handler(srv interface{}, stream grpc.ServerStream) error {
|
||||
func _Gateway_SubscribeEvents_Handler(srv interface{}, stream grpc.ServerStream) error {
|
||||
m := new(SubscribeEventsRequest)
|
||||
if err := stream.RecvMsg(m); err != nil {
|
||||
return err
|
||||
}
|
||||
return srv.(EdgeGatewayServer).SubscribeEvents(m, &grpc.GenericServerStream[SubscribeEventsRequest, GatewayEvent]{ServerStream: stream})
|
||||
return srv.(GatewayServer).SubscribeEvents(m, &grpc.GenericServerStream[SubscribeEventsRequest, GatewayEvent]{ServerStream: stream})
|
||||
}
|
||||
|
||||
// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
|
||||
type EdgeGateway_SubscribeEventsServer = grpc.ServerStreamingServer[GatewayEvent]
|
||||
type Gateway_SubscribeEventsServer = grpc.ServerStreamingServer[GatewayEvent]
|
||||
|
||||
// EdgeGateway_ServiceDesc is the grpc.ServiceDesc for EdgeGateway service.
|
||||
// Gateway_ServiceDesc is the grpc.ServiceDesc for Gateway service.
|
||||
// It's only intended for direct use with grpc.RegisterService,
|
||||
// and not to be introspected or modified (even as a copy)
|
||||
var EdgeGateway_ServiceDesc = grpc.ServiceDesc{
|
||||
ServiceName: "galaxy.gateway.v1.EdgeGateway",
|
||||
HandlerType: (*EdgeGatewayServer)(nil),
|
||||
var Gateway_ServiceDesc = grpc.ServiceDesc{
|
||||
ServiceName: "edge.v1.Gateway",
|
||||
HandlerType: (*GatewayServer)(nil),
|
||||
Methods: []grpc.MethodDesc{
|
||||
{
|
||||
MethodName: "ExecuteCommand",
|
||||
Handler: _EdgeGateway_ExecuteCommand_Handler,
|
||||
Handler: _Gateway_ExecuteCommand_Handler,
|
||||
},
|
||||
},
|
||||
Streams: []grpc.StreamDesc{
|
||||
{
|
||||
StreamName: "SubscribeEvents",
|
||||
Handler: _EdgeGateway_SubscribeEvents_Handler,
|
||||
Handler: _Gateway_SubscribeEvents_Handler,
|
||||
ServerStreams: true,
|
||||
},
|
||||
},
|
||||
Metadata: "galaxy/gateway/v1/edge_gateway.proto",
|
||||
Metadata: "edge/v1/edge_gateway.proto",
|
||||
}
|
||||
@@ -0,0 +1,136 @@
|
||||
// Code generated by protoc-gen-connect-go. DO NOT EDIT.
|
||||
//
|
||||
// Source: edge/v1/edge_gateway.proto
|
||||
|
||||
package edgev1connect
|
||||
|
||||
import (
|
||||
connect "connectrpc.com/connect"
|
||||
context "context"
|
||||
errors "errors"
|
||||
v1 "galaxy/gateway/proto/edge/v1"
|
||||
http "net/http"
|
||||
strings "strings"
|
||||
)
|
||||
|
||||
// This is a compile-time assertion to ensure that this generated file and the connect package are
|
||||
// compatible. If you get a compiler error that this constant is not defined, this code was
|
||||
// generated with a version of connect newer than the one compiled into your binary. You can fix the
|
||||
// problem by either regenerating this code with an older version of connect or updating the connect
|
||||
// version compiled into your binary.
|
||||
const _ = connect.IsAtLeastVersion1_13_0
|
||||
|
||||
const (
|
||||
// GatewayName is the fully-qualified name of the Gateway service.
|
||||
GatewayName = "edge.v1.Gateway"
|
||||
)
|
||||
|
||||
// These constants are the fully-qualified names of the RPCs defined in this package. They're
|
||||
// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route.
|
||||
//
|
||||
// Note that these are different from the fully-qualified method names used by
|
||||
// google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to
|
||||
// reflection-formatted method names, remove the leading slash and convert the remaining slash to a
|
||||
// period.
|
||||
const (
|
||||
// GatewayExecuteCommandProcedure is the fully-qualified name of the Gateway's ExecuteCommand RPC.
|
||||
GatewayExecuteCommandProcedure = "/edge.v1.Gateway/ExecuteCommand"
|
||||
// GatewaySubscribeEventsProcedure is the fully-qualified name of the Gateway's SubscribeEvents RPC.
|
||||
GatewaySubscribeEventsProcedure = "/edge.v1.Gateway/SubscribeEvents"
|
||||
)
|
||||
|
||||
// GatewayClient is a client for the edge.v1.Gateway service.
|
||||
type GatewayClient interface {
|
||||
ExecuteCommand(context.Context, *connect.Request[v1.ExecuteCommandRequest]) (*connect.Response[v1.ExecuteCommandResponse], error)
|
||||
SubscribeEvents(context.Context, *connect.Request[v1.SubscribeEventsRequest]) (*connect.ServerStreamForClient[v1.GatewayEvent], error)
|
||||
}
|
||||
|
||||
// NewGatewayClient constructs a client for the edge.v1.Gateway service. By default, it uses the
|
||||
// Connect protocol with the binary Protobuf Codec, asks for gzipped responses, and sends
|
||||
// uncompressed requests. To use the gRPC or gRPC-Web protocols, supply the connect.WithGRPC() or
|
||||
// connect.WithGRPCWeb() options.
|
||||
//
|
||||
// The URL supplied here should be the base URL for the Connect or gRPC server (for example,
|
||||
// http://api.acme.com or https://acme.com/grpc).
|
||||
func NewGatewayClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) GatewayClient {
|
||||
baseURL = strings.TrimRight(baseURL, "/")
|
||||
gatewayMethods := v1.File_edge_v1_edge_gateway_proto.Services().ByName("Gateway").Methods()
|
||||
return &gatewayClient{
|
||||
executeCommand: connect.NewClient[v1.ExecuteCommandRequest, v1.ExecuteCommandResponse](
|
||||
httpClient,
|
||||
baseURL+GatewayExecuteCommandProcedure,
|
||||
connect.WithSchema(gatewayMethods.ByName("ExecuteCommand")),
|
||||
connect.WithClientOptions(opts...),
|
||||
),
|
||||
subscribeEvents: connect.NewClient[v1.SubscribeEventsRequest, v1.GatewayEvent](
|
||||
httpClient,
|
||||
baseURL+GatewaySubscribeEventsProcedure,
|
||||
connect.WithSchema(gatewayMethods.ByName("SubscribeEvents")),
|
||||
connect.WithClientOptions(opts...),
|
||||
),
|
||||
}
|
||||
}
|
||||
|
||||
// gatewayClient implements GatewayClient.
|
||||
type gatewayClient struct {
|
||||
executeCommand *connect.Client[v1.ExecuteCommandRequest, v1.ExecuteCommandResponse]
|
||||
subscribeEvents *connect.Client[v1.SubscribeEventsRequest, v1.GatewayEvent]
|
||||
}
|
||||
|
||||
// ExecuteCommand calls edge.v1.Gateway.ExecuteCommand.
|
||||
func (c *gatewayClient) ExecuteCommand(ctx context.Context, req *connect.Request[v1.ExecuteCommandRequest]) (*connect.Response[v1.ExecuteCommandResponse], error) {
|
||||
return c.executeCommand.CallUnary(ctx, req)
|
||||
}
|
||||
|
||||
// SubscribeEvents calls edge.v1.Gateway.SubscribeEvents.
|
||||
func (c *gatewayClient) SubscribeEvents(ctx context.Context, req *connect.Request[v1.SubscribeEventsRequest]) (*connect.ServerStreamForClient[v1.GatewayEvent], error) {
|
||||
return c.subscribeEvents.CallServerStream(ctx, req)
|
||||
}
|
||||
|
||||
// GatewayHandler is an implementation of the edge.v1.Gateway service.
|
||||
type GatewayHandler interface {
|
||||
ExecuteCommand(context.Context, *connect.Request[v1.ExecuteCommandRequest]) (*connect.Response[v1.ExecuteCommandResponse], error)
|
||||
SubscribeEvents(context.Context, *connect.Request[v1.SubscribeEventsRequest], *connect.ServerStream[v1.GatewayEvent]) error
|
||||
}
|
||||
|
||||
// NewGatewayHandler builds an HTTP handler from the service implementation. It returns the path on
|
||||
// which to mount the handler and the handler itself.
|
||||
//
|
||||
// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf
|
||||
// and JSON codecs. They also support gzip compression.
|
||||
func NewGatewayHandler(svc GatewayHandler, opts ...connect.HandlerOption) (string, http.Handler) {
|
||||
gatewayMethods := v1.File_edge_v1_edge_gateway_proto.Services().ByName("Gateway").Methods()
|
||||
gatewayExecuteCommandHandler := connect.NewUnaryHandler(
|
||||
GatewayExecuteCommandProcedure,
|
||||
svc.ExecuteCommand,
|
||||
connect.WithSchema(gatewayMethods.ByName("ExecuteCommand")),
|
||||
connect.WithHandlerOptions(opts...),
|
||||
)
|
||||
gatewaySubscribeEventsHandler := connect.NewServerStreamHandler(
|
||||
GatewaySubscribeEventsProcedure,
|
||||
svc.SubscribeEvents,
|
||||
connect.WithSchema(gatewayMethods.ByName("SubscribeEvents")),
|
||||
connect.WithHandlerOptions(opts...),
|
||||
)
|
||||
return "/edge.v1.Gateway/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
switch r.URL.Path {
|
||||
case GatewayExecuteCommandProcedure:
|
||||
gatewayExecuteCommandHandler.ServeHTTP(w, r)
|
||||
case GatewaySubscribeEventsProcedure:
|
||||
gatewaySubscribeEventsHandler.ServeHTTP(w, r)
|
||||
default:
|
||||
http.NotFound(w, r)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
// UnimplementedGatewayHandler returns CodeUnimplemented from all methods.
|
||||
type UnimplementedGatewayHandler struct{}
|
||||
|
||||
func (UnimplementedGatewayHandler) ExecuteCommand(context.Context, *connect.Request[v1.ExecuteCommandRequest]) (*connect.Response[v1.ExecuteCommandResponse], error) {
|
||||
return nil, connect.NewError(connect.CodeUnimplemented, errors.New("edge.v1.Gateway.ExecuteCommand is not implemented"))
|
||||
}
|
||||
|
||||
func (UnimplementedGatewayHandler) SubscribeEvents(context.Context, *connect.Request[v1.SubscribeEventsRequest], *connect.ServerStream[v1.GatewayEvent]) error {
|
||||
return connect.NewError(connect.CodeUnimplemented, errors.New("edge.v1.Gateway.SubscribeEvents is not implemented"))
|
||||
}
|
||||
@@ -1,138 +0,0 @@
|
||||
// Code generated by protoc-gen-connect-go. DO NOT EDIT.
|
||||
//
|
||||
// Source: galaxy/gateway/v1/edge_gateway.proto
|
||||
|
||||
package gatewayv1connect
|
||||
|
||||
import (
|
||||
connect "connectrpc.com/connect"
|
||||
context "context"
|
||||
errors "errors"
|
||||
v1 "galaxy/gateway/proto/galaxy/gateway/v1"
|
||||
http "net/http"
|
||||
strings "strings"
|
||||
)
|
||||
|
||||
// This is a compile-time assertion to ensure that this generated file and the connect package are
|
||||
// compatible. If you get a compiler error that this constant is not defined, this code was
|
||||
// generated with a version of connect newer than the one compiled into your binary. You can fix the
|
||||
// problem by either regenerating this code with an older version of connect or updating the connect
|
||||
// version compiled into your binary.
|
||||
const _ = connect.IsAtLeastVersion1_13_0
|
||||
|
||||
const (
|
||||
// EdgeGatewayName is the fully-qualified name of the EdgeGateway service.
|
||||
EdgeGatewayName = "galaxy.gateway.v1.EdgeGateway"
|
||||
)
|
||||
|
||||
// These constants are the fully-qualified names of the RPCs defined in this package. They're
|
||||
// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route.
|
||||
//
|
||||
// Note that these are different from the fully-qualified method names used by
|
||||
// google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to
|
||||
// reflection-formatted method names, remove the leading slash and convert the remaining slash to a
|
||||
// period.
|
||||
const (
|
||||
// EdgeGatewayExecuteCommandProcedure is the fully-qualified name of the EdgeGateway's
|
||||
// ExecuteCommand RPC.
|
||||
EdgeGatewayExecuteCommandProcedure = "/galaxy.gateway.v1.EdgeGateway/ExecuteCommand"
|
||||
// EdgeGatewaySubscribeEventsProcedure is the fully-qualified name of the EdgeGateway's
|
||||
// SubscribeEvents RPC.
|
||||
EdgeGatewaySubscribeEventsProcedure = "/galaxy.gateway.v1.EdgeGateway/SubscribeEvents"
|
||||
)
|
||||
|
||||
// EdgeGatewayClient is a client for the galaxy.gateway.v1.EdgeGateway service.
|
||||
type EdgeGatewayClient interface {
|
||||
ExecuteCommand(context.Context, *connect.Request[v1.ExecuteCommandRequest]) (*connect.Response[v1.ExecuteCommandResponse], error)
|
||||
SubscribeEvents(context.Context, *connect.Request[v1.SubscribeEventsRequest]) (*connect.ServerStreamForClient[v1.GatewayEvent], error)
|
||||
}
|
||||
|
||||
// NewEdgeGatewayClient constructs a client for the galaxy.gateway.v1.EdgeGateway service. By
|
||||
// default, it uses the Connect protocol with the binary Protobuf Codec, asks for gzipped responses,
|
||||
// and sends uncompressed requests. To use the gRPC or gRPC-Web protocols, supply the
|
||||
// connect.WithGRPC() or connect.WithGRPCWeb() options.
|
||||
//
|
||||
// The URL supplied here should be the base URL for the Connect or gRPC server (for example,
|
||||
// http://api.acme.com or https://acme.com/grpc).
|
||||
func NewEdgeGatewayClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) EdgeGatewayClient {
|
||||
baseURL = strings.TrimRight(baseURL, "/")
|
||||
edgeGatewayMethods := v1.File_galaxy_gateway_v1_edge_gateway_proto.Services().ByName("EdgeGateway").Methods()
|
||||
return &edgeGatewayClient{
|
||||
executeCommand: connect.NewClient[v1.ExecuteCommandRequest, v1.ExecuteCommandResponse](
|
||||
httpClient,
|
||||
baseURL+EdgeGatewayExecuteCommandProcedure,
|
||||
connect.WithSchema(edgeGatewayMethods.ByName("ExecuteCommand")),
|
||||
connect.WithClientOptions(opts...),
|
||||
),
|
||||
subscribeEvents: connect.NewClient[v1.SubscribeEventsRequest, v1.GatewayEvent](
|
||||
httpClient,
|
||||
baseURL+EdgeGatewaySubscribeEventsProcedure,
|
||||
connect.WithSchema(edgeGatewayMethods.ByName("SubscribeEvents")),
|
||||
connect.WithClientOptions(opts...),
|
||||
),
|
||||
}
|
||||
}
|
||||
|
||||
// edgeGatewayClient implements EdgeGatewayClient.
|
||||
type edgeGatewayClient struct {
|
||||
executeCommand *connect.Client[v1.ExecuteCommandRequest, v1.ExecuteCommandResponse]
|
||||
subscribeEvents *connect.Client[v1.SubscribeEventsRequest, v1.GatewayEvent]
|
||||
}
|
||||
|
||||
// ExecuteCommand calls galaxy.gateway.v1.EdgeGateway.ExecuteCommand.
|
||||
func (c *edgeGatewayClient) ExecuteCommand(ctx context.Context, req *connect.Request[v1.ExecuteCommandRequest]) (*connect.Response[v1.ExecuteCommandResponse], error) {
|
||||
return c.executeCommand.CallUnary(ctx, req)
|
||||
}
|
||||
|
||||
// SubscribeEvents calls galaxy.gateway.v1.EdgeGateway.SubscribeEvents.
|
||||
func (c *edgeGatewayClient) SubscribeEvents(ctx context.Context, req *connect.Request[v1.SubscribeEventsRequest]) (*connect.ServerStreamForClient[v1.GatewayEvent], error) {
|
||||
return c.subscribeEvents.CallServerStream(ctx, req)
|
||||
}
|
||||
|
||||
// EdgeGatewayHandler is an implementation of the galaxy.gateway.v1.EdgeGateway service.
|
||||
type EdgeGatewayHandler interface {
|
||||
ExecuteCommand(context.Context, *connect.Request[v1.ExecuteCommandRequest]) (*connect.Response[v1.ExecuteCommandResponse], error)
|
||||
SubscribeEvents(context.Context, *connect.Request[v1.SubscribeEventsRequest], *connect.ServerStream[v1.GatewayEvent]) error
|
||||
}
|
||||
|
||||
// NewEdgeGatewayHandler builds an HTTP handler from the service implementation. It returns the path
|
||||
// on which to mount the handler and the handler itself.
|
||||
//
|
||||
// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf
|
||||
// and JSON codecs. They also support gzip compression.
|
||||
func NewEdgeGatewayHandler(svc EdgeGatewayHandler, opts ...connect.HandlerOption) (string, http.Handler) {
|
||||
edgeGatewayMethods := v1.File_galaxy_gateway_v1_edge_gateway_proto.Services().ByName("EdgeGateway").Methods()
|
||||
edgeGatewayExecuteCommandHandler := connect.NewUnaryHandler(
|
||||
EdgeGatewayExecuteCommandProcedure,
|
||||
svc.ExecuteCommand,
|
||||
connect.WithSchema(edgeGatewayMethods.ByName("ExecuteCommand")),
|
||||
connect.WithHandlerOptions(opts...),
|
||||
)
|
||||
edgeGatewaySubscribeEventsHandler := connect.NewServerStreamHandler(
|
||||
EdgeGatewaySubscribeEventsProcedure,
|
||||
svc.SubscribeEvents,
|
||||
connect.WithSchema(edgeGatewayMethods.ByName("SubscribeEvents")),
|
||||
connect.WithHandlerOptions(opts...),
|
||||
)
|
||||
return "/galaxy.gateway.v1.EdgeGateway/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
switch r.URL.Path {
|
||||
case EdgeGatewayExecuteCommandProcedure:
|
||||
edgeGatewayExecuteCommandHandler.ServeHTTP(w, r)
|
||||
case EdgeGatewaySubscribeEventsProcedure:
|
||||
edgeGatewaySubscribeEventsHandler.ServeHTTP(w, r)
|
||||
default:
|
||||
http.NotFound(w, r)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
// UnimplementedEdgeGatewayHandler returns CodeUnimplemented from all methods.
|
||||
type UnimplementedEdgeGatewayHandler struct{}
|
||||
|
||||
func (UnimplementedEdgeGatewayHandler) ExecuteCommand(context.Context, *connect.Request[v1.ExecuteCommandRequest]) (*connect.Response[v1.ExecuteCommandResponse], error) {
|
||||
return nil, connect.NewError(connect.CodeUnimplemented, errors.New("galaxy.gateway.v1.EdgeGateway.ExecuteCommand is not implemented"))
|
||||
}
|
||||
|
||||
func (UnimplementedEdgeGatewayHandler) SubscribeEvents(context.Context, *connect.Request[v1.SubscribeEventsRequest], *connect.ServerStream[v1.GatewayEvent]) error {
|
||||
return connect.NewError(connect.CodeUnimplemented, errors.New("galaxy.gateway.v1.EdgeGateway.SubscribeEvents is not implemented"))
|
||||
}
|
||||
Reference in New Issue
Block a user