grpc-proxy: remove backup target relate gRPC

Longhorn-4076

Signed-off-by: Chin-Ya Huang <chin-ya.huang@suse.com>

Author: c3y1huang

generate_grpc.sh

@@ -8,7 +8,6 @@ if [ ! -e ./proto/vendor/protobuf/src/google/protobuf ]; then
     DIR="./proto/vendor/protobuf/src/google/protobuf"
     mkdir -p $DIR
     wget https://raw.githubusercontent.com/protocolbuffers/protobuf/v3.9.0/src/google/protobuf/empty.proto -P $DIR
-    wget https://raw.githubusercontent.com/protocolbuffers/protobuf/v3.9.0/src/google/protobuf/timestamp.proto -P $DIR
 fi
 DIR="./proto/vendor/github.com/longhorn/longhorn-engine/proto/ptypes"
 if [ ! -e ${DIR} ]; then

integration/rpc/proxy/proxy_pb2.py

@@ -100,31 +100,6 @@ def __init__(self, channel):
         request_serializer=proxy__pb2.ProxyEngineRequest.SerializeToString,
         response_deserializer=proxy__pb2.EngineBackupRestoreStatusProxyResponse.FromString,
         )
-    self.BackupVolumeList = channel.unary_unary(
-        '/imrpc.ProxyEngineService/BackupVolumeList',
-        request_serializer=proxy__pb2.EngineBackupVolumeListRequest.SerializeToString,
-        response_deserializer=proxy__pb2.EngineBackupVolumeListProxyResponse.FromString,
-        )
-    self.BackupVolumeGet = channel.unary_unary(
-        '/imrpc.ProxyEngineService/BackupVolumeGet',
-        request_serializer=proxy__pb2.EngineBackupVolumeGetRequest.SerializeToString,
-        response_deserializer=proxy__pb2.EngineBackupVolumeGetProxyResponse.FromString,
-        )
-    self.BackupGet = channel.unary_unary(
-        '/imrpc.ProxyEngineService/BackupGet',
-        request_serializer=proxy__pb2.EngineBackupGetRequest.SerializeToString,
-        response_deserializer=proxy__pb2.EngineBackupGetProxyResponse.FromString,
-        )
-    self.BackupConfigMetaGet = channel.unary_unary(
-        '/imrpc.ProxyEngineService/BackupConfigMetaGet',
-        request_serializer=proxy__pb2.EngineBackupConfigMetaGetRequest.SerializeToString,
-        response_deserializer=proxy__pb2.EngineBackupConfigMetaGetProxyResponse.FromString,
-        )
-    self.BackupRemove = channel.unary_unary(
-        '/imrpc.ProxyEngineService/BackupRemove',
-        request_serializer=proxy__pb2.EngineBackupRemoveRequest.SerializeToString,
-        response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
-        )
     self.ReplicaAdd = channel.unary_unary(
         '/imrpc.ProxyEngineService/ReplicaAdd',
         request_serializer=proxy__pb2.EngineReplicaAddRequest.SerializeToString,
@@ -275,41 +250,6 @@ def BackupRestoreStatus(self, request, context):
     context.set_details('Method not implemented!')
     raise NotImplementedError('Method not implemented!')
 
-  def BackupVolumeList(self, request, context):
-    # missing associated documentation comment in .proto file
-    pass
-    context.set_code(grpc.StatusCode.UNIMPLEMENTED)
-    context.set_details('Method not implemented!')
-    raise NotImplementedError('Method not implemented!')
-
-  def BackupVolumeGet(self, request, context):
-    # missing associated documentation comment in .proto file
-    pass
-    context.set_code(grpc.StatusCode.UNIMPLEMENTED)
-    context.set_details('Method not implemented!')
-    raise NotImplementedError('Method not implemented!')
-
-  def BackupGet(self, request, context):
-    # missing associated documentation comment in .proto file
-    pass
-    context.set_code(grpc.StatusCode.UNIMPLEMENTED)
-    context.set_details('Method not implemented!')
-    raise NotImplementedError('Method not implemented!')
-
-  def BackupConfigMetaGet(self, request, context):
-    # missing associated documentation comment in .proto file
-    pass
-    context.set_code(grpc.StatusCode.UNIMPLEMENTED)
-    context.set_details('Method not implemented!')
-    raise NotImplementedError('Method not implemented!')
-
-  def BackupRemove(self, request, context):
-    # missing associated documentation comment in .proto file
-    pass
-    context.set_code(grpc.StatusCode.UNIMPLEMENTED)
-    context.set_details('Method not implemented!')
-    raise NotImplementedError('Method not implemented!')
-
   def ReplicaAdd(self, request, context):
     # missing associated documentation comment in .proto file
     pass
@@ -433,31 +373,6 @@ def add_ProxyEngineServiceServicer_to_server(servicer, server):
           request_deserializer=proxy__pb2.ProxyEngineRequest.FromString,
           response_serializer=proxy__pb2.EngineBackupRestoreStatusProxyResponse.SerializeToString,
       ),
