feat(storage): get backend nvme controller/path cmds

README.md

@@ -90,10 +90,14 @@ alias dpu="docker run --rm --network host ghcr.io/opiproject/godpu:main"
 # connect to remote nvme/tcp controller
 nvmf0=$(dpu storage create backend nvme controller --id nvmf0 --multipath disable)
 path0=$(dpu storage create backend nvme path tcp --controller "$nvmf0" --id path0 --ip "11.11.11.2" --port 4444 --nqn nqn.2016-06.io.spdk:cnode1 --hostnqn nqn.2014-08.org.nvmexpress:uuid:feb98abe-d51f-40c8-b348-2753f3571d3c)
+dpu storage get backend nvme controller --name $nvmf0
+dpu storage get backend nvme path --name $path0
 
 # connect to local nvme/pcie ssd controller
 nvmf1=$(dpu storage create backend nvme controller --id nvmf1 --multipath disable)
 path1=$(dpu storage create backend nvme path pcie --controller "$nvmf1" --id path1 --bdf "0000:40:00.0")
+dpu storage get backend nvme controller --name $nvmf1
+dpu storage get backend nvme path --name $path1
 
 # expose volume over nvme/tcp controller
 ss0=$(dpu storage create frontend nvme subsystem --id subsys0 --nqn "nqn.2022-09.io.spdk:opitest0")

cmd/storage/backend/backend.go

@@ -77,3 +77,39 @@
 
 	return cmd
 }
+
+// NewGetCommand creates a new command to get backend resources
+func NewGetCommand() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:     "backend",
+		Aliases: []string{"b"},
+		Short:   "Gets backend resource",
+		Args:    cobra.NoArgs,
+		Run: func(c *cobra.Command, _ []string) {
+			err := c.Help()
+			cobra.CheckErr(err)
+		},
+	}
+
+	cmd.AddCommand(newGetNvmeCommand())
+
+	return cmd
+}
+
+func newGetNvmeCommand() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:     "nvme",
+		Aliases: []string{"n"},
+		Short:   "Gets nvme resource",
+		Args:    cobra.NoArgs,
+		Run: func(c *cobra.Command, _ []string) {
+			err := c.Help()
+			cobra.CheckErr(err)
+		},
+	}
+
+	cmd.AddCommand(newGetNvmeControllerCommand())
+	cmd.AddCommand(newGetNvmePathCommand())
+
+	return cmd
+}

cmd/storage/backend/nvme_controller.go

@@ -13,6 +13,7 @@
 	backendclient "github.com/opiproject/godpu/storage/backend"
 	pb "github.com/opiproject/opi-api/storage/v1alpha1/gen/go"
 	"github.com/spf13/cobra"
+	"google.golang.org/protobuf/encoding/protojson"
 )
 
 func newCreateNvmeControllerCommand() *cobra.Command {
@@ -93,3 +94,37 @@
 
 	return cmd
 }
+
+func newGetNvmeControllerCommand() *cobra.Command {
+	name := ""
+	cmd := &cobra.Command{
+		Use:     "controller",
+		Aliases: []string{"c"},
+		Short:   "Gets nvme controller representing an external nvme device",
+		Args:    cobra.NoArgs,
+		Run: func(c *cobra.Command, _ []string) {
+			addr, err := c.Flags().GetString(common.AddrCmdLineArg)
+			cobra.CheckErr(err)
+
+			timeout, err := c.Flags().GetDuration(common.TimeoutCmdLineArg)
+			cobra.CheckErr(err)
+
+			client, err := backendclient.New(addr)
+			cobra.CheckErr(err)
+
+			ctx, cancel := context.WithTimeout(context.Background(), timeout)
+			defer cancel()
+
+			ctrl, err := client.GetNvmeController(ctx, name)
+			cobra.CheckErr(err)
+
+			common.PrintResponse(protojson.Format(ctrl))
+		},
+	}
+
+	cmd.Flags().StringVar(&name, "name", "", "name of remote controller to get")
+
+	cobra.CheckErr(cmd.MarkFlagRequired("name"))
+
+	return cmd
+}

cmd/storage/backend/nvme_path.go

