scottk/talos
1
0
Fork 0
mirror of https://github.com/lingble/talos.git synced 2025-11-01 13:07:47 +00:00
Code Issues Packages Projects Releases Wiki Activity

chore: update tools, use new generators

Browse Source 
To stay current.

Signed-off-by: Alexey Palazhchenko <alexey.palazhchenko@gmail.com>
This commit is contained in:
Alexey Palazhchenko
2021-03-15 12:47:02 +03:00
committed by talos-bot
parent e31790f6f5
commit 0dbaeb9e65
30 changed files with 3026 additions and 2847 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
Dockerfile
View File

@@ -79,25 +79,25 @@ FROM build AS generate-build
# Common needs to be at or near the top to satisfy the subsequent imports
COPY ./api/vendor/ /api/vendor/
COPY ./api/common/common.proto /api/common/common.proto
RUN protoc -I/api -I/api/vendor/ --go_out=plugins=grpc,paths=source_relative:/api common/common.proto
RUN protoc -I/api -I/api/vendor/ --go_out=paths=source_relative:/api --go-grpc_out=paths=source_relative:/api common/common.proto
COPY ./api/health/health.proto /api/health/health.proto
RUN protoc -I/api -I/api/vendor/ --go_out=plugins=grpc,paths=source_relative:/api health/health.proto
RUN protoc -I/api -I/api/vendor/ --go_out=paths=source_relative:/api --go-grpc_out=paths=source_relative:/api health/health.proto
COPY ./api/security/security.proto /api/security/security.proto
RUN protoc -I/api -I/api/vendor/ --go_out=plugins=grpc,paths=source_relative:/api security/security.proto
RUN protoc -I/api -I/api/vendor/ --go_out=paths=source_relative:/api --go-grpc_out=paths=source_relative:/api security/security.proto
COPY ./api/storage/storage.proto /api/storage/storage.proto
RUN protoc -I/api -I/api/vendor/ --go_out=plugins=grpc,paths=source_relative:/api storage/storage.proto
RUN protoc -I/api -I/api/vendor/ --go_out=paths=source_relative:/api --go-grpc_out=paths=source_relative:/api storage/storage.proto
COPY ./api/machine/machine.proto /api/machine/machine.proto
RUN protoc -I/api -I/api/vendor/ --go_out=plugins=grpc,paths=source_relative:/api machine/machine.proto
RUN protoc -I/api -I/api/vendor/ --go_out=paths=source_relative:/api --go-grpc_out=paths=source_relative:/api machine/machine.proto
COPY ./api/time/time.proto /api/time/time.proto
RUN protoc -I/api -I/api/vendor/ --go_out=plugins=grpc,paths=source_relative:/api time/time.proto
RUN protoc -I/api -I/api/vendor/ --go_out=paths=source_relative:/api --go-grpc_out=paths=source_relative:/api time/time.proto
COPY ./api/network/network.proto /api/network/network.proto
RUN protoc -I/api -I/api/vendor/ --go_out=plugins=grpc,paths=source_relative:/api network/network.proto
RUN protoc -I/api -I/api/vendor/ --go_out=paths=source_relative:/api --go-grpc_out=paths=source_relative:/api network/network.proto
COPY ./api/cluster/cluster.proto /api/cluster/cluster.proto
RUN protoc -I/api -I/api/vendor/ --go_out=plugins=grpc,paths=source_relative:/api cluster/cluster.proto
RUN protoc -I/api -I/api/vendor/ --go_out=paths=source_relative:/api --go-grpc_out=paths=source_relative:/api cluster/cluster.proto
COPY ./api/resource/resource.proto /api/resource/resource.proto
RUN protoc -I/api -I/api/vendor/ --go_out=plugins=grpc,paths=source_relative:/api resource/resource.proto
RUN protoc -I/api -I/api/vendor/ --go_out=paths=source_relative:/api --go-grpc_out=paths=source_relative:/api resource/resource.proto
COPY ./api/inspect/inspect.proto /api/inspect/inspect.proto
RUN protoc -I/api -I/api/vendor/ --go_out=plugins=grpc,paths=source_relative:/api inspect/inspect.proto
RUN protoc -I/api -I/api/vendor/ --go_out=paths=source_relative:/api --go-grpc_out=paths=source_relative:/api inspect/inspect.proto
# Gofumports generated files to adjust import order
RUN gofumports -w -local github.com/talos-systems/talos /api/

2
Makefile
View File

@@ -9,7 +9,7 @@ REGISTRY_AND_USERNAME := $(IMAGE_REGISTRY)/$(USERNAME)
DOCKER_LOGIN_ENABLED ?= true
ARTIFACTS := _out
TOOLS ?= ghcr.io/talos-systems/tools:v0.5.0-alpha.0
TOOLS ?= ghcr.io/talos-systems/tools:v0.5.0-alpha.0-1-gbcf3380
PKGS ?= v0.5.0-alpha.0-2-g35f9b6f
EXTRAS ?= v0.3.0-alpha.0
GO_VERSION ?= 1.16

2
internal/app/machined/internal/server/v1alpha1/v1alpha1_inspect.go
View File