-      'BackupVolumeList': grpc.unary_unary_rpc_method_handler(
-          servicer.BackupVolumeList,
-          request_deserializer=proxy__pb2.EngineBackupVolumeListRequest.FromString,
-          response_serializer=proxy__pb2.EngineBackupVolumeListProxyResponse.SerializeToString,
-      ),
-      'BackupVolumeGet': grpc.unary_unary_rpc_method_handler(
-          servicer.BackupVolumeGet,
-          request_deserializer=proxy__pb2.EngineBackupVolumeGetRequest.FromString,
-          response_serializer=proxy__pb2.EngineBackupVolumeGetProxyResponse.SerializeToString,
-      ),
-      'BackupGet': grpc.unary_unary_rpc_method_handler(
-          servicer.BackupGet,
-          request_deserializer=proxy__pb2.EngineBackupGetRequest.FromString,
-          response_serializer=proxy__pb2.EngineBackupGetProxyResponse.SerializeToString,
-      ),
-      'BackupConfigMetaGet': grpc.unary_unary_rpc_method_handler(
-          servicer.BackupConfigMetaGet,
-          request_deserializer=proxy__pb2.EngineBackupConfigMetaGetRequest.FromString,
-          response_serializer=proxy__pb2.EngineBackupConfigMetaGetProxyResponse.SerializeToString,
-      ),
-      'BackupRemove': grpc.unary_unary_rpc_method_handler(
-          servicer.BackupRemove,
-          request_deserializer=proxy__pb2.EngineBackupRemoveRequest.FromString,
-          response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
-      ),
       'ReplicaAdd': grpc.unary_unary_rpc_method_handler(
           servicer.ReplicaAdd,
           request_deserializer=proxy__pb2.EngineReplicaAddRequest.FromString,

integration/rpc/proxy/proxy_pb2_grpc.py

@@ -3,11 +3,8 @@ package client
 import (
 	"encoding/json"
 
-	"github.com/golang/protobuf/ptypes"
 	"github.com/pkg/errors"
 
-	"github.com/longhorn/backupstore"
-
 	rpc "github.com/longhorn/longhorn-instance-manager/pkg/imrpc"
 )
 
@@ -164,196 +161,3 @@ func (c *ProxyClient) BackupRestoreStatus(serviceAddress string) (status map[str
 	}
 	return status, nil
 }
-
-func (c *ProxyClient) BackupGet(destURL string, envs []string) (info *EngineBackupInfo, err error) {
-	input := map[string]string{
-		"destURL": destURL,
-	}
-	if err := validateProxyMethodParameters(input); err != nil {
-		return nil, errors.Wrap(err, "failed to get backup")
-	}
-
-	defer func() {
-		err = errors.Wrapf(err, "%v failed to get backup", c.getProxyErrorPrefix(destURL))
-	}()
-
-	req := &rpc.EngineBackupGetRequest{
-		Envs:    envs,
-		DestUrl: destURL,
-	}
-	recv, err := c.service.BackupGet(getContextWithGRPCTimeout(c.ctx), req)
-	if err != nil {
-		return nil, err
-	}
-
-	return parseBackup(recv.Backup), nil
-}
-
-func (c *ProxyClient) BackupVolumeGet(destURL string, envs []string) (info *EngineBackupVolumeInfo, err error) {
-	input := map[string]string{
-		"destURL": destURL,
-	}
-	if err := validateProxyMethodParameters(input); err != nil {
-		return nil, errors.Wrap(err, "failed to get backup volume")
-	}
-
-	defer func() {
-		err = errors.Wrapf(err, "%v failed to get backup volume", c.getProxyErrorPrefix(destURL))
-	}()
-
-	req := &rpc.EngineBackupVolumeGetRequest{
-		Envs:    envs,
-		DestUrl: destURL,
-	}
-	recv, err := c.service.BackupVolumeGet(getContextWithGRPCTimeout(c.ctx), req)
-	if err != nil {
-		return nil, err
-	}
-
-	info = &EngineBackupVolumeInfo{
-		Name:                 recv.Volume.Name,
-		Size:                 recv.Volume.Size,
-		Labels:               recv.Volume.Labels,
-		Created:              recv.Volume.Created,
-		LastBackupName:       recv.Volume.LastBackupName,
-		LastBackupAt:         recv.Volume.LastBackupAt,
-		DataStored:           recv.Volume.DataStored,
-		Messages:             recv.Volume.Messages,
-		Backups:              parseBackups(recv.Volume.Backups),
-		BackingImageName:     recv.Volume.BackingImageName,
-		BackingImageChecksum: recv.Volume.BackingImageChecksum,
-	}
-	return info, nil
-}
-
-func (c *ProxyClient) BackupVolumeList(destURL, volumeName string, volumeOnly bool, envs []string) (info map[string]*EngineBackupVolumeInfo, err error) {
-	input := map[string]string{
-		"destURL": destURL,
-	}
-	if err := validateProxyMethodParameters(input); err != nil {
-		return nil, errors.Wrap(err, "failed to list backup for volumes")
-	}
-
-	defer func() {
-		if volumeName == "" {
-			err = errors.Wrapf(err, "%v failed to list backup for volumes", c.getProxyErrorPrefix(destURL))
-		} else {
-			err = errors.Wrapf(err, "%v failed to list backup for volume %v", c.getProxyErrorPrefix(destURL), volumeName)
-		}
-	}()
-
-	req := &rpc.EngineBackupVolumeListRequest{
-		Envs:       envs,
-		DestUrl:    destURL,
-		VolumeName: volumeName,
-		VolumeOnly: volumeOnly,
-	}
-	recv, err := c.service.BackupVolumeList(getContextWithGRPCTimeout(c.ctx), req)
-	if err != nil {
-		return nil, err
-	}
-
-	info = map[string]*EngineBackupVolumeInfo{}
-	for k, v := range recv.Volumes {
-		info[k] = &EngineBackupVolumeInfo{
-			Name:                 v.Name,
-			Size:                 v.Size,
-			Labels:               v.Labels,
-			Created:              v.Created,
-			LastBackupName:       v.LastBackupName,
-			LastBackupAt:         v.LastBackupAt,
-			DataStored:           v.DataStored,
-			Messages:             v.Messages,
-			Backups:              parseBackups(v.Backups),
-			BackingImageName:     v.BackingImageName,
-			BackingImageChecksum: v.BackingImageChecksum,
-		}
-	}
-	return info, nil
-}
-
-func parseBackups(in map[string]*rpc.EngineBackupInfo) (out map[string]*EngineBackupInfo) {
-	out = map[string]*EngineBackupInfo{}
-	for k, v := range in {
-		out[k] = parseBackup(v)
-	}
-	return out
-}
-
-func parseBackup(in *rpc.EngineBackupInfo) (out *EngineBackupInfo) {
-	return &EngineBackupInfo{
-		Name:                   in.Name,
-		URL:                    in.Url,
-		SnapshotName:           in.SnapshotName,
-		SnapshotCreated:        in.SnapshotCreated,
-		Created:                in.Created,
-		Size:                   in.Size,
-		Labels:                 in.Labels,
-		IsIncremental:          in.IsIncremental,
-		VolumeName:             in.VolumeName,
-		VolumeSize:             in.VolumeSize,
-		VolumeCreated:          in.VolumeCreated,
-		VolumeBackingImageName: in.VolumeBackingImageName,
-		Messages:               in.Messages,
-	}
-}
-
-func (c *ProxyClient) BackupConfigMetaGet(destURL string, envs []string) (meta *backupstore.ConfigMetadata, err error) {
-	input := map[string]string{
-		"destURL": destURL,
-	}
-	if err := validateProxyMethodParameters(input); err != nil {
-		return nil, errors.Wrap(err, "failed to get backup config metadata")
-	}
-
-	defer func() {
-		err = errors.Wrapf(err, "%v failed to get backup config metadata", c.getProxyErrorPrefix(destURL))
-	}()
-
-	req := &rpc.EngineBackupConfigMetaGetRequest{
-		Envs:    envs,
-		DestUrl: destURL,
-	}
-	recv, err := c.service.BackupConfigMetaGet(getContextWithGRPCTimeout(c.ctx), req)
-	if err != nil {
-		return nil, err
-	}
-
-	ts, err := ptypes.Timestamp(recv.ModificationTime)
-	if err != nil {
-		return nil, err
-	}
-
-	return &backupstore.ConfigMetadata{
-		ModificationTime: ts,
-	}, nil
-}
-
-func (c *ProxyClient) BackupRemove(destURL, volumeName string, envs []string) (err error) {
-	input := map[string]string{
-		"destURL": destURL,
-	}
-	if err := validateProxyMethodParameters(input); err != nil {
-		return errors.Wrap(err, "failed to remove backup")
-	}
-
-	defer func() {
-		if volumeName == "" {
-			err = errors.Wrapf(err, "%v failed to remove backup", c.getProxyErrorPrefix(destURL))
-		} else {
-			err = errors.Wrapf(err, "%v failed to remove backup for volume %v", c.getProxyErrorPrefix(destURL), volumeName)
-		}
-	}()
-
-	req := &rpc.EngineBackupRemoveRequest{
-		Envs:       envs,
-		DestUrl:    destURL,
-		VolumeName: volumeName,
-	}
-	_, err = c.service.BackupRemove(getContextWithGRPCTimeout(c.ctx), req)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}