encryption.micro.go

// Code generated by protoc-gen-micro. DO NOT EDIT.
// source: encryption.proto

/*
Package encryption is a generated protocol buffer package.

It is generated from these files:
	encryption.proto

It has these top-level messages:
	Export
	Import
	KeyInfo
	Key
	AddKeyRequest
	AddKeyResponse
	GetKeyRequest
	GetKeyResponse
	AdminListKeysRequest
	AdminListKeysResponse
	AdminDeleteKeyRequest
	AdminDeleteKeyResponse
	AdminExportKeyRequest
	AdminExportKeyResponse
	AdminImportKeyRequest
	AdminImportKeyResponse
	AdminCreateKeyRequest
	AdminCreateKeyResponse
	NodeKey
	Node
	NodeInfo
	Block
	RangedBlock
	GetNodeInfoRequest
	GetNodeInfoResponse
	GetNodePlainSizeRequest
	GetNodePlainSizeResponse
	SetNodeInfoRequest
	SetNodeInfoResponse
	DeleteNodeRequest
	DeleteNodeResponse
	DeleteNodeKeyRequest
	DeleteNodeKeyResponse
	DeleteNodeSharedKeyRequest
	DeleteNodeSharedKeyResponse
	SetNodeKeyRequest
	SetNodeKeyResponse
	SetNodeBlockRequest
	SetNodeBlockResponse
	CopyNodeInfoRequest
	CopyNodeInfoResponse
*/
package encryption

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"

