domrichardson
275 lines
8.6 KiB
Go
275 lines
8.6 KiB
Go
// Hand-written gRPC bindings for keymanager.proto using JSON codec.
|
|
// To use: register the JSON codec before creating gRPC servers/clients.
|
|
|
|
package pb
|
|
|
|
import (
|
|
"context"
|
|
|
|
"google.golang.org/grpc"
|
|
"google.golang.org/grpc/codes"
|
|
"google.golang.org/grpc/status"
|
|
)
|
|
|
|
// Message types
|
|
|
|
type RegisterRequest struct {
|
|
ServerId string `json:"server_id"`
|
|
PreRegToken string `json:"pre_reg_token"`
|
|
Hostname string `json:"hostname"`
|
|
IpAddress string `json:"ip_address"`
|
|
OsInfo string `json:"os_info"`
|
|
}
|
|
|
|
type RegisterResponse struct {
|
|
AgentToken string `json:"agent_token"`
|
|
}
|
|
|
|
type SyncRequest struct {
|
|
ServerId string `json:"server_id"`
|
|
AgentToken string `json:"agent_token"`
|
|
}
|
|
|
|
type SyncResponse struct {
|
|
PublicKeys []string `json:"public_keys"`
|
|
}
|
|
|
|
type UploadKeyRequest struct {
|
|
ServerId string `json:"server_id"`
|
|
AgentToken string `json:"agent_token"`
|
|
PublicKey string `json:"public_key"`
|
|
Label string `json:"label"`
|
|
}
|
|
|
|
type UploadKeyResponse struct {
|
|
KeyId string `json:"key_id"`
|
|
}
|
|
|
|
// CommandStream message types
|
|
|
|
type ServerCommand struct {
|
|
CommandId string `json:"command_id"`
|
|
GenerateKey *GenerateKeyCmd `json:"generate_key,omitempty"`
|
|
}
|
|
|
|
type GenerateKeyCmd struct {
|
|
Label string `json:"label"`
|
|
KeyType string `json:"key_type,omitempty"`
|
|
KeySize int `json:"key_size,omitempty"`
|
|
Passphrase string `json:"passphrase,omitempty"`
|
|
Comment string `json:"comment,omitempty"`
|
|
}
|
|
|
|
type AgentMessage struct {
|
|
ServerId string `json:"server_id"`
|
|
AgentToken string `json:"agent_token"`
|
|
Ready *AgentReady `json:"ready,omitempty"`
|
|
Result *CommandResult `json:"result,omitempty"`
|
|
}
|
|
|
|
type AgentReady struct{}
|
|
|
|
type CommandResult struct {
|
|
CommandId string `json:"command_id"`
|
|
Success bool `json:"success"`
|
|
Message string `json:"message"`
|
|
}
|
|
|
|
// CommandStream server-side interface
|
|
|
|
type KeyManager_CommandStreamServer interface {
|
|
Send(*ServerCommand) error
|
|
Recv() (*AgentMessage, error)
|
|
grpc.ServerStream
|
|
}
|
|
|
|
type keyManagerCommandStreamServer struct {
|
|
grpc.ServerStream
|
|
}
|
|
|
|
func (s *keyManagerCommandStreamServer) Send(m *ServerCommand) error {
|
|
return s.ServerStream.SendMsg(m)
|
|
}
|
|
|
|
func (s *keyManagerCommandStreamServer) Recv() (*AgentMessage, error) {
|
|
m := new(AgentMessage)
|
|
if err := s.ServerStream.RecvMsg(m); err != nil {
|
|
return nil, err
|
|
}
|
|
return m, nil
|
|
}
|
|
|
|
// CommandStream client-side interface
|
|
|
|
type KeyManager_CommandStreamClient interface {
|
|
Send(*AgentMessage) error
|
|
Recv() (*ServerCommand, error)
|
|
grpc.ClientStream
|
|
}
|
|
|
|
type keyManagerCommandStreamClient struct {
|
|
grpc.ClientStream
|
|
}
|
|
|
|
func (c *keyManagerCommandStreamClient) Send(m *AgentMessage) error {
|
|
return c.ClientStream.SendMsg(m)
|
|
}
|
|
|
|
func (c *keyManagerCommandStreamClient) Recv() (*ServerCommand, error) {
|
|
m := new(ServerCommand)
|
|
if err := c.ClientStream.RecvMsg(m); err != nil {
|
|
return nil, err
|
|
}
|
|
return m, nil
|
|
}
|
|
|
|
// Server interface
|
|
|
|
type KeyManagerServer interface {
|
|
Register(context.Context, *RegisterRequest) (*RegisterResponse, error)
|
|
SyncKeys(context.Context, *SyncRequest) (*SyncResponse, error)
|
|
UploadGeneratedKey(context.Context, *UploadKeyRequest) (*UploadKeyResponse, error)
|
|
CommandStream(KeyManager_CommandStreamServer) error
|
|
}
|
|
|
|
type UnimplementedKeyManagerServer struct{}
|
|
|
|
func (UnimplementedKeyManagerServer) Register(context.Context, *RegisterRequest) (*RegisterResponse, error) {
|
|
return nil, status.Errorf(codes.Unimplemented, "method Register not implemented")
|
|
}
|
|
|
|
func (UnimplementedKeyManagerServer) SyncKeys(context.Context, *SyncRequest) (*SyncResponse, error) {
|
|
return nil, status.Errorf(codes.Unimplemented, "method SyncKeys not implemented")
|
|
}
|
|
|
|
func (UnimplementedKeyManagerServer) UploadGeneratedKey(context.Context, *UploadKeyRequest) (*UploadKeyResponse, error) {
|
|
return nil, status.Errorf(codes.Unimplemented, "method UploadGeneratedKey not implemented")
|
|
}
|
|
|
|
func (UnimplementedKeyManagerServer) CommandStream(KeyManager_CommandStreamServer) error {
|
|
return status.Errorf(codes.Unimplemented, "method CommandStream not implemented")
|
|
}
|
|
|
|
// Client interface
|
|
|
|
type KeyManagerClient interface {
|
|
Register(ctx context.Context, in *RegisterRequest, opts ...grpc.CallOption) (*RegisterResponse, error)
|
|
SyncKeys(ctx context.Context, in *SyncRequest, opts ...grpc.CallOption) (*SyncResponse, error)
|
|
UploadGeneratedKey(ctx context.Context, in *UploadKeyRequest, opts ...grpc.CallOption) (*UploadKeyResponse, error)
|
|
CommandStream(ctx context.Context, opts ...grpc.CallOption) (KeyManager_CommandStreamClient, error)
|
|
}
|
|
|
|
type keyManagerClient struct {
|
|
cc grpc.ClientConnInterface
|
|
}
|
|
|
|
func NewKeyManagerClient(cc grpc.ClientConnInterface) KeyManagerClient {
|
|
return &keyManagerClient{cc}
|
|
}
|
|
|
|
func (c *keyManagerClient) Register(ctx context.Context, in *RegisterRequest, opts ...grpc.CallOption) (*RegisterResponse, error) {
|
|
out := new(RegisterResponse)
|
|
if err := c.cc.Invoke(ctx, "/keymanager.v1.KeyManager/Register", in, out, opts...); err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *keyManagerClient) SyncKeys(ctx context.Context, in *SyncRequest, opts ...grpc.CallOption) (*SyncResponse, error) {
|
|
out := new(SyncResponse)
|
|
if err := c.cc.Invoke(ctx, "/keymanager.v1.KeyManager/SyncKeys", in, out, opts...); err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *keyManagerClient) UploadGeneratedKey(ctx context.Context, in *UploadKeyRequest, opts ...grpc.CallOption) (*UploadKeyResponse, error) {
|
|
out := new(UploadKeyResponse)
|
|
if err := c.cc.Invoke(ctx, "/keymanager.v1.KeyManager/UploadGeneratedKey", in, out, opts...); err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *keyManagerClient) CommandStream(ctx context.Context, opts ...grpc.CallOption) (KeyManager_CommandStreamClient, error) {
|
|
stream, err := c.cc.NewStream(ctx, &KeyManager_ServiceDesc.Streams[0], "/keymanager.v1.KeyManager/CommandStream", opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &keyManagerCommandStreamClient{stream}, nil
|
|
}
|
|
|
|
// Server registration
|
|
|
|
func RegisterKeyManagerServer(s grpc.ServiceRegistrar, srv KeyManagerServer) {
|
|
s.RegisterService(&KeyManager_ServiceDesc, srv)
|
|
}
|
|
|
|
var KeyManager_ServiceDesc = grpc.ServiceDesc{
|
|
ServiceName: "keymanager.v1.KeyManager",
|
|
HandlerType: (*KeyManagerServer)(nil),
|
|
Methods: []grpc.MethodDesc{
|
|
{MethodName: "Register", Handler: _KeyManager_Register_Handler},
|
|
{MethodName: "SyncKeys", Handler: _KeyManager_SyncKeys_Handler},
|
|
{MethodName: "UploadGeneratedKey", Handler: _KeyManager_UploadGeneratedKey_Handler},
|
|
},
|
|
Streams: []grpc.StreamDesc{
|
|
{
|
|
StreamName: "CommandStream",
|
|
Handler: _KeyManager_CommandStream_Handler,
|
|
ServerStreams: true,
|
|
ClientStreams: true,
|
|
},
|
|
},
|
|
Metadata: "keymanager/v1/keymanager.proto",
|
|
}
|
|
|
|
func _KeyManager_Register_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(RegisterRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(KeyManagerServer).Register(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{Server: srv, FullMethod: "/keymanager.v1.KeyManager/Register"}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(KeyManagerServer).Register(ctx, req.(*RegisterRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _KeyManager_SyncKeys_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(SyncRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(KeyManagerServer).SyncKeys(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{Server: srv, FullMethod: "/keymanager.v1.KeyManager/SyncKeys"}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(KeyManagerServer).SyncKeys(ctx, req.(*SyncRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _KeyManager_UploadGeneratedKey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(UploadKeyRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(KeyManagerServer).UploadGeneratedKey(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{Server: srv, FullMethod: "/keymanager.v1.KeyManager/UploadGeneratedKey"}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(KeyManagerServer).UploadGeneratedKey(ctx, req.(*UploadKeyRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _KeyManager_CommandStream_Handler(srv interface{}, stream grpc.ServerStream) error {
|
|
return srv.(KeyManagerServer).CommandStream(&keyManagerCommandStreamServer{stream})
|
|
}
|