@@ -16,6 +16,8 @@ import (
// InspectServer implements InspectService API.
type InspectServer struct {
inspectapi.UnimplementedInspectServiceServer
server *Server
}

2
internal/app/machined/internal/server/v1alpha1/v1alpha1_resource.go
View File

@@ -21,6 +21,8 @@ import (
// ResourceServer implements ResourceService API.
type ResourceServer struct {
resourceapi.UnimplementedResourceServiceServer
server *Server
}

6
internal/app/machined/internal/server/v1alpha1/v1alpha1_server.go
View File

@@ -77,8 +77,12 @@ const MinimumEtcdUpgradeLeaseLockSeconds = 60
// OSPathSeparator is the string version of the os.PathSeparator.
const OSPathSeparator = string(os.PathSeparator)
// Server implements the gRPC service server.
// Server implements ClusterService and MachineService APIs
// and is also responsible for registering ResourceServer and InspectServer.
type Server struct {
cluster.UnimplementedClusterServiceServer
machine.UnimplementedMachineServiceServer
Controller runtime.Controller
server *grpc.Server

21
internal/app/maintenance/server/server.go
View File

@@ -23,22 +23,24 @@ import (
v1alpha1machine "github.com/talos-systems/talos/pkg/machinery/config/types/v1alpha1/machine"
)
// Server implements machine.MachineService.
// Server implements machine.MachineService, network.NetworkService, and storage.StorageService.
type Server struct {
storage.UnimplementedStorageServiceServer
machine.UnimplementedMachineServiceServer
network.UnimplementedNetworkServiceServer
storaged.Server
runtime runtime.Runtime
cfgCh chan []byte
logger *log.Logger
server *grpc.Server
runtime runtime.Runtime
logger *log.Logger
cfgCh chan []byte
server *grpc.Server
storaged storaged.Server
}
// New initializes and returns a `Server`.
func New(r runtime.Runtime, logger *log.Logger, cfgCh chan []byte) *Server {
return &Server{
logger: logger,
runtime: r,
logger: logger,
cfgCh: cfgCh,
}
}
@@ -52,6 +54,11 @@ func (s *Server) Register(obj *grpc.Server) {
network.RegisterNetworkServiceServer(obj, s)
}
// Disks implements storage.StorageService.
func (s *Server) Disks(ctx context.Context, in *empty.Empty) (reply *storage.DisksResponse, err error) {
return s.storaged.Disks(ctx, in)
}
// ApplyConfiguration implements machine.MachineService.
func (s *Server) ApplyConfiguration(ctx context.Context, in *machine.ApplyConfigurationRequest) (reply *machine.ApplyConfigurationResponse, err error) {
if in.OnReboot {

5
internal/app/networkd/pkg/reg/reg.go
View File

@@ -24,8 +24,11 @@ import (
)
// Registrator is the concrete type that implements the factory.Registrator and
// networkapi.NetworkServer interfaces.
// healthapi.HealthServer and networkapi.NetworkServiceServer interfaces.
type Registrator struct {
healthapi.UnimplementedHealthServer
networkapi.UnimplementedNetworkServiceServer
Networkd *networkd.Networkd
Conn *rtnetlink.Conn

2
internal/app/storaged/server.go
View File

@@ -17,7 +17,7 @@ import (
// TODO: this is not a full blown service yet, it's used as the common base in the machine and the maintenance services.
type Server struct{}
// Disks implements machine.MaintenanceService.
// Disks implements storage.StorageService.
func (s *Server) Disks(ctx context.Context, in *empty.Empty) (reply *storage.DisksResponse, err error) {
disks, err := util.GetDisks()
if err != nil {

7
internal/app/timed/pkg/reg/reg.go
View File

@@ -19,8 +19,11 @@ import (
)
// Registrator is the concrete type that implements the factory.Registrator and
// timeapi.Init interfaces.
// healthapi.HealthServer and timeapi.TimeServiceServer interfaces.
type Registrator struct {
healthapi.UnimplementedHealthServer
timeapi.UnimplementedTimeServiceServer
Timed *ntp.NTP
}
@@ -32,6 +35,8 @@ func NewRegistrator(n *ntp.NTP) *Registrator {
}
// Register implements the factory.Registrator interface.
//
//nolint:interfacer
func (r *Registrator) Register(s *grpc.Server) {
timeapi.RegisterTimeServiceServer(s, r)
healthapi.RegisterHealthServer(s, r)

6
internal/app/trustd/internal/reg/reg.go
View File

@@ -19,12 +19,16 @@ import (
)
// Registrator is the concrete type that implements the factory.Registrator and
// securityapi.SecurityServer interfaces.
// securityapi.SecurityServiceServer interfaces.
type Registrator struct {
securityapi.UnimplementedSecurityServiceServer
Config config.Provider
}
// Register implements the factory.Registrator interface.
//
//nolint:interfacer
func (r *Registrator) Register(s *grpc.Server) {
securityapi.RegisterSecurityServiceServer(s, r)
}

117
pkg/machinery/api/cluster/cluster.pb.go
View File

@@ -1,20 +1,16 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// protoc-gen-go v1.23.0
// protoc v3.14.0
// protoc-gen-go v1.25.0
// protoc v3.15.3
// source: cluster/cluster.proto
package cluster
import (
context "context"
reflect "reflect"
sync "sync"
proto "github.com/golang/protobuf/proto"
grpc "google.golang.org/grpc"
codes "google.golang.org/grpc/codes"
status "google.golang.org/grpc/status"
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
durationpb "google.golang.org/protobuf/types/known/durationpb"
@@ -350,112 +346,3 @@ func file_cluster_cluster_proto_init() {
file_cluster_cluster_proto_goTypes = nil
file_cluster_cluster_proto_depIdxs = nil
}
// Reference imports to suppress errors if they are not otherwise used.
var (
_ context.Context
_ grpc.ClientConnInterface
)
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion6
// ClusterServiceClient is the client API for ClusterService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type ClusterServiceClient interface {
HealthCheck(ctx context.Context, in *HealthCheckRequest, opts ...grpc.CallOption) (ClusterService_HealthCheckClient, error)
}
type clusterServiceClient struct {
cc grpc.ClientConnInterface
}
func NewClusterServiceClient(cc grpc.ClientConnInterface) ClusterServiceClient {
return &clusterServiceClient{cc}
}
func (c *clusterServiceClient) HealthCheck(ctx context.Context, in *HealthCheckRequest, opts ...grpc.CallOption) (ClusterService_HealthCheckClient, error) {
stream, err := c.cc.NewStream(ctx, &_ClusterService_serviceDesc.Streams[0], "/cluster.ClusterService/HealthCheck", opts...)
if err != nil {
return nil, err
}
x := &clusterServiceHealthCheckClient{stream}
if err := x.ClientStream.SendMsg(in); err != nil {
return nil, err
}
if err := x.ClientStream.CloseSend(); err != nil {
return nil, err
}
return x, nil
}
type ClusterService_HealthCheckClient interface {
Recv() (*HealthCheckProgress, error)
grpc.ClientStream
}
type clusterServiceHealthCheckClient struct {
grpc.ClientStream
}
func (x *clusterServiceHealthCheckClient) Recv() (*HealthCheckProgress, error) {
m := new(HealthCheckProgress)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
// ClusterServiceServer is the server API for ClusterService service.
type ClusterServiceServer interface {
HealthCheck(*HealthCheckRequest, ClusterService_HealthCheckServer) error
}
// UnimplementedClusterServiceServer can be embedded to have forward compatible implementations.
type UnimplementedClusterServiceServer struct {
}
func (*UnimplementedClusterServiceServer) HealthCheck(*HealthCheckRequest, ClusterService_HealthCheckServer) error {
return status.Errorf(codes.Unimplemented, "method HealthCheck not implemented")
}
func RegisterClusterServiceServer(s *grpc.Server, srv ClusterServiceServer) {
s.RegisterService(&_ClusterService_serviceDesc, srv)
}
func _ClusterService_HealthCheck_Handler(srv interface{}, stream grpc.ServerStream) error {
m := new(HealthCheckRequest)
if err := stream.RecvMsg(m); err != nil {
return err
}
return srv.(ClusterServiceServer).HealthCheck(m, &clusterServiceHealthCheckServer{stream})
}
type ClusterService_HealthCheckServer interface {
Send(*HealthCheckProgress) error
grpc.ServerStream
}
type clusterServiceHealthCheckServer struct {
grpc.ServerStream
}
func (x *clusterServiceHealthCheckServer) Send(m *HealthCheckProgress) error {
return x.ServerStream.SendMsg(m)
}
var _ClusterService_serviceDesc = grpc.ServiceDesc{
ServiceName: "cluster.ClusterService",
HandlerType: (*ClusterServiceServer)(nil),
Methods: []grpc.MethodDesc{},
Streams: []grpc.StreamDesc{
{
StreamName: "HealthCheck",
Handler: _ClusterService_HealthCheck_Handler,
ServerStreams: true,
},
},
Metadata: "cluster/cluster.proto",
}

129
pkg/machinery/api/cluster/cluster_grpc.pb.go Normal file
View File

@@ -0,0 +1,129 @@
// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
package cluster
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.32.0 or later.
const _ = grpc.SupportPackageIsVersion7
// ClusterServiceClient is the client API for ClusterService 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 ClusterServiceClient interface {
HealthCheck(ctx context.Context, in *HealthCheckRequest, opts ...grpc.CallOption) (ClusterService_HealthCheckClient, error)
}
type clusterServiceClient struct {
cc grpc.ClientConnInterface
}
func NewClusterServiceClient(cc grpc.ClientConnInterface) ClusterServiceClient {
return &clusterServiceClient{cc}
}
func (c *clusterServiceClient) HealthCheck(ctx context.Context, in *HealthCheckRequest, opts ...grpc.CallOption) (ClusterService_HealthCheckClient, error) {
stream, err := c.cc.NewStream(ctx, &ClusterService_ServiceDesc.Streams[0], "/cluster.ClusterService/HealthCheck", opts...)
if err != nil {
return nil, err
}
x := &clusterServiceHealthCheckClient{stream}
if err := x.ClientStream.SendMsg(in); err != nil {
return nil, err
}
if err := x.ClientStream.CloseSend(); err != nil {
return nil, err
}
return x, nil
}
type ClusterService_HealthCheckClient interface {
Recv() (*HealthCheckProgress, error)
grpc.ClientStream
}
type clusterServiceHealthCheckClient struct {
grpc.ClientStream
}
func (x *clusterServiceHealthCheckClient) Recv() (*HealthCheckProgress, error) {
m := new(HealthCheckProgress)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
// ClusterServiceServer is the server API for ClusterService service.
// All implementations must embed UnimplementedClusterServiceServer
// for forward compatibility
type ClusterServiceServer interface {
HealthCheck(*HealthCheckRequest, ClusterService_HealthCheckServer) error
mustEmbedUnimplementedClusterServiceServer()
}
// UnimplementedClusterServiceServer must be embedded to have forward compatible implementations.
type UnimplementedClusterServiceServer struct {
}
func (UnimplementedClusterServiceServer) HealthCheck(*HealthCheckRequest, ClusterService_HealthCheckServer) error {
return status.Errorf(codes.Unimplemented, "method HealthCheck not implemented")
}
func (UnimplementedClusterServiceServer) mustEmbedUnimplementedClusterServiceServer() {}
// UnsafeClusterServiceServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to ClusterServiceServer will
// result in compilation errors.
type UnsafeClusterServiceServer interface {
mustEmbedUnimplementedClusterServiceServer()
}
func RegisterClusterServiceServer(s grpc.ServiceRegistrar, srv ClusterServiceServer) {
s.RegisterService(&ClusterService_ServiceDesc, srv)
}
func _ClusterService_HealthCheck_Handler(srv interface{}, stream grpc.ServerStream) error {
m := new(HealthCheckRequest)
if err := stream.RecvMsg(m); err != nil {
return err
}
return srv.(ClusterServiceServer).HealthCheck(m, &clusterServiceHealthCheckServer{stream})
}
type ClusterService_HealthCheckServer interface {
Send(*HealthCheckProgress) error
grpc.ServerStream
}
type clusterServiceHealthCheckServer struct {
grpc.ServerStream
}
func (x *clusterServiceHealthCheckServer) Send(m *HealthCheckProgress) error {
return x.ServerStream.SendMsg(m)
}
// ClusterService_ServiceDesc is the grpc.ServiceDesc for ClusterService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var ClusterService_ServiceDesc = grpc.ServiceDesc{
ServiceName: "cluster.ClusterService",
HandlerType: (*ClusterServiceServer)(nil),
Methods: []grpc.MethodDesc{},
Streams: []grpc.StreamDesc{
{
StreamName: "HealthCheck",
Handler: _ClusterService_HealthCheck_Handler,
ServerStreams: true,
},
},
Metadata: "cluster/cluster.proto",
}

4
pkg/machinery/api/common/common.pb.go
View File

@@ -1,7 +1,7 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// protoc-gen-go v1.23.0
// protoc v3.14.0
// protoc-gen-go v1.25.0
// protoc v3.15.3
// source: common/common.proto
package common

192
pkg/machinery/api/health/health.pb.go
View File

@@ -1,20 +1,16 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// protoc-gen-go v1.23.0
// protoc v3.14.0
// protoc-gen-go v1.25.0
// protoc v3.15.3
// source: health/health.proto
package health
import (
context "context"
reflect "reflect"
sync "sync"
proto "github.com/golang/protobuf/proto"
grpc "google.golang.org/grpc"
codes "google.golang.org/grpc/codes"
status "google.golang.org/grpc/status"
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
emptypb "google.golang.org/protobuf/types/known/emptypb"
@@ -551,187 +547,3 @@ func file_health_health_proto_init() {
file_health_health_proto_goTypes = nil
file_health_health_proto_depIdxs = nil
}
// Reference imports to suppress errors if they are not otherwise used.
var (
_ context.Context
_ grpc.ClientConnInterface
)
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion6
// HealthClient is the client API for Health service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type HealthClient interface {
Check(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*HealthCheckResponse, error)
Watch(ctx context.Context, in *HealthWatchRequest, opts ...grpc.CallOption) (Health_WatchClient, error)
Ready(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*ReadyCheckResponse, error)
}
type healthClient struct {
cc grpc.ClientConnInterface
}
func NewHealthClient(cc grpc.ClientConnInterface) HealthClient {
return &healthClient{cc}
}
func (c *healthClient) Check(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*HealthCheckResponse, error) {
out := new(HealthCheckResponse)
err := c.cc.Invoke(ctx, "/health.Health/Check", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *healthClient) Watch(ctx context.Context, in *HealthWatchRequest, opts ...grpc.CallOption) (Health_WatchClient, error) {
stream, err := c.cc.NewStream(ctx, &_Health_serviceDesc.Streams[0], "/health.Health/Watch", opts...)
if err != nil {
return nil, err
}
x := &healthWatchClient{stream}
if err := x.ClientStream.SendMsg(in); err != nil {
return nil, err
}
if err := x.ClientStream.CloseSend(); err != nil {
return nil, err
}
return x, nil
}
type Health_WatchClient interface {
Recv() (*HealthCheckResponse, error)
grpc.ClientStream
}
type healthWatchClient struct {
grpc.ClientStream
}
func (x *healthWatchClient) Recv() (*HealthCheckResponse, error) {
m := new(HealthCheckResponse)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
func (c *healthClient) Ready(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*ReadyCheckResponse, error) {
out := new(ReadyCheckResponse)
err := c.cc.Invoke(ctx, "/health.Health/Ready", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// HealthServer is the server API for Health service.
type HealthServer interface {
Check(context.Context, *emptypb.Empty) (*HealthCheckResponse, error)
Watch(*HealthWatchRequest, Health_WatchServer) error
Ready(context.Context, *emptypb.Empty) (*ReadyCheckResponse, error)
}
// UnimplementedHealthServer can be embedded to have forward compatible implementations.
type UnimplementedHealthServer struct {
}
func (*UnimplementedHealthServer) Check(context.Context, *emptypb.Empty) (*HealthCheckResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Check not implemented")
}
func (*UnimplementedHealthServer) Watch(*HealthWatchRequest, Health_WatchServer) error {
return status.Errorf(codes.Unimplemented, "method Watch not implemented")
}
func (*UnimplementedHealthServer) Ready(context.Context, *emptypb.Empty) (*ReadyCheckResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Ready not implemented")
}
func RegisterHealthServer(s *grpc.Server, srv HealthServer) {
s.RegisterService(&_Health_serviceDesc, srv)
}
func _Health_Check_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(emptypb.Empty)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(HealthServer).Check(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/health.Health/Check",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(HealthServer).Check(ctx, req.(*emptypb.Empty))
}
return interceptor(ctx, in, info, handler)
}
func _Health_Watch_Handler(srv interface{}, stream grpc.ServerStream) error {
m := new(HealthWatchRequest)
if err := stream.RecvMsg(m); err != nil {
return err
}
return srv.(HealthServer).Watch(m, &healthWatchServer{stream})
}
type Health_WatchServer interface {
Send(*HealthCheckResponse) error
grpc.ServerStream
}
type healthWatchServer struct {
grpc.ServerStream
}
func (x *healthWatchServer) Send(m *HealthCheckResponse) error {
return x.ServerStream.SendMsg(m)
}
func _Health_Ready_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(emptypb.Empty)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(HealthServer).Ready(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/health.Health/Ready",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(HealthServer).Ready(ctx, req.(*emptypb.Empty))
}
return interceptor(ctx, in, info, handler)
}
var _Health_serviceDesc = grpc.ServiceDesc{
ServiceName: "health.Health",
HandlerType: (*HealthServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "Check",
Handler: _Health_Check_Handler,
},
{
MethodName: "Ready",
Handler: _Health_Ready_Handler,
},
},
Streams: []grpc.StreamDesc{
{
StreamName: "Watch",
Handler: _Health_Watch_Handler,
ServerStreams: true,
},
},
Metadata: "health/health.proto",
}

205
pkg/machinery/api/health/health_grpc.pb.go Normal file
View File

@@ -0,0 +1,205 @@
// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
package health
import (
context "context"
grpc "google.golang.org/grpc"
codes "google.golang.org/grpc/codes"
status "google.golang.org/grpc/status"
emptypb "google.golang.org/protobuf/types/known/emptypb"
)
// 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.32.0 or later.
const _ = grpc.SupportPackageIsVersion7
// HealthClient is the client API for Health 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 HealthClient interface {
Check(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*HealthCheckResponse, error)
Watch(ctx context.Context, in *HealthWatchRequest, opts ...grpc.CallOption) (Health_WatchClient, error)
Ready(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*ReadyCheckResponse, error)
}
type healthClient struct {
cc grpc.ClientConnInterface
}
func NewHealthClient(cc grpc.ClientConnInterface) HealthClient {
return &healthClient{cc}
}
func (c *healthClient) Check(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*HealthCheckResponse, error) {
out := new(HealthCheckResponse)
err := c.cc.Invoke(ctx, "/health.Health/Check", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *healthClient) Watch(ctx context.Context, in *HealthWatchRequest, opts ...grpc.CallOption) (Health_WatchClient, error) {
stream, err := c.cc.NewStream(ctx, &Health_ServiceDesc.Streams[0], "/health.Health/Watch", opts...)
if err != nil {
return nil, err
}
x := &healthWatchClient{stream}
if err := x.ClientStream.SendMsg(in); err != nil {
return nil, err
}
if err := x.ClientStream.CloseSend(); err != nil {
return nil, err
}
return x, nil
}
type Health_WatchClient interface {
Recv() (*HealthCheckResponse, error)
grpc.ClientStream
}
type healthWatchClient struct {
grpc.ClientStream
}
func (x *healthWatchClient) Recv() (*HealthCheckResponse, error) {
m := new(HealthCheckResponse)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
func (c *healthClient) Ready(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*ReadyCheckResponse, error) {
out := new(ReadyCheckResponse)
err := c.cc.Invoke(ctx, "/health.Health/Ready", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// HealthServer is the server API for Health service.
// All implementations must embed UnimplementedHealthServer
// for forward compatibility
type HealthServer interface {
Check(context.Context, *emptypb.Empty) (*HealthCheckResponse, error)
Watch(*HealthWatchRequest, Health_WatchServer) error
Ready(context.Context, *emptypb.Empty) (*ReadyCheckResponse, error)
mustEmbedUnimplementedHealthServer()
}
// UnimplementedHealthServer must be embedded to have forward compatible implementations.
type UnimplementedHealthServer struct {
}
func (UnimplementedHealthServer) Check(context.Context, *emptypb.Empty) (*HealthCheckResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Check not implemented")
}
func (UnimplementedHealthServer) Watch(*HealthWatchRequest, Health_WatchServer) error {
return status.Errorf(codes.Unimplemented, "method Watch not implemented")
}
func (UnimplementedHealthServer) Ready(context.Context, *emptypb.Empty) (*ReadyCheckResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Ready not implemented")
}
func (UnimplementedHealthServer) mustEmbedUnimplementedHealthServer() {}
// UnsafeHealthServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to HealthServer will
// result in compilation errors.
type UnsafeHealthServer interface {
mustEmbedUnimplementedHealthServer()
}
func RegisterHealthServer(s grpc.ServiceRegistrar, srv HealthServer) {
s.RegisterService(&Health_ServiceDesc, srv)
}
func _Health_Check_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(emptypb.Empty)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(HealthServer).Check(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/health.Health/Check",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(HealthServer).Check(ctx, req.(*emptypb.Empty))
}
return interceptor(ctx, in, info, handler)
}
func _Health_Watch_Handler(srv interface{}, stream grpc.ServerStream) error {
m := new(HealthWatchRequest)
if err := stream.RecvMsg(m); err != nil {
return err
}
return srv.(HealthServer).Watch(m, &healthWatchServer{stream})
}
type Health_WatchServer interface {
Send(*HealthCheckResponse) error
grpc.ServerStream
}
type healthWatchServer struct {
grpc.ServerStream
}
func (x *healthWatchServer) Send(m *HealthCheckResponse) error {
return x.ServerStream.SendMsg(m)
}
func _Health_Ready_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(emptypb.Empty)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(HealthServer).Ready(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/health.Health/Ready",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(HealthServer).Ready(ctx, req.(*emptypb.Empty))
}
return interceptor(ctx, in, info, handler)
}
// Health_ServiceDesc is the grpc.ServiceDesc for Health service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var Health_ServiceDesc = grpc.ServiceDesc{
ServiceName: "health.Health",
HandlerType: (*HealthServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "Check",
Handler: _Health_Check_Handler,
},
{
MethodName: "Ready",
Handler: _Health_Ready_Handler,
},
},
Streams: []grpc.StreamDesc{
{
StreamName: "Watch",
Handler: _Health_Watch_Handler,
ServerStreams: true,
},
},
Metadata: "health/health.proto",
}

90
pkg/machinery/api/inspect/inspect.pb.go
View File

@@ -1,20 +1,16 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// protoc-gen-go v1.23.0
// protoc v3.14.0
// protoc-gen-go v1.25.0
// protoc v3.15.3
// source: inspect/inspect.proto
package inspect
import (
context "context"
reflect "reflect"
sync "sync"
proto "github.com/golang/protobuf/proto"
grpc "google.golang.org/grpc"
codes "google.golang.org/grpc/codes"
status "google.golang.org/grpc/status"
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
emptypb "google.golang.org/protobuf/types/known/emptypb"
@@ -424,85 +420,3 @@ func file_inspect_inspect_proto_init() {
file_inspect_inspect_proto_goTypes = nil
file_inspect_inspect_proto_depIdxs = nil
}
// Reference imports to suppress errors if they are not otherwise used.
var (
_ context.Context
_ grpc.ClientConnInterface
)
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion6
// InspectServiceClient is the client API for InspectService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type InspectServiceClient interface {
ControllerRuntimeDependencies(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*ControllerRuntimeDependenciesResponse, error)
}
type inspectServiceClient struct {
cc grpc.ClientConnInterface
}
func NewInspectServiceClient(cc grpc.ClientConnInterface) InspectServiceClient {
return &inspectServiceClient{cc}
}
func (c *inspectServiceClient) ControllerRuntimeDependencies(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*ControllerRuntimeDependenciesResponse, error) {
out := new(ControllerRuntimeDependenciesResponse)
err := c.cc.Invoke(ctx, "/inspect.InspectService/ControllerRuntimeDependencies", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// InspectServiceServer is the server API for InspectService service.
type InspectServiceServer interface {
ControllerRuntimeDependencies(context.Context, *emptypb.Empty) (*ControllerRuntimeDependenciesResponse, error)
}
// UnimplementedInspectServiceServer can be embedded to have forward compatible implementations.
type UnimplementedInspectServiceServer struct {
}
func (*UnimplementedInspectServiceServer) ControllerRuntimeDependencies(context.Context, *emptypb.Empty) (*ControllerRuntimeDependenciesResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method ControllerRuntimeDependencies not implemented")
}
func RegisterInspectServiceServer(s *grpc.Server, srv InspectServiceServer) {
s.RegisterService(&_InspectService_serviceDesc, srv)
}
func _InspectService_ControllerRuntimeDependencies_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(emptypb.Empty)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(InspectServiceServer).ControllerRuntimeDependencies(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/inspect.InspectService/ControllerRuntimeDependencies",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(InspectServiceServer).ControllerRuntimeDependencies(ctx, req.(*emptypb.Empty))
}
return interceptor(ctx, in, info, handler)
}
var _InspectService_serviceDesc = grpc.ServiceDesc{
ServiceName: "inspect.InspectService",
HandlerType: (*InspectServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "ControllerRuntimeDependencies",
Handler: _InspectService_ControllerRuntimeDependencies_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "inspect/inspect.proto",
}

103
pkg/machinery/api/inspect/inspect_grpc.pb.go Normal file
View File

@@ -0,0 +1,103 @@
// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
package inspect
import (
context "context"
grpc "google.golang.org/grpc"
codes "google.golang.org/grpc/codes"
status "google.golang.org/grpc/status"
emptypb "google.golang.org/protobuf/types/known/emptypb"
)
// 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.32.0 or later.
const _ = grpc.SupportPackageIsVersion7
// InspectServiceClient is the client API for InspectService 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 InspectServiceClient interface {
ControllerRuntimeDependencies(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*ControllerRuntimeDependenciesResponse, error)
}
type inspectServiceClient struct {
cc grpc.ClientConnInterface
}
func NewInspectServiceClient(cc grpc.ClientConnInterface) InspectServiceClient {
return &inspectServiceClient{cc}
}
func (c *inspectServiceClient) ControllerRuntimeDependencies(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*ControllerRuntimeDependenciesResponse, error) {
out := new(ControllerRuntimeDependenciesResponse)
err := c.cc.Invoke(ctx, "/inspect.InspectService/ControllerRuntimeDependencies", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// InspectServiceServer is the server API for InspectService service.
// All implementations must embed UnimplementedInspectServiceServer
// for forward compatibility
type InspectServiceServer interface {
ControllerRuntimeDependencies(context.Context, *emptypb.Empty) (*ControllerRuntimeDependenciesResponse, error)
mustEmbedUnimplementedInspectServiceServer()
}
// UnimplementedInspectServiceServer must be embedded to have forward compatible implementations.
type UnimplementedInspectServiceServer struct {
}
func (UnimplementedInspectServiceServer) ControllerRuntimeDependencies(context.Context, *emptypb.Empty) (*ControllerRuntimeDependenciesResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method ControllerRuntimeDependencies not implemented")
}
func (UnimplementedInspectServiceServer) mustEmbedUnimplementedInspectServiceServer() {}
// UnsafeInspectServiceServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to InspectServiceServer will
// result in compilation errors.
type UnsafeInspectServiceServer interface {
mustEmbedUnimplementedInspectServiceServer()
}
func RegisterInspectServiceServer(s grpc.ServiceRegistrar, srv InspectServiceServer) {
s.RegisterService(&InspectService_ServiceDesc, srv)
}
func _InspectService_ControllerRuntimeDependencies_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(emptypb.Empty)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(InspectServiceServer).ControllerRuntimeDependencies(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/inspect.InspectService/ControllerRuntimeDependencies",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(InspectServiceServer).ControllerRuntimeDependencies(ctx, req.(*emptypb.Empty))
}
return interceptor(ctx, in, info, handler)
}
// InspectService_ServiceDesc is the grpc.ServiceDesc for InspectService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var InspectService_ServiceDesc = grpc.ServiceDesc{
ServiceName: "inspect.InspectService",
HandlerType: (*InspectServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "ControllerRuntimeDependencies",
Handler: _InspectService_ControllerRuntimeDependencies_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "inspect/inspect.proto",
}

1713
pkg/machinery/api/machine/machine.pb.go
View File

File diff suppressed because it is too large Load Diff

1728
pkg/machinery/api/machine/machine_grpc.pb.go Normal file
View File

File diff suppressed because it is too large Load Diff

127
pkg/machinery/api/network/network.pb.go
View File

@@ -1,20 +1,16 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// protoc-gen-go v1.23.0
// protoc v3.14.0
// protoc-gen-go v1.25.0
// protoc v3.15.3
// source: network/network.proto
package network
import (
context "context"
reflect "reflect"
sync "sync"
proto "github.com/golang/protobuf/proto"
grpc "google.golang.org/grpc"
codes "google.golang.org/grpc/codes"
status "google.golang.org/grpc/status"
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
emptypb "google.golang.org/protobuf/types/known/emptypb"
@@ -908,122 +904,3 @@ func file_network_network_proto_init() {
file_network_network_proto_goTypes = nil
file_network_network_proto_depIdxs = nil
}
// Reference imports to suppress errors if they are not otherwise used.
var (
_ context.Context
_ grpc.ClientConnInterface
)
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion6
// NetworkServiceClient is the client API for NetworkService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type NetworkServiceClient interface {
Routes(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*RoutesResponse, error)
Interfaces(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*InterfacesResponse, error)
}
type networkServiceClient struct {
cc grpc.ClientConnInterface
}
func NewNetworkServiceClient(cc grpc.ClientConnInterface) NetworkServiceClient {
return &networkServiceClient{cc}
}
func (c *networkServiceClient) Routes(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*RoutesResponse, error) {
out := new(RoutesResponse)
err := c.cc.Invoke(ctx, "/network.NetworkService/Routes", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *networkServiceClient) Interfaces(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*InterfacesResponse, error) {
out := new(InterfacesResponse)
err := c.cc.Invoke(ctx, "/network.NetworkService/Interfaces", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// NetworkServiceServer is the server API for NetworkService service.
type NetworkServiceServer interface {
Routes(context.Context, *emptypb.Empty) (*RoutesResponse, error)
Interfaces(context.Context, *emptypb.Empty) (*InterfacesResponse, error)
}
// UnimplementedNetworkServiceServer can be embedded to have forward compatible implementations.
type UnimplementedNetworkServiceServer struct {
}
func (*UnimplementedNetworkServiceServer) Routes(context.Context, *emptypb.Empty) (*RoutesResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Routes not implemented")
}
func (*UnimplementedNetworkServiceServer) Interfaces(context.Context, *emptypb.Empty) (*InterfacesResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Interfaces not implemented")
}
func RegisterNetworkServiceServer(s *grpc.Server, srv NetworkServiceServer) {
s.RegisterService(&_NetworkService_serviceDesc, srv)
}
func _NetworkService_Routes_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(emptypb.Empty)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(NetworkServiceServer).Routes(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/network.NetworkService/Routes",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(NetworkServiceServer).Routes(ctx, req.(*emptypb.Empty))
}
return interceptor(ctx, in, info, handler)
}
func _NetworkService_Interfaces_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(emptypb.Empty)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(NetworkServiceServer).Interfaces(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/network.NetworkService/Interfaces",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(NetworkServiceServer).Interfaces(ctx, req.(*emptypb.Empty))
}
return interceptor(ctx, in, info, handler)
}
var _NetworkService_serviceDesc = grpc.ServiceDesc{
ServiceName: "network.NetworkService",
HandlerType: (*NetworkServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "Routes",
Handler: _NetworkService_Routes_Handler,
},
{
MethodName: "Interfaces",
Handler: _NetworkService_Interfaces_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "network/network.proto",
}

140
pkg/machinery/api/network/network_grpc.pb.go Normal file
View File

@@ -0,0 +1,140 @@
// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
package network
import (
context "context"
grpc "google.golang.org/grpc"
codes "google.golang.org/grpc/codes"
status "google.golang.org/grpc/status"
emptypb "google.golang.org/protobuf/types/known/emptypb"
)
// 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.32.0 or later.
const _ = grpc.SupportPackageIsVersion7
// NetworkServiceClient is the client API for NetworkService 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 NetworkServiceClient interface {
Routes(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*RoutesResponse, error)
Interfaces(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*InterfacesResponse, error)
}
type networkServiceClient struct {
cc grpc.ClientConnInterface
}
func NewNetworkServiceClient(cc grpc.ClientConnInterface) NetworkServiceClient {
return &networkServiceClient{cc}
}
func (c *networkServiceClient) Routes(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*RoutesResponse, error) {
out := new(RoutesResponse)
err := c.cc.Invoke(ctx, "/network.NetworkService/Routes", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *networkServiceClient) Interfaces(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*InterfacesResponse, error) {
out := new(InterfacesResponse)
err := c.cc.Invoke(ctx, "/network.NetworkService/Interfaces", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// NetworkServiceServer is the server API for NetworkService service.
// All implementations must embed UnimplementedNetworkServiceServer
// for forward compatibility
type NetworkServiceServer interface {
Routes(context.Context, *emptypb.Empty) (*RoutesResponse, error)
Interfaces(context.Context, *emptypb.Empty) (*InterfacesResponse, error)
mustEmbedUnimplementedNetworkServiceServer()
}
// UnimplementedNetworkServiceServer must be embedded to have forward compatible implementations.
type UnimplementedNetworkServiceServer struct {
}
func (UnimplementedNetworkServiceServer) Routes(context.Context, *emptypb.Empty) (*RoutesResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Routes not implemented")
}
func (UnimplementedNetworkServiceServer) Interfaces(context.Context, *emptypb.Empty) (*InterfacesResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Interfaces not implemented")
}
func (UnimplementedNetworkServiceServer) mustEmbedUnimplementedNetworkServiceServer() {}
// UnsafeNetworkServiceServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to NetworkServiceServer will
// result in compilation errors.
type UnsafeNetworkServiceServer interface {
mustEmbedUnimplementedNetworkServiceServer()
}
func RegisterNetworkServiceServer(s grpc.ServiceRegistrar, srv NetworkServiceServer) {
s.RegisterService(&NetworkService_ServiceDesc, srv)
}
func _NetworkService_Routes_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(emptypb.Empty)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(NetworkServiceServer).Routes(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/network.NetworkService/Routes",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(NetworkServiceServer).Routes(ctx, req.(*emptypb.Empty))
}
return interceptor(ctx, in, info, handler)
}
func _NetworkService_Interfaces_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(emptypb.Empty)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(NetworkServiceServer).Interfaces(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/network.NetworkService/Interfaces",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(NetworkServiceServer).Interfaces(ctx, req.(*emptypb.Empty))
}
return interceptor(ctx, in, info, handler)
}
// NetworkService_ServiceDesc is the grpc.ServiceDesc for NetworkService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var NetworkService_ServiceDesc = grpc.ServiceDesc{
ServiceName: "network.NetworkService",
HandlerType: (*NetworkServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "Routes",
Handler: _NetworkService_Routes_Handler,
},
{
MethodName: "Interfaces",
Handler: _NetworkService_Interfaces_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "network/network.proto",
}

219
pkg/machinery/api/resource/resource.pb.go
View File

@@ -1,20 +1,16 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// protoc-gen-go v1.23.0
// protoc v3.14.0
// protoc-gen-go v1.25.0
// protoc v3.15.3
// source: resource/resource.proto
package resource
import (
context "context"
reflect "reflect"
sync "sync"
proto "github.com/golang/protobuf/proto"
grpc "google.golang.org/grpc"
codes "google.golang.org/grpc/codes"
status "google.golang.org/grpc/status"
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
@@ -1005,214 +1001,3 @@ func file_resource_resource_proto_init() {
file_resource_resource_proto_goTypes = nil
file_resource_resource_proto_depIdxs = nil
}
// Reference imports to suppress errors if they are not otherwise used.
var (
_ context.Context
_ grpc.ClientConnInterface
)
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion6
// ResourceServiceClient is the client API for ResourceService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type ResourceServiceClient interface {
Get(ctx context.Context, in *GetRequest, opts ...grpc.CallOption) (*GetResponse, error)
List(ctx context.Context, in *ListRequest, opts ...grpc.CallOption) (ResourceService_ListClient, error)
Watch(ctx context.Context, in *WatchRequest, opts ...grpc.CallOption) (ResourceService_WatchClient, error)
}
type resourceServiceClient struct {
cc grpc.ClientConnInterface
}
func NewResourceServiceClient(cc grpc.ClientConnInterface) ResourceServiceClient {
return &resourceServiceClient{cc}
}
func (c *resourceServiceClient) Get(ctx context.Context, in *GetRequest, opts ...grpc.CallOption) (*GetResponse, error) {
out := new(GetResponse)
err := c.cc.Invoke(ctx, "/resource.ResourceService/Get", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *resourceServiceClient) List(ctx context.Context, in *ListRequest, opts ...grpc.CallOption) (ResourceService_ListClient, error) {
stream, err := c.cc.NewStream(ctx, &_ResourceService_serviceDesc.Streams[0], "/resource.ResourceService/List", opts...)
if err != nil {
return nil, err
}
x := &resourceServiceListClient{stream}
if err := x.ClientStream.SendMsg(in); err != nil {
return nil, err
}
if err := x.ClientStream.CloseSend(); err != nil {
return nil, err
}
return x, nil
}
type ResourceService_ListClient interface {
Recv() (*ListResponse, error)
grpc.ClientStream
}
type resourceServiceListClient struct {
grpc.ClientStream
}
func (x *resourceServiceListClient) Recv() (*ListResponse, error) {
m := new(ListResponse)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
func (c *resourceServiceClient) Watch(ctx context.Context, in *WatchRequest, opts ...grpc.CallOption) (ResourceService_WatchClient, error) {
stream, err := c.cc.NewStream(ctx, &_ResourceService_serviceDesc.Streams[1], "/resource.ResourceService/Watch", opts...)
if err != nil {
return nil, err
}
x := &resourceServiceWatchClient{stream}
if err := x.ClientStream.SendMsg(in); err != nil {
return nil, err
}
if err := x.ClientStream.CloseSend(); err != nil {
return nil, err
}
return x, nil
}
type ResourceService_WatchClient interface {
Recv() (*WatchResponse, error)
grpc.ClientStream
}
type resourceServiceWatchClient struct {
grpc.ClientStream
}
func (x *resourceServiceWatchClient) Recv() (*WatchResponse, error) {
m := new(WatchResponse)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
// ResourceServiceServer is the server API for ResourceService service.
type ResourceServiceServer interface {
Get(context.Context, *GetRequest) (*GetResponse, error)
List(*ListRequest, ResourceService_ListServer) error
Watch(*WatchRequest, ResourceService_WatchServer) error
}
// UnimplementedResourceServiceServer can be embedded to have forward compatible implementations.
type UnimplementedResourceServiceServer struct {
}
func (*UnimplementedResourceServiceServer) Get(context.Context, *GetRequest) (*GetResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Get not implemented")
}
func (*UnimplementedResourceServiceServer) List(*ListRequest, ResourceService_ListServer) error {
return status.Errorf(codes.Unimplemented, "method List not implemented")
}
func (*UnimplementedResourceServiceServer) Watch(*WatchRequest, ResourceService_WatchServer) error {
return status.Errorf(codes.Unimplemented, "method Watch not implemented")
}
func RegisterResourceServiceServer(s *grpc.Server, srv ResourceServiceServer) {
s.RegisterService(&_ResourceService_serviceDesc, srv)
}
func _ResourceService_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ResourceServiceServer).Get(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/resource.ResourceService/Get",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ResourceServiceServer).Get(ctx, req.(*GetRequest))
}
return interceptor(ctx, in, info, handler)
}
func _ResourceService_List_Handler(srv interface{}, stream grpc.ServerStream) error {
m := new(ListRequest)
if err := stream.RecvMsg(m); err != nil {
return err
}
return srv.(ResourceServiceServer).List(m, &resourceServiceListServer{stream})
}
type ResourceService_ListServer interface {
Send(*ListResponse) error
grpc.ServerStream
}
type resourceServiceListServer struct {
grpc.ServerStream
}
func (x *resourceServiceListServer) Send(m *ListResponse) error {
return x.ServerStream.SendMsg(m)
}
func _ResourceService_Watch_Handler(srv interface{}, stream grpc.ServerStream) error {
m := new(WatchRequest)
if err := stream.RecvMsg(m); err != nil {
return err
}
return srv.(ResourceServiceServer).Watch(m, &resourceServiceWatchServer{stream})
}
type ResourceService_WatchServer interface {
Send(*WatchResponse) error
grpc.ServerStream
}
type resourceServiceWatchServer struct {
grpc.ServerStream
}
func (x *resourceServiceWatchServer) Send(m *WatchResponse) error {
return x.ServerStream.SendMsg(m)
}
var _ResourceService_serviceDesc = grpc.ServiceDesc{
ServiceName: "resource.ResourceService",
HandlerType: (*ResourceServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "Get",
Handler: _ResourceService_Get_Handler,
},
},
Streams: []grpc.StreamDesc{
{
StreamName: "List",
Handler: _ResourceService_List_Handler,
ServerStreams: true,
},
{
StreamName: "Watch",
Handler: _ResourceService_Watch_Handler,
ServerStreams: true,
},
},
Metadata: "resource/resource.proto",
}

231
pkg/machinery/api/resource/resource_grpc.pb.go Normal file
View File

@@ -0,0 +1,231 @@
// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
package resource
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.32.0 or later.
const _ = grpc.SupportPackageIsVersion7
// ResourceServiceClient is the client API for ResourceService 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 ResourceServiceClient interface {
Get(ctx context.Context, in *GetRequest, opts ...grpc.CallOption) (*GetResponse, error)
List(ctx context.Context, in *ListRequest, opts ...grpc.CallOption) (ResourceService_ListClient, error)
Watch(ctx context.Context, in *WatchRequest, opts ...grpc.CallOption) (ResourceService_WatchClient, error)
}
type resourceServiceClient struct {
cc grpc.ClientConnInterface
}
func NewResourceServiceClient(cc grpc.ClientConnInterface) ResourceServiceClient {
return &resourceServiceClient{cc}
}
func (c *resourceServiceClient) Get(ctx context.Context, in *GetRequest, opts ...grpc.CallOption) (*GetResponse, error) {
out := new(GetResponse)
err := c.cc.Invoke(ctx, "/resource.ResourceService/Get", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *resourceServiceClient) List(ctx context.Context, in *ListRequest, opts ...grpc.CallOption) (ResourceService_ListClient, error) {
stream, err := c.cc.NewStream(ctx, &ResourceService_ServiceDesc.Streams[0], "/resource.ResourceService/List", opts...)
if err != nil {
return nil, err
}
x := &resourceServiceListClient{stream}
if err := x.ClientStream.SendMsg(in); err != nil {
return nil, err
}
if err := x.ClientStream.CloseSend(); err != nil {
return nil, err
}
return x, nil
}
type ResourceService_ListClient interface {
Recv() (*ListResponse, error)
grpc.ClientStream
}
type resourceServiceListClient struct {
grpc.ClientStream
}
func (x *resourceServiceListClient) Recv() (*ListResponse, error) {
m := new(ListResponse)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
func (c *resourceServiceClient) Watch(ctx context.Context, in *WatchRequest, opts ...grpc.CallOption) (ResourceService_WatchClient, error) {
stream, err := c.cc.NewStream(ctx, &ResourceService_ServiceDesc.Streams[1], "/resource.ResourceService/Watch", opts...)
if err != nil {
return nil, err
}
x := &resourceServiceWatchClient{stream}
if err := x.ClientStream.SendMsg(in); err != nil {
return nil, err
}
if err := x.ClientStream.CloseSend(); err != nil {
return nil, err
}
return x, nil
}
type ResourceService_WatchClient interface {
Recv() (*WatchResponse, error)
grpc.ClientStream
}
type resourceServiceWatchClient struct {
grpc.ClientStream
}
func (x *resourceServiceWatchClient) Recv() (*WatchResponse, error) {
m := new(WatchResponse)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
// ResourceServiceServer is the server API for ResourceService service.
// All implementations must embed UnimplementedResourceServiceServer
// for forward compatibility
type ResourceServiceServer interface {
Get(context.Context, *GetRequest) (*GetResponse, error)
List(*ListRequest, ResourceService_ListServer) error
Watch(*WatchRequest, ResourceService_WatchServer) error
mustEmbedUnimplementedResourceServiceServer()
}
// UnimplementedResourceServiceServer must be embedded to have forward compatible implementations.
type UnimplementedResourceServiceServer struct {
}
func (UnimplementedResourceServiceServer) Get(context.Context, *GetRequest) (*GetResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Get not implemented")
}
func (UnimplementedResourceServiceServer) List(*ListRequest, ResourceService_ListServer) error {
return status.Errorf(codes.Unimplemented, "method List not implemented")
}
func (UnimplementedResourceServiceServer) Watch(*WatchRequest, ResourceService_WatchServer) error {
return status.Errorf(codes.Unimplemented, "method Watch not implemented")
}
func (UnimplementedResourceServiceServer) mustEmbedUnimplementedResourceServiceServer() {}
// UnsafeResourceServiceServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to ResourceServiceServer will
// result in compilation errors.
type UnsafeResourceServiceServer interface {
mustEmbedUnimplementedResourceServiceServer()
}
func RegisterResourceServiceServer(s grpc.ServiceRegistrar, srv ResourceServiceServer) {
s.RegisterService(&ResourceService_ServiceDesc, srv)
}
func _ResourceService_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ResourceServiceServer).Get(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/resource.ResourceService/Get",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ResourceServiceServer).Get(ctx, req.(*GetRequest))
}
return interceptor(ctx, in, info, handler)
}
func _ResourceService_List_Handler(srv interface{}, stream grpc.ServerStream) error {
m := new(ListRequest)
if err := stream.RecvMsg(m); err != nil {
return err
}
return srv.(ResourceServiceServer).List(m, &resourceServiceListServer{stream})
}
type ResourceService_ListServer interface {
Send(*ListResponse) error
grpc.ServerStream
}
type resourceServiceListServer struct {
grpc.ServerStream
}
func (x *resourceServiceListServer) Send(m *ListResponse) error {
return x.ServerStream.SendMsg(m)
}
func _ResourceService_Watch_Handler(srv interface{}, stream grpc.ServerStream) error {
m := new(WatchRequest)
if err := stream.RecvMsg(m); err != nil {
return err
}
return srv.(ResourceServiceServer).Watch(m, &resourceServiceWatchServer{stream})
}
type ResourceService_WatchServer interface {
Send(*WatchResponse) error
grpc.ServerStream
}
type resourceServiceWatchServer struct {
grpc.ServerStream
}
func (x *resourceServiceWatchServer) Send(m *WatchResponse) error {
return x.ServerStream.SendMsg(m)
}
// ResourceService_ServiceDesc is the grpc.ServiceDesc for ResourceService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var ResourceService_ServiceDesc = grpc.ServiceDesc{
ServiceName: "resource.ResourceService",
HandlerType: (*ResourceServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "Get",
Handler: _ResourceService_Get_Handler,
},
},
Streams: []grpc.StreamDesc{
{
StreamName: "List",
Handler: _ResourceService_List_Handler,
ServerStreams: true,
},
{
StreamName: "Watch",
Handler: _ResourceService_Watch_Handler,
ServerStreams: true,
},
},
Metadata: "resource/resource.proto",
}

164
pkg/machinery/api/security/security.pb.go
View File

@@ -1,20 +1,16 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// protoc-gen-go v1.23.0
// protoc v3.14.0
// protoc-gen-go v1.25.0
// protoc v3.15.3
// source: security/security.proto
package security
import (
context "context"
reflect "reflect"
sync "sync"
proto "github.com/golang/protobuf/proto"
grpc "google.golang.org/grpc"
codes "google.golang.org/grpc/codes"
status "google.golang.org/grpc/status"
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
)
@@ -516,159 +512,3 @@ func file_security_security_proto_init() {
file_security_security_proto_goTypes = nil
file_security_security_proto_depIdxs = nil
}
// Reference imports to suppress errors if they are not otherwise used.
var (
_ context.Context
_ grpc.ClientConnInterface
)
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion6
// SecurityServiceClient is the client API for SecurityService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type SecurityServiceClient interface {
Certificate(ctx context.Context, in *CertificateRequest, opts ...grpc.CallOption) (*CertificateResponse, error)
ReadFile(ctx context.Context, in *ReadFileRequest, opts ...grpc.CallOption) (*ReadFileResponse, error)
WriteFile(ctx context.Context, in *WriteFileRequest, opts ...grpc.CallOption) (*WriteFileResponse, error)
}
type securityServiceClient struct {
cc grpc.ClientConnInterface
}
func NewSecurityServiceClient(cc grpc.ClientConnInterface) SecurityServiceClient {
return &securityServiceClient{cc}
}
func (c *securityServiceClient) Certificate(ctx context.Context, in *CertificateRequest, opts ...grpc.CallOption) (*CertificateResponse, error) {
out := new(CertificateResponse)
err := c.cc.Invoke(ctx, "/securityapi.SecurityService/Certificate", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *securityServiceClient) ReadFile(ctx context.Context, in *ReadFileRequest, opts ...grpc.CallOption) (*ReadFileResponse, error) {
out := new(ReadFileResponse)
err := c.cc.Invoke(ctx, "/securityapi.SecurityService/ReadFile", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *securityServiceClient) WriteFile(ctx context.Context, in *WriteFileRequest, opts ...grpc.CallOption) (*WriteFileResponse, error) {
out := new(WriteFileResponse)
err := c.cc.Invoke(ctx, "/securityapi.SecurityService/WriteFile", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// SecurityServiceServer is the server API for SecurityService service.
type SecurityServiceServer interface {
Certificate(context.Context, *CertificateRequest) (*CertificateResponse, error)
ReadFile(context.Context, *ReadFileRequest) (*ReadFileResponse, error)
WriteFile(context.Context, *WriteFileRequest) (*WriteFileResponse, error)
}
// UnimplementedSecurityServiceServer can be embedded to have forward compatible implementations.
type UnimplementedSecurityServiceServer struct {
}
func (*UnimplementedSecurityServiceServer) Certificate(context.Context, *CertificateRequest) (*CertificateResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Certificate not implemented")
}
func (*UnimplementedSecurityServiceServer) ReadFile(context.Context, *ReadFileRequest) (*ReadFileResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method ReadFile not implemented")
}
func (*UnimplementedSecurityServiceServer) WriteFile(context.Context, *WriteFileRequest) (*WriteFileResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method WriteFile not implemented")
}
func RegisterSecurityServiceServer(s *grpc.Server, srv SecurityServiceServer) {
s.RegisterService(&_SecurityService_serviceDesc, srv)
}
func _SecurityService_Certificate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(CertificateRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(SecurityServiceServer).Certificate(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/securityapi.SecurityService/Certificate",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(SecurityServiceServer).Certificate(ctx, req.(*CertificateRequest))
}
return interceptor(ctx, in, info, handler)
}
func _SecurityService_ReadFile_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ReadFileRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(SecurityServiceServer).ReadFile(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/securityapi.SecurityService/ReadFile",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(SecurityServiceServer).ReadFile(ctx, req.(*ReadFileRequest))
}
return interceptor(ctx, in, info, handler)
}
func _SecurityService_WriteFile_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(WriteFileRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(SecurityServiceServer).WriteFile(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/securityapi.SecurityService/WriteFile",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(SecurityServiceServer).WriteFile(ctx, req.(*WriteFileRequest))
}
return interceptor(ctx, in, info, handler)
}
var _SecurityService_serviceDesc = grpc.ServiceDesc{
ServiceName: "securityapi.SecurityService",
HandlerType: (*SecurityServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "Certificate",
Handler: _SecurityService_Certificate_Handler,
},
{
MethodName: "ReadFile",
Handler: _SecurityService_ReadFile_Handler,
},
{
MethodName: "WriteFile",
Handler: _SecurityService_WriteFile_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "security/security.proto",
}

176
pkg/machinery/api/security/security_grpc.pb.go Normal file
View File

@@ -0,0 +1,176 @@
// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
package security
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.32.0 or later.
const _ = grpc.SupportPackageIsVersion7
// SecurityServiceClient is the client API for SecurityService 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 SecurityServiceClient interface {
Certificate(ctx context.Context, in *CertificateRequest, opts ...grpc.CallOption) (*CertificateResponse, error)
ReadFile(ctx context.Context, in *ReadFileRequest, opts ...grpc.CallOption) (*ReadFileResponse, error)
WriteFile(ctx context.Context, in *WriteFileRequest, opts ...grpc.CallOption) (*WriteFileResponse, error)
}
type securityServiceClient struct {
cc grpc.ClientConnInterface
}
func NewSecurityServiceClient(cc grpc.ClientConnInterface) SecurityServiceClient {
return &securityServiceClient{cc}
}
func (c *securityServiceClient) Certificate(ctx context.Context, in *CertificateRequest, opts ...grpc.CallOption) (*CertificateResponse, error) {
out := new(CertificateResponse)
err := c.cc.Invoke(ctx, "/securityapi.SecurityService/Certificate", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *securityServiceClient) ReadFile(ctx context.Context, in *ReadFileRequest, opts ...grpc.CallOption) (*ReadFileResponse, error) {
out := new(ReadFileResponse)
err := c.cc.Invoke(ctx, "/securityapi.SecurityService/ReadFile", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *securityServiceClient) WriteFile(ctx context.Context, in *WriteFileRequest, opts ...grpc.CallOption) (*WriteFileResponse, error) {
out := new(WriteFileResponse)
err := c.cc.Invoke(ctx, "/securityapi.SecurityService/WriteFile", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// SecurityServiceServer is the server API for SecurityService service.
// All implementations must embed UnimplementedSecurityServiceServer
// for forward compatibility
type SecurityServiceServer interface {
Certificate(context.Context, *CertificateRequest) (*CertificateResponse, error)
ReadFile(context.Context, *ReadFileRequest) (*ReadFileResponse, error)
WriteFile(context.Context, *WriteFileRequest) (*WriteFileResponse, error)
mustEmbedUnimplementedSecurityServiceServer()
}
// UnimplementedSecurityServiceServer must be embedded to have forward compatible implementations.
type UnimplementedSecurityServiceServer struct {
}
func (UnimplementedSecurityServiceServer) Certificate(context.Context, *CertificateRequest) (*CertificateResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Certificate not implemented")
}
func (UnimplementedSecurityServiceServer) ReadFile(context.Context, *ReadFileRequest) (*ReadFileResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method ReadFile not implemented")
}
func (UnimplementedSecurityServiceServer) WriteFile(context.Context, *WriteFileRequest) (*WriteFileResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method WriteFile not implemented")
}
func (UnimplementedSecurityServiceServer) mustEmbedUnimplementedSecurityServiceServer() {}
// UnsafeSecurityServiceServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to SecurityServiceServer will
// result in compilation errors.
type UnsafeSecurityServiceServer interface {
mustEmbedUnimplementedSecurityServiceServer()
}
func RegisterSecurityServiceServer(s grpc.ServiceRegistrar, srv SecurityServiceServer) {
s.RegisterService(&SecurityService_ServiceDesc, srv)
}
func _SecurityService_Certificate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(CertificateRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(SecurityServiceServer).Certificate(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/securityapi.SecurityService/Certificate",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(SecurityServiceServer).Certificate(ctx, req.(*CertificateRequest))
}
return interceptor(ctx, in, info, handler)
}
func _SecurityService_ReadFile_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ReadFileRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(SecurityServiceServer).ReadFile(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/securityapi.SecurityService/ReadFile",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(SecurityServiceServer).ReadFile(ctx, req.(*ReadFileRequest))
}
return interceptor(ctx, in, info, handler)
}
func _SecurityService_WriteFile_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(WriteFileRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(SecurityServiceServer).WriteFile(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/securityapi.SecurityService/WriteFile",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(SecurityServiceServer).WriteFile(ctx, req.(*WriteFileRequest))
}
return interceptor(ctx, in, info, handler)
}
// SecurityService_ServiceDesc is the grpc.ServiceDesc for SecurityService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var SecurityService_ServiceDesc = grpc.ServiceDesc{
ServiceName: "securityapi.SecurityService",
HandlerType: (*SecurityServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "Certificate",
Handler: _SecurityService_Certificate_Handler,
},
{
MethodName: "ReadFile",
Handler: _SecurityService_ReadFile_Handler,
},
{
MethodName: "WriteFile",
Handler: _SecurityService_WriteFile_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "security/security.proto",
}

90
pkg/machinery/api/storage/storage.pb.go
View File

@@ -1,20 +1,16 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// protoc-gen-go v1.23.0
// protoc v3.14.0
// protoc-gen-go v1.25.0
// protoc v3.15.3
// source: storage/storage.proto
package storage
import (
context "context"
reflect "reflect"
sync "sync"
proto "github.com/golang/protobuf/proto"
grpc "google.golang.org/grpc"
codes "google.golang.org/grpc/codes"
status "google.golang.org/grpc/status"
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
emptypb "google.golang.org/protobuf/types/known/emptypb"
@@ -337,85 +333,3 @@ func file_storage_storage_proto_init() {
file_storage_storage_proto_goTypes = nil
file_storage_storage_proto_depIdxs = nil
}
// Reference imports to suppress errors if they are not otherwise used.
var (
_ context.Context
_ grpc.ClientConnInterface
)
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion6
// StorageServiceClient is the client API for StorageService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type StorageServiceClient interface {
Disks(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*DisksResponse, error)
}
type storageServiceClient struct {
cc grpc.ClientConnInterface
}
func NewStorageServiceClient(cc grpc.ClientConnInterface) StorageServiceClient {
return &storageServiceClient{cc}
}
func (c *storageServiceClient) Disks(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*DisksResponse, error) {
out := new(DisksResponse)
err := c.cc.Invoke(ctx, "/storage.StorageService/Disks", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// StorageServiceServer is the server API for StorageService service.
type StorageServiceServer interface {
Disks(context.Context, *emptypb.Empty) (*DisksResponse, error)
}
// UnimplementedStorageServiceServer can be embedded to have forward compatible implementations.
type UnimplementedStorageServiceServer struct {
}
func (*UnimplementedStorageServiceServer) Disks(context.Context, *emptypb.Empty) (*DisksResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Disks not implemented")
}
func RegisterStorageServiceServer(s *grpc.Server, srv StorageServiceServer) {
s.RegisterService(&_StorageService_serviceDesc, srv)
}
func _StorageService_Disks_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(emptypb.Empty)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(StorageServiceServer).Disks(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/storage.StorageService/Disks",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(StorageServiceServer).Disks(ctx, req.(*emptypb.Empty))
}
return interceptor(ctx, in, info, handler)
}
var _StorageService_serviceDesc = grpc.ServiceDesc{
ServiceName: "storage.StorageService",
HandlerType: (*StorageServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "Disks",
Handler: _StorageService_Disks_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "storage/storage.proto",
}

103
pkg/machinery/api/storage/storage_grpc.pb.go Normal file
View File

@@ -0,0 +1,103 @@
// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
package storage
import (
context "context"
grpc "google.golang.org/grpc"
codes "google.golang.org/grpc/codes"
status "google.golang.org/grpc/status"
emptypb "google.golang.org/protobuf/types/known/emptypb"
)
// 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.32.0 or later.
const _ = grpc.SupportPackageIsVersion7
// StorageServiceClient is the client API for StorageService 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 StorageServiceClient interface {
Disks(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*DisksResponse, error)
}
type storageServiceClient struct {
cc grpc.ClientConnInterface
}
func NewStorageServiceClient(cc grpc.ClientConnInterface) StorageServiceClient {
return &storageServiceClient{cc}
}
func (c *storageServiceClient) Disks(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*DisksResponse, error) {
out := new(DisksResponse)
err := c.cc.Invoke(ctx, "/storage.StorageService/Disks", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// StorageServiceServer is the server API for StorageService service.
// All implementations must embed UnimplementedStorageServiceServer
// for forward compatibility
type StorageServiceServer interface {
Disks(context.Context, *emptypb.Empty) (*DisksResponse, error)
mustEmbedUnimplementedStorageServiceServer()
}
// UnimplementedStorageServiceServer must be embedded to have forward compatible implementations.
type UnimplementedStorageServiceServer struct {
}
func (UnimplementedStorageServiceServer) Disks(context.Context, *emptypb.Empty) (*DisksResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Disks not implemented")
}
func (UnimplementedStorageServiceServer) mustEmbedUnimplementedStorageServiceServer() {}
// UnsafeStorageServiceServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to StorageServiceServer will
// result in compilation errors.
type UnsafeStorageServiceServer interface {
mustEmbedUnimplementedStorageServiceServer()
}
func RegisterStorageServiceServer(s grpc.ServiceRegistrar, srv StorageServiceServer) {
s.RegisterService(&StorageService_ServiceDesc, srv)
}
func _StorageService_Disks_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(emptypb.Empty)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(StorageServiceServer).Disks(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/storage.StorageService/Disks",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(StorageServiceServer).Disks(ctx, req.(*emptypb.Empty))
}
return interceptor(ctx, in, info, handler)
}
// StorageService_ServiceDesc is the grpc.ServiceDesc for StorageService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var StorageService_ServiceDesc = grpc.ServiceDesc{
ServiceName: "storage.StorageService",
HandlerType: (*StorageServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "Disks",
Handler: _StorageService_Disks_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "storage/storage.proto",
}

127
pkg/machinery/api/time/time.pb.go
View File

@@ -1,20 +1,16 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// protoc-gen-go v1.23.0
// protoc v3.14.0
// protoc-gen-go v1.25.0
// protoc v3.15.3
// source: time/time.proto
package time
import (
context "context"
reflect "reflect"
sync "sync"
proto "github.com/golang/protobuf/proto"
grpc "google.golang.org/grpc"
codes "google.golang.org/grpc/codes"
status "google.golang.org/grpc/status"
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
emptypb "google.golang.org/protobuf/types/known/emptypb"
@@ -346,122 +342,3 @@ func file_time_time_proto_init() {
file_time_time_proto_goTypes = nil
file_time_time_proto_depIdxs = nil
}
// Reference imports to suppress errors if they are not otherwise used.
var (
_ context.Context
_ grpc.ClientConnInterface
)
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion6
// TimeServiceClient is the client API for TimeService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type TimeServiceClient interface {
Time(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*TimeResponse, error)
TimeCheck(ctx context.Context, in *TimeRequest, opts ...grpc.CallOption) (*TimeResponse, error)
}
type timeServiceClient struct {
cc grpc.ClientConnInterface
}
func NewTimeServiceClient(cc grpc.ClientConnInterface) TimeServiceClient {
return &timeServiceClient{cc}
}
func (c *timeServiceClient) Time(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*TimeResponse, error) {
out := new(TimeResponse)
err := c.cc.Invoke(ctx, "/time.TimeService/Time", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *timeServiceClient) TimeCheck(ctx context.Context, in *TimeRequest, opts ...grpc.CallOption) (*TimeResponse, error) {
out := new(TimeResponse)
err := c.cc.Invoke(ctx, "/time.TimeService/TimeCheck", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// TimeServiceServer is the server API for TimeService service.
type TimeServiceServer interface {
Time(context.Context, *emptypb.Empty) (*TimeResponse, error)
TimeCheck(context.Context, *TimeRequest) (*TimeResponse, error)
}
// UnimplementedTimeServiceServer can be embedded to have forward compatible implementations.
type UnimplementedTimeServiceServer struct {
}
func (*UnimplementedTimeServiceServer) Time(context.Context, *emptypb.Empty) (*TimeResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Time not implemented")
}
func (*UnimplementedTimeServiceServer) TimeCheck(context.Context, *TimeRequest) (*TimeResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method TimeCheck not implemented")
}
func RegisterTimeServiceServer(s *grpc.Server, srv TimeServiceServer) {
s.RegisterService(&_TimeService_serviceDesc, srv)
}
func _TimeService_Time_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(emptypb.Empty)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(TimeServiceServer).Time(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/time.TimeService/Time",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(TimeServiceServer).Time(ctx, req.(*emptypb.Empty))
}
return interceptor(ctx, in, info, handler)
}
func _TimeService_TimeCheck_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(TimeRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(TimeServiceServer).TimeCheck(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/time.TimeService/TimeCheck",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(TimeServiceServer).TimeCheck(ctx, req.(*TimeRequest))
}
return interceptor(ctx, in, info, handler)
}
var _TimeService_serviceDesc = grpc.ServiceDesc{
ServiceName: "time.TimeService",
HandlerType: (*TimeServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "Time",
Handler: _TimeService_Time_Handler,
},
{
MethodName: "TimeCheck",
Handler: _TimeService_TimeCheck_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "time/time.proto",
}

140
pkg/machinery/api/time/time_grpc.pb.go Normal file
View File

@@ -0,0 +1,140 @@
// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
package time
import (
context "context"
grpc "google.golang.org/grpc"
codes "google.golang.org/grpc/codes"
status "google.golang.org/grpc/status"
emptypb "google.golang.org/protobuf/types/known/emptypb"
)
// 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.32.0 or later.
const _ = grpc.SupportPackageIsVersion7
// TimeServiceClient is the client API for TimeService 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 TimeServiceClient interface {
Time(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*TimeResponse, error)
TimeCheck(ctx context.Context, in *TimeRequest, opts ...grpc.CallOption) (*TimeResponse, error)
}
type timeServiceClient struct {
cc grpc.ClientConnInterface
}
func NewTimeServiceClient(cc grpc.ClientConnInterface) TimeServiceClient {
return &timeServiceClient{cc}
}
func (c *timeServiceClient) Time(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*TimeResponse, error) {
out := new(TimeResponse)
err := c.cc.Invoke(ctx, "/time.TimeService/Time", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *timeServiceClient) TimeCheck(ctx context.Context, in *TimeRequest, opts ...grpc.CallOption) (*TimeResponse, error) {
out := new(TimeResponse)
err := c.cc.Invoke(ctx, "/time.TimeService/TimeCheck", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// TimeServiceServer is the server API for TimeService service.
// All implementations must embed UnimplementedTimeServiceServer
// for forward compatibility
type TimeServiceServer interface {
Time(context.Context, *emptypb.Empty) (*TimeResponse, error)
TimeCheck(context.Context, *TimeRequest) (*TimeResponse, error)
mustEmbedUnimplementedTimeServiceServer()
}
// UnimplementedTimeServiceServer must be embedded to have forward compatible implementations.
type UnimplementedTimeServiceServer struct {
}
func (UnimplementedTimeServiceServer) Time(context.Context, *emptypb.Empty) (*TimeResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Time not implemented")
}
func (UnimplementedTimeServiceServer) TimeCheck(context.Context, *TimeRequest) (*TimeResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method TimeCheck not implemented")
}
func (UnimplementedTimeServiceServer) mustEmbedUnimplementedTimeServiceServer() {}
// UnsafeTimeServiceServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to TimeServiceServer will
// result in compilation errors.
type UnsafeTimeServiceServer interface {
mustEmbedUnimplementedTimeServiceServer()
}
func RegisterTimeServiceServer(s grpc.ServiceRegistrar, srv TimeServiceServer) {
s.RegisterService(&TimeService_ServiceDesc, srv)
}
func _TimeService_Time_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(emptypb.Empty)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(TimeServiceServer).Time(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/time.TimeService/Time",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(TimeServiceServer).Time(ctx, req.(*emptypb.Empty))
}
return interceptor(ctx, in, info, handler)
}
func _TimeService_TimeCheck_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(TimeRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(TimeServiceServer).TimeCheck(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/time.TimeService/TimeCheck",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(TimeServiceServer).TimeCheck(ctx, req.(*TimeRequest))
}
return interceptor(ctx, in, info, handler)
}
// TimeService_ServiceDesc is the grpc.ServiceDesc for TimeService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var TimeService_ServiceDesc = grpc.ServiceDesc{
ServiceName: "time.TimeService",
HandlerType: (*TimeServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "Time",
Handler: _TimeService_Time_Handler,
},
{
MethodName: "TimeCheck",
Handler: _TimeService_TimeCheck_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "time/time.proto",
}

2
prototool.yaml
View File

@@ -10,7 +10,7 @@ protoc:
# The Protobuf version to use from https://github.com/protocolbuffers/protobuf/releases.
# By default use 3.8.0.
# You probably want to set this to make your builds completely reproducible.
version: 3.14.0
version: 3.15.3
# Additional paths to include with -I to protoc.
# By default, the directory of the config file is included,