import (
	client "github.com/micro/go-micro/client"
	server "github.com/micro/go-micro/server"
	context "context"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ client.Option
var _ server.Option

// Client API for UserKeyStore service

type UserKeyStoreClient interface {
	AddKey(ctx context.Context, in *AddKeyRequest, opts ...client.CallOption) (*AddKeyResponse, error)
	GetKey(ctx context.Context, in *GetKeyRequest, opts ...client.CallOption) (*GetKeyResponse, error)
	AdminListKeys(ctx context.Context, in *AdminListKeysRequest, opts ...client.CallOption) (*AdminListKeysResponse, error)
	AdminCreateKey(ctx context.Context, in *AdminCreateKeyRequest, opts ...client.CallOption) (*AdminCreateKeyResponse, error)
	AdminDeleteKey(ctx context.Context, in *AdminDeleteKeyRequest, opts ...client.CallOption) (*AdminDeleteKeyResponse, error)
	AdminExportKey(ctx context.Context, in *AdminExportKeyRequest, opts ...client.CallOption) (*AdminExportKeyResponse, error)
	AdminImportKey(ctx context.Context, in *AdminImportKeyRequest, opts ...client.CallOption) (*AdminImportKeyResponse, error)
}

type userKeyStoreClient struct {
	c           client.Client
	serviceName string
}

func NewUserKeyStoreClient(serviceName string, c client.Client) UserKeyStoreClient {
	if c == nil {
		c = client.NewClient()
	}
	if len(serviceName) == 0 {
		serviceName = "encryption"
	}
	return &userKeyStoreClient{
		c:           c,
		serviceName: serviceName,
	}
}

func (c *userKeyStoreClient) AddKey(ctx context.Context, in *AddKeyRequest, opts ...client.CallOption) (*AddKeyResponse, error) {
	req := c.c.NewRequest(c.serviceName, "UserKeyStore.AddKey", in)
	out := new(AddKeyResponse)
	err := c.c.Call(ctx, req, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *userKeyStoreClient) GetKey(ctx context.Context, in *GetKeyRequest, opts ...client.CallOption) (*GetKeyResponse, error) {
	req := c.c.NewRequest(c.serviceName, "UserKeyStore.GetKey", in)
	out := new(GetKeyResponse)
	err := c.c.Call(ctx, req, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *userKeyStoreClient) AdminListKeys(ctx context.Context, in *AdminListKeysRequest, opts ...client.CallOption) (*AdminListKeysResponse, error) {
	req := c.c.NewRequest(c.serviceName, "UserKeyStore.AdminListKeys", in)
	out := new(AdminListKeysResponse)
	err := c.c.Call(ctx, req, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *userKeyStoreClient) AdminCreateKey(ctx context.Context, in *AdminCreateKeyRequest, opts ...client.CallOption) (*AdminCreateKeyResponse, error) {
	req := c.c.NewRequest(c.serviceName, "UserKeyStore.AdminCreateKey", in)
	out := new(AdminCreateKeyResponse)
	err := c.c.Call(ctx, req, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *userKeyStoreClient) AdminDeleteKey(ctx context.Context, in *AdminDeleteKeyRequest, opts ...client.CallOption) (*AdminDeleteKeyResponse, error) {
	req := c.c.NewRequest(c.serviceName, "UserKeyStore.AdminDeleteKey", in)
	out := new(AdminDeleteKeyResponse)
	err := c.c.Call(ctx, req, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *userKeyStoreClient) AdminExportKey(ctx context.Context, in *AdminExportKeyRequest, opts ...client.CallOption) (*AdminExportKeyResponse, error) {
	req := c.c.NewRequest(c.serviceName, "UserKeyStore.AdminExportKey", in)
	out := new(AdminExportKeyResponse)
	err := c.c.Call(ctx, req, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *userKeyStoreClient) AdminImportKey(ctx context.Context, in *AdminImportKeyRequest, opts ...client.CallOption) (*AdminImportKeyResponse, error) {
	req := c.c.NewRequest(c.serviceName, "UserKeyStore.AdminImportKey", in)
	out := new(AdminImportKeyResponse)
	err := c.c.Call(ctx, req, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// Server API for UserKeyStore service

type UserKeyStoreHandler interface {
	AddKey(context.Context, *AddKeyRequest, *AddKeyResponse) error
	GetKey(context.Context, *GetKeyRequest, *GetKeyResponse) error
	AdminListKeys(context.Context, *AdminListKeysRequest, *AdminListKeysResponse) error
	AdminCreateKey(context.Context, *AdminCreateKeyRequest, *AdminCreateKeyResponse) error
	AdminDeleteKey(context.Context, *AdminDeleteKeyRequest, *AdminDeleteKeyResponse) error
	AdminExportKey(context.Context, *AdminExportKeyRequest, *AdminExportKeyResponse) error
	AdminImportKey(context.Context, *AdminImportKeyRequest, *AdminImportKeyResponse) error
}

func RegisterUserKeyStoreHandler(s server.Server, hdlr UserKeyStoreHandler, opts ...server.HandlerOption) {
	s.Handle(s.NewHandler(&UserKeyStore{hdlr}, opts...))
}

type UserKeyStore struct {
	UserKeyStoreHandler
}

func (h *UserKeyStore) AddKey(ctx context.Context, in *AddKeyRequest, out *AddKeyResponse) error {
	return h.UserKeyStoreHandler.AddKey(ctx, in, out)
}

func (h *UserKeyStore) GetKey(ctx context.Context, in *GetKeyRequest, out *GetKeyResponse) error {
	return h.UserKeyStoreHandler.GetKey(ctx, in, out)
}

func (h *UserKeyStore) AdminListKeys(ctx context.Context, in *AdminListKeysRequest, out *AdminListKeysResponse) error {
	return h.UserKeyStoreHandler.AdminListKeys(ctx, in, out)
}

func (h *UserKeyStore) AdminCreateKey(ctx context.Context, in *AdminCreateKeyRequest, out *AdminCreateKeyResponse) error {
	return h.UserKeyStoreHandler.AdminCreateKey(ctx, in, out)
}

func (h *UserKeyStore) AdminDeleteKey(ctx context.Context, in *AdminDeleteKeyRequest, out *AdminDeleteKeyResponse) error {
	return h.UserKeyStoreHandler.AdminDeleteKey(ctx, in, out)
}

func (h *UserKeyStore) AdminExportKey(ctx context.Context, in *AdminExportKeyRequest, out *AdminExportKeyResponse) error {
	return h.UserKeyStoreHandler.AdminExportKey(ctx, in, out)
}

func (h *UserKeyStore) AdminImportKey(ctx context.Context, in *AdminImportKeyRequest, out *AdminImportKeyResponse) error {
	return h.UserKeyStoreHandler.AdminImportKey(ctx, in, out)
}

// Client API for NodeKeyManager service

type NodeKeyManagerClient interface {
	GetNodeInfo(ctx context.Context, in *GetNodeInfoRequest, opts ...client.CallOption) (*GetNodeInfoResponse, error)
	GetNodePlainSize(ctx context.Context, in *GetNodePlainSizeRequest, opts ...client.CallOption) (*GetNodePlainSizeResponse, error)
	SetNodeInfo(ctx context.Context, opts ...client.CallOption) (NodeKeyManager_SetNodeInfoClient, error)
	CopyNodeInfo(ctx context.Context, in *CopyNodeInfoRequest, opts ...client.CallOption) (*CopyNodeInfoResponse, error)
	DeleteNode(ctx context.Context, in *DeleteNodeRequest, opts ...client.CallOption) (*DeleteNodeResponse, error)
	DeleteNodeKey(ctx context.Context, in *DeleteNodeKeyRequest, opts ...client.CallOption) (*DeleteNodeKeyResponse, error)
	DeleteNodeSharedKey(ctx context.Context, in *DeleteNodeSharedKeyRequest, opts ...client.CallOption) (*DeleteNodeSharedKeyResponse, error)
}

type nodeKeyManagerClient struct {
	c           client.Client
	serviceName string
}

func NewNodeKeyManagerClient(serviceName string, c client.Client) NodeKeyManagerClient {
	if c == nil {
		c = client.NewClient()
	}
	if len(serviceName) == 0 {
		serviceName = "encryption"
	}
	return &nodeKeyManagerClient{
		c:           c,
		serviceName: serviceName,
	}
}

func (c *nodeKeyManagerClient) GetNodeInfo(ctx context.Context, in *GetNodeInfoRequest, opts ...client.CallOption) (*GetNodeInfoResponse, error) {
	req := c.c.NewRequest(c.serviceName, "NodeKeyManager.GetNodeInfo", in)
	out := new(GetNodeInfoResponse)
	err := c.c.Call(ctx, req, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nodeKeyManagerClient) GetNodePlainSize(ctx context.Context, in *GetNodePlainSizeRequest, opts ...client.CallOption) (*GetNodePlainSizeResponse, error) {
	req := c.c.NewRequest(c.serviceName, "NodeKeyManager.GetNodePlainSize", in)
	out := new(GetNodePlainSizeResponse)
	err := c.c.Call(ctx, req, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nodeKeyManagerClient) SetNodeInfo(ctx context.Context, opts ...client.CallOption) (NodeKeyManager_SetNodeInfoClient, error) {
	req := c.c.NewRequest(c.serviceName, "NodeKeyManager.SetNodeInfo", &SetNodeInfoRequest{})
	stream, err := c.c.Stream(ctx, req, opts...)
	if err != nil {
		return nil, err
	}
	return &nodeKeyManagerSetNodeInfoClient{stream}, nil
}

type NodeKeyManager_SetNodeInfoClient interface {
	SendMsg(interface{}) error
	RecvMsg(interface{}) error
	Close() error
	Send(*SetNodeInfoRequest) error
}

type nodeKeyManagerSetNodeInfoClient struct {
	stream client.Streamer
}

func (x *nodeKeyManagerSetNodeInfoClient) Close() error {
	return x.stream.Close()
}

func (x *nodeKeyManagerSetNodeInfoClient) SendMsg(m interface{}) error {
	return x.stream.Send(m)
}

func (x *nodeKeyManagerSetNodeInfoClient) RecvMsg(m interface{}) error {
	return x.stream.Recv(m)
}

func (x *nodeKeyManagerSetNodeInfoClient) Send(m *SetNodeInfoRequest) error {
	return x.stream.Send(m)
}

func (c *nodeKeyManagerClient) CopyNodeInfo(ctx context.Context, in *CopyNodeInfoRequest, opts ...client.CallOption) (*CopyNodeInfoResponse, error) {
	req := c.c.NewRequest(c.serviceName, "NodeKeyManager.CopyNodeInfo", in)
	out := new(CopyNodeInfoResponse)
	err := c.c.Call(ctx, req, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nodeKeyManagerClient) DeleteNode(ctx context.Context, in *DeleteNodeRequest, opts ...client.CallOption) (*DeleteNodeResponse, error) {
	req := c.c.NewRequest(c.serviceName, "NodeKeyManager.DeleteNode", in)
	out := new(DeleteNodeResponse)
	err := c.c.Call(ctx, req, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nodeKeyManagerClient) DeleteNodeKey(ctx context.Context, in *DeleteNodeKeyRequest, opts ...client.CallOption) (*DeleteNodeKeyResponse, error) {
	req := c.c.NewRequest(c.serviceName, "NodeKeyManager.DeleteNodeKey", in)
	out := new(DeleteNodeKeyResponse)
	err := c.c.Call(ctx, req, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nodeKeyManagerClient) DeleteNodeSharedKey(ctx context.Context, in *DeleteNodeSharedKeyRequest, opts ...client.CallOption) (*DeleteNodeSharedKeyResponse, error) {
	req := c.c.NewRequest(c.serviceName, "NodeKeyManager.DeleteNodeSharedKey", in)
	out := new(DeleteNodeSharedKeyResponse)
	err := c.c.Call(ctx, req, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// Server API for NodeKeyManager service

type NodeKeyManagerHandler interface {
	GetNodeInfo(context.Context, *GetNodeInfoRequest, *GetNodeInfoResponse) error
	GetNodePlainSize(context.Context, *GetNodePlainSizeRequest, *GetNodePlainSizeResponse) error
	SetNodeInfo(context.Context, NodeKeyManager_SetNodeInfoStream) error
	CopyNodeInfo(context.Context, *CopyNodeInfoRequest, *CopyNodeInfoResponse) error
	DeleteNode(context.Context, *DeleteNodeRequest, *DeleteNodeResponse) error
	DeleteNodeKey(context.Context, *DeleteNodeKeyRequest, *DeleteNodeKeyResponse) error
	DeleteNodeSharedKey(context.Context, *DeleteNodeSharedKeyRequest, *DeleteNodeSharedKeyResponse) error
}

func RegisterNodeKeyManagerHandler(s server.Server, hdlr NodeKeyManagerHandler, opts ...server.HandlerOption) {
	s.Handle(s.NewHandler(&NodeKeyManager{hdlr}, opts...))
}

type NodeKeyManager struct {
	NodeKeyManagerHandler
}

func (h *NodeKeyManager) GetNodeInfo(ctx context.Context, in *GetNodeInfoRequest, out *GetNodeInfoResponse) error {
	return h.NodeKeyManagerHandler.GetNodeInfo(ctx, in, out)
}

func (h *NodeKeyManager) GetNodePlainSize(ctx context.Context, in *GetNodePlainSizeRequest, out *GetNodePlainSizeResponse) error {
	return h.NodeKeyManagerHandler.GetNodePlainSize(ctx, in, out)
}

func (h *NodeKeyManager) SetNodeInfo(ctx context.Context, stream server.Streamer) error {
	return h.NodeKeyManagerHandler.SetNodeInfo(ctx, &nodeKeyManagerSetNodeInfoStream{stream})
}

type NodeKeyManager_SetNodeInfoStream interface {
	SendMsg(interface{}) error
	RecvMsg(interface{}) error
	Close() error
	Recv() (*SetNodeInfoRequest, error)
}

type nodeKeyManagerSetNodeInfoStream struct {
	stream server.Streamer
}

func (x *nodeKeyManagerSetNodeInfoStream) Close() error {
	return x.stream.Close()
}

func (x *nodeKeyManagerSetNodeInfoStream) SendMsg(m interface{}) error {
	return x.stream.Send(m)
}

func (x *nodeKeyManagerSetNodeInfoStream) RecvMsg(m interface{}) error {
	return x.stream.Recv(m)
}

func (x *nodeKeyManagerSetNodeInfoStream) Recv() (*SetNodeInfoRequest, error) {
	m := new(SetNodeInfoRequest)
	if err := x.stream.Recv(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (h *NodeKeyManager) CopyNodeInfo(ctx context.Context, in *CopyNodeInfoRequest, out *CopyNodeInfoResponse) error {
	return h.NodeKeyManagerHandler.CopyNodeInfo(ctx, in, out)
}

func (h *NodeKeyManager) DeleteNode(ctx context.Context, in *DeleteNodeRequest, out *DeleteNodeResponse) error {
	return h.NodeKeyManagerHandler.DeleteNode(ctx, in, out)
}

func (h *NodeKeyManager) DeleteNodeKey(ctx context.Context, in *DeleteNodeKeyRequest, out *DeleteNodeKeyResponse) error {
	return h.NodeKeyManagerHandler.DeleteNodeKey(ctx, in, out)
}

func (h *NodeKeyManager) DeleteNodeSharedKey(ctx context.Context, in *DeleteNodeSharedKeyRequest, out *DeleteNodeSharedKeyResponse) error {
	return h.NodeKeyManagerHandler.DeleteNodeSharedKey(ctx, in, out)
}