@@ -11,6 +11,7 @@
 	"github.com/opiproject/godpu/cmd/storage/common"
 	backendclient "github.com/opiproject/godpu/storage/backend"
 	"github.com/spf13/cobra"
+	"google.golang.org/protobuf/encoding/protojson"
 )
 
 func newCreateNvmePathCommand() *cobra.Command {
@@ -150,3 +151,37 @@
 
 	return cmd
 }
+
+func newGetNvmePathCommand() *cobra.Command {
+	name := ""
+	cmd := &cobra.Command{
+		Use:     "path",
+		Aliases: []string{"p"},
+		Short:   "Gets nvme path to an external nvme device",
+		Args:    cobra.NoArgs,
+		Run: func(c *cobra.Command, _ []string) {
+			addr, err := c.Flags().GetString(common.AddrCmdLineArg)
+			cobra.CheckErr(err)
+
+			timeout, err := c.Flags().GetDuration(common.TimeoutCmdLineArg)
+			cobra.CheckErr(err)
+
+			client, err := backendclient.New(addr)
+			cobra.CheckErr(err)
+
+			ctx, cancel := context.WithTimeout(context.Background(), timeout)
+			defer cancel()
+
+			ctrl, err := client.GetNvmePath(ctx, name)
+			cobra.CheckErr(err)
+
+			common.PrintResponse(protojson.Format(ctrl))
+		},
+	}
+
+	cmd.Flags().StringVar(&name, "name", "", "name of path to get")
+
+	cobra.CheckErr(cmd.MarkFlagRequired("name"))
+
+	return cmd
+}

cmd/storage/storage.go

@@ -32,6 +32,7 @@
 
 	cmd.AddCommand(newStorageCreateCommand())
 	cmd.AddCommand(newStorageDeleteCommand())
+	cmd.AddCommand(newStorageGetCommand())
 	cmd.AddCommand(newStorageTestCommand())
 
 	return cmd
@@ -72,3 +73,20 @@
 
 	return cmd
 }
+
+func newStorageGetCommand() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:     "get",
+		Aliases: []string{"g"},
+		Short:   "Gets resource",
+		Args:    cobra.NoArgs,
+		Run: func(c *cobra.Command, _ []string) {
+			err := c.Help()
+			cobra.CheckErr(err)
+		},
+	}
+
+	cmd.AddCommand(backend.NewGetCommand())
+
+	return cmd
+}

docker-compose.yml

@@ -185,7 +185,9 @@ services:
     command: |
       '/dpu storage test --addr opi-spdk-server:50051 && \
         nvmf0=$$(/dpu storage create backend nvme controller --addr=opi-spdk-server:50051 --id nvmf0 --multipath failover) && \
+        /dpu storage get backend nvme controller --addr=opi-spdk-server:50051 --name "$$nvmf0" && \
         path0=$$(/dpu storage create backend nvme path tcp --addr=opi-spdk-server:50051 --controller "$$nvmf0" --id path0 --ip $$(getent hosts spdk | cut -d" " -f1) --port 4444 --nqn nqn.2016-06.io.spdk:cnode1 --hostnqn nqn.2014-08.org.nvmexpress:uuid:feb98abe-d51f-40c8-b348-2753f3571d3c) && \
+        /dpu storage get backend nvme path --addr=opi-spdk-server:50051 --name "$$path0" && \
         ss0=$$(/dpu storage create frontend nvme subsystem --addr=opi-spdk-server:50051 --id subsys0 --nqn "nqn.2022-09.io.spdk:opitest1") && \
         ctrl0=$$(/dpu storage create frontend nvme controller tcp --addr=opi-spdk-server:50051 --id ctrl0 --ip "127.0.0.1" --port 4420 --subsystem "$$ss0") && \
         ns0=$$(/dpu storage create frontend nvme namespace --addr=opi-spdk-server:50051 --id namespace0 --volume "Malloc0" --subsystem "$$ss0") && \

storage/backend/nvme_controller.go

@@ -59,3 +59,23 @@ func (c *Client) DeleteNvmeController(
 
 	return err
 }
+
+// GetNvmeController gets an nvme controller representing
+// an external nvme device
+func (c *Client) GetNvmeController(
+	ctx context.Context,
+	name string,
+) (*pb.NvmeRemoteController, error) {
+	conn, connClose, err := c.connector.NewConn()
+	if err != nil {
+		return nil, err
+	}
+	defer connClose()
+
+	client := c.createNvmeClient(conn)
+	return client.GetNvmeRemoteController(
+		ctx,
+		&pb.GetNvmeRemoteControllerRequest{
+			Name: name,
+		})
+}

storage/backend/nvme_controller_test.go

@@ -173,3 +173,81 @@ func TestDeleteNvmeController(t *testing.T) {
 		})
 	}
 }
+
+func TestGetNvmeController(t *testing.T) {
+	testControllerName := "remotenvmeget"
+	testRequest := &pb.GetNvmeRemoteControllerRequest{
+		Name: testControllerName,
+	}
+	testController := &pb.NvmeRemoteController{
+		Name:      testControllerName,
+		Multipath: pb.NvmeMultipath_NVME_MULTIPATH_FAILOVER,
+	}
+	tests := map[string]struct {
+		giveClientErr    error
+		giveConnectorErr error
+		wantErr          error
+		wantRequest      *pb.GetNvmeRemoteControllerRequest
+		wantResponse     *pb.NvmeRemoteController
+		wantConnClosed   bool
+	}{
+		"successful call": {
+			giveConnectorErr: nil,
+			giveClientErr:    nil,
+			wantErr:          nil,
+			wantRequest:      proto.Clone(testRequest).(*pb.GetNvmeRemoteControllerRequest),
+			wantResponse:     proto.Clone(testController).(*pb.NvmeRemoteController),
+			wantConnClosed:   true,
+		},
+		"client err": {
+			giveConnectorErr: nil,
+			giveClientErr:    errors.New("Some client error"),
+			wantErr:          errors.New("Some client error"),
+			wantRequest:      proto.Clone(testRequest).(*pb.GetNvmeRemoteControllerRequest),
+			wantResponse:     nil,
+			wantConnClosed:   true,
+		},
+		"connector err": {
+			giveConnectorErr: errors.New("Some conn error"),
+			giveClientErr:    nil,
+			wantErr:          errors.New("Some conn error"),
+			wantRequest:      nil,
+			wantResponse:     nil,
+			wantConnClosed:   false,
+		},
+	}
+
+	for testName, tt := range tests {
+		t.Run(testName, func(t *testing.T) {
+			ctx, cancel := context.WithTimeout(context.Background(), time.Second)
+			defer cancel()
+
+			mockClient := mocks.NewNvmeRemoteControllerServiceClient(t)
+			if tt.wantRequest != nil {
+				mockClient.EXPECT().GetNvmeRemoteController(ctx, tt.wantRequest).
+					Return(proto.Clone(tt.wantResponse).(*pb.NvmeRemoteController), tt.giveClientErr)
+			}
+
+			connClosed := false
+			mockConn := mocks.NewConnector(t)
+			mockConn.EXPECT().NewConn().Return(
+				&grpc.ClientConn{},
+				func() { connClosed = true },
+				tt.giveConnectorErr,
+			)
+
+			c, _ := NewWithArgs(
+				mockConn,
+				func(grpc.ClientConnInterface) pb.NvmeRemoteControllerServiceClient {
+					return mockClient
+				},
+			)
+
+			response, err := c.GetNvmeController(ctx, testControllerName)
+
+			require.Equal(t, tt.wantErr, err)
+			require.True(t, proto.Equal(tt.wantResponse, response))
+			require.Equal(t, tt.wantConnClosed, connClosed)
+		})
+	}
+}

storage/backend/nvme_path.go

@@ -108,3 +108,22 @@ func (c *Client) DeleteNvmePath(
 
 	return err
 }
+
+// GetNvmePath gets an nvme path to an external nvme controller
+func (c *Client) GetNvmePath(
+	ctx context.Context,
+	name string,
+) (*pb.NvmePath, error) {
+	conn, connClose, err := c.connector.NewConn()
+	if err != nil {
+		return nil, err
+	}
+	defer connClose()
+
+	client := c.createNvmeClient(conn)
+	return client.GetNvmePath(
+		ctx,
+		&pb.GetNvmePathRequest{
+			Name: name,
+		})
+}