mgr/dashboard: fix nvmeof api documentation

From Aviv:
POST /api/nvmeof/hosts - the description of the command it wrong IMO. It is not about creating a host. It is about allowing a host X to access subsystem Y.
GET /api/nvmeof/hosts/{subsystem_nqn} - also the description is not accurate. The command lists all hosts that are allowed to access this subsystem.
DELETE /api/nvmeof/hosts/{subsystem_nqn}/{host_nqn} - again the description should be changed as above.
POST /api/nvmeof/namespace - bad formatting of the description
GET /api/nvmeof/subsystem - the description is wrong, should say - "List all NVMeoF subsystems". And it shouldn't get any param.
POST /api/nvmeof/subsystem - few issues here. The serial_number, and max_namespaces are optional (we need to mention that). Also it is missing the --enable-ha argument that is also optional.
Some commands are missing: log_level, connection.i

Fixes: https://tracker.ceph.com/issues/64714
Signed-off-by: Nizamudeen A <nia@redhat.com>

diff --git a/src/pybind/mgr/dashboard/controllers/nvmeof.py b/src/pybind/mgr/dashboard/controllers/nvmeof.py
index 6184f6a4166d9435e8104342c97f343cac5ec7ce..b485a5aa17b22cedff3157a396c88844f1aa969f 100644 (file)
--- a/src/pybind/mgr/dashboard/controllers/nvmeof.py
+++ b/src/pybind/mgr/dashboard/controllers/nvmeof.py
@@ -17,38 +17,39 @@ else:
     @APIDoc('NVMe-oF Namespace Management API', 'NVMe-oF')
     class NvmeofNamespace(RESTController):
         @ReadPermission
+        @EndpointDoc('List all NVMeoF namespaces',
+                     parameters={
+                         'subsystem_nqn': (str, 'NVMeoF subsystem NQN')
+                     })
         def list(self, subsystem_nqn: str):
-            """
-            List all NVMeoF namespaces
-            """
             response = MessageToJson(NVMeoFClient().list_namespaces(subsystem_nqn))
             return json.loads(response)
 
         @CreatePermission
+        @EndpointDoc('Create a new NVMeoF namespace',
+                     parameters={
+                         'rbd_pool': (str, 'RBD pool name'),
+                         'rbd_image': (str, 'RBD image name'),
+                         'subsystem_nqn': (str, 'NVMeoF subsystem NQN'),
+                         'create_image': (bool, 'Create RBD image'),
+                         'image_size': (int, 'RBD image size'),
+                         'block_size': (int, 'NVMeoF namespace block size')
+                     })
         def create(self, rbd_pool: str, rbd_image: str, subsystem_nqn: str,
                    create_image: Optional[bool] = True, image_size: Optional[int] = 1024,
                    block_size: int = 512):
-            """
-            Create a new NVMeoF namespace
-            :param rbd_pool: RBD pool name
-            :param rbd_image: RBD image name
-            :param subsystem_nqn: NVMeoF subsystem NQN
-            :param create_image: Create RBD image
-            :param image_size: RBD image size
-            :param block_size: NVMeoF namespace block size
-            """
             response = NVMeoFClient().create_namespace(rbd_pool, rbd_image,
                                                        subsystem_nqn, block_size,
                                                        create_image, image_size)
             return json.loads(MessageToJson(response))
 
         @Endpoint('DELETE', path='{subsystem_nqn}')
+        @EndpointDoc('Delete an existing NVMeoF namespace',
+                     parameters={
+                         'subsystem_nqn': (str, 'NVMeoF subsystem NQN')
+                     })
         @DeletePermission
         def delete(self, subsystem_nqn: str):
-            """
-            Delete an existing NVMeoF namespace
-            :param subsystem_nqn: NVMeoF subsystem NQN
-            """
             response = NVMeoFClient().delete_namespace(subsystem_nqn)
             return json.loads(MessageToJson(response))
 
@@ -56,7 +57,7 @@ else:
     @APIDoc('NVMe-oF Subsystem Management API', 'NVMe-oF')
     class NvmeofSubsystem(RESTController):
         @ReadPermission
-        @EndpointDoc("List all NVMeoF gateways",
+        @EndpointDoc("List all NVMeoF subsystems",
                      parameters={
                          'subsystem_nqn': (str, 'NVMeoF subsystem NQN'),
                      })
@@ -68,26 +69,24 @@ else:
             return json.loads(response)
 
         @CreatePermission
-        def create(self, subsystem_nqn: str, serial_number: Optional[str] = None,
-                   max_namespaces: Optional[int] = 256):
-            """
-            Create a new NVMeoF subsystem
-
-            :param subsystem_nqn: NVMeoF subsystem NQN
-            :param serial_number: NVMeoF subsystem serial number
-            :param max_namespaces: NVMeoF subsystem maximum namespaces
-            """
-            response = NVMeoFClient().create_subsystem(subsystem_nqn, serial_number, max_namespaces)
+        @EndpointDoc('Create a new NVMeoF subsystem',
+                     parameters={
+                         'subsystem_nqn': (str, 'NVMeoF subsystem NQN'),
+                         'serial_number': (str, 'NVMeoF subsystem serial number'),
+                         'max_namespaces': (int, 'Maximum number of namespaces')
+                     })
+        def create(self, subsystem_nqn: str):
+            response = NVMeoFClient().create_subsystem(subsystem_nqn)
             return json.loads(MessageToJson(response))
 
         @DeletePermission
         @Endpoint('DELETE', path='{subsystem_nqn}')
+        @EndpointDoc('Delete an existing NVMeoF subsystem',
+                     parameters={
+                         'subsystem_nqn': (str, 'NVMeoF subsystem NQN'),
+                         'force': (bool, 'Force delete')
+                     })
         def delete(self, subsystem_nqn: str, force: Optional[bool] = False):
-            """
-            Delete an existing NVMeoF subsystem
-            :param subsystem_nqn: NVMeoF subsystem NQN
-            :param force: Force delete
-            """
             response = NVMeoFClient().delete_subsystem(subsystem_nqn, force)
             return json.loads(MessageToJson(response))
 
@@ -95,31 +94,31 @@ else:
     @APIDoc('NVMe-oF Host Management API', 'NVMe-oF')
     class NvmeofHost(RESTController):
         @ReadPermission
+        @EndpointDoc('List all allowed hosts for an NVMeoF subsystem',
+                     parameters={
+                         'subsystem_nqn': (str, 'NVMeoF subsystem NQN')
+                     })
         def list(self, subsystem_nqn: str):
-            """
-            List all NVMeoF hosts
-            :param subsystem_nqn: NVMeoF subsystem NQN
-            """
             response = MessageToJson(NVMeoFClient().list_hosts(subsystem_nqn))
             return json.loads(response)
 
         @CreatePermission
+        @EndpointDoc('Allow hosts to access an NVMeoF subsystem',
+                     parameters={
+                         'subsystem_nqn': (str, 'NVMeoF subsystem NQN'),
+                         'host_nqn': (str, 'NVMeoF host NQN')
+                     })
         def create(self, subsystem_nqn: str, host_nqn: str):
-            """
-            Create a new NVMeoF host
-            :param subsystem_nqn: NVMeoF subsystem NQN
-            :param host_nqn: NVMeoF host NQN
-            """
             response = NVMeoFClient().add_host(subsystem_nqn, host_nqn)
             return json.loads(MessageToJson(response))
 
         @DeletePermission
+        @EndpointDoc('Disallow hosts from accessing an NVMeoF subsystem',
+                     parameters={
+                         'subsystem_nqn': (str, 'NVMeoF subsystem NQN'),
+                         'host_nqn': (str, 'NVMeoF host NQN')
+                     })
         def delete(self, subsystem_nqn: str, host_nqn: str):
-            """
-            Delete an existing NVMeoF host
-            :param subsystem_nqn: NVMeoF subsystem NQN
-            :param host_nqn: NVMeoF host NQN
-            """
             response = NVMeoFClient().remove_host(subsystem_nqn, host_nqn)
             return json.loads(MessageToJson(response))
 
@@ -127,33 +126,33 @@ else:
     @APIDoc('NVMe-oF Listener Management API', 'NVMe-oF')
     class NvmeofListener(RESTController):
         @ReadPermission
+        @EndpointDoc('List all NVMeoF listeners',
+                     parameters={
+                         'subsystem_nqn': (str, 'NVMeoF subsystem NQN')
+                     })
         def list(self, subsystem_nqn: str):
-            """
-            List all NVMeoF listeners
-            :param nqn: NVMeoF subsystem NQN
-            """
             response = MessageToJson(NVMeoFClient().list_listeners(subsystem_nqn))
             return json.loads(response)
 
         @CreatePermission
+        @EndpointDoc('Create a new NVMeoF listener',
+                     parameters={
+                         'nqn': (str, 'NVMeoF subsystem NQN'),
+                         'gateway': (str, 'NVMeoF gateway'),
+                         'traddr': (str, 'NVMeoF transport address')
+                     })
         def create(self, nqn: str, gateway: str, traddr: Optional[str] = None):
-            """
-            Create a new NVMeoF listener
-            :param nqn: NVMeoF subsystem NQN
-            :param gateway: NVMeoF gateway
-            :param traddr: NVMeoF transport address
-            """
             response = NVMeoFClient().create_listener(nqn, gateway, traddr)
             return json.loads(MessageToJson(response))
 
         @DeletePermission
+        @EndpointDoc('Delete an existing NVMeoF listener',
+                     parameters={
+                         'nqn': (str, 'NVMeoF subsystem NQN'),
+                         'gateway': (str, 'NVMeoF gateway'),
+                         'traddr': (str, 'NVMeoF transport address')
+                     })
         def delete(self, nqn: str, gateway: str, traddr: Optional[str] = None):
-            """
-            Delete an existing NVMeoF listener
-            :param nqn: NVMeoF subsystem NQN
-            :param gateway: NVMeoF gateway
-            :param traddr: NVMeoF transport address
-            """
             response = NVMeoFClient().delete_listener(nqn, gateway, traddr)
             return json.loads(MessageToJson(response))
 
@@ -162,9 +161,7 @@ else:
     class NvmeofGateway(RESTController):
         @ReadPermission
         @Endpoint()
+        @EndpointDoc('List all NVMeoF gateways')
         def info(self):
-            """
-            Get NVMeoF gateway information
-            """
             response = MessageToJson(NVMeoFClient().gateway_info())
             return json.loads(response)

diff --git a/src/pybind/mgr/dashboard/openapi.yaml b/src/pybind/mgr/dashboard/openapi.yaml
index ec3ae76cb6540cbf2c7ca4159d8a39cc6e2e3d9e..3429a117b99a7b5ddb61ad75268480bcb0f51f36 100644 (file)
--- a/src/pybind/mgr/dashboard/openapi.yaml
+++ b/src/pybind/mgr/dashboard/openapi.yaml
@@ -7641,7 +7641,6 @@ paths:
       - NFS-Ganesha
   /api/nvmeof/gateway/info:
     get:
-      description: "\n            Get NVMeoF gateway information\n            "
       parameters: []
       responses:
         '200':
@@ -7660,13 +7659,11 @@ paths:
             trace.
       security:
       - jwt: []
+      summary: List all NVMeoF gateways
       tags:
       - NVMe-oF
   /api/nvmeof/hosts:
     post:
-      description: "\n            Create a new NVMeoF host\n            :param subsystem_nqn:\
-        \ NVMeoF subsystem NQN\n            :param host_nqn: NVMeoF host NQN\n   \
-        \         "
       parameters: []
       requestBody:
         content:
@@ -7674,8 +7671,10 @@ paths:
             schema:
               properties:
                 host_nqn:
+                  description: NVMeoF host NQN
                   type: string
                 subsystem_nqn:
+                  description: NVMeoF subsystem NQN
                   type: string
               required:
               - subsystem_nqn
@@ -7703,14 +7702,14 @@ paths:
             trace.
       security:
       - jwt: []
+      summary: Allow hosts to access an NVMeoF subsystem
       tags:
       - NVMe-oF
   /api/nvmeof/hosts/{subsystem_nqn}:
     get:
-      description: "\n            List all NVMeoF hosts\n            :param subsystem_nqn:\
-        \ NVMeoF subsystem NQN\n            "
       parameters:
-      - in: path
+      - description: NVMeoF subsystem NQN
+        in: path
         name: subsystem_nqn
         required: true
         schema:
@@ -7732,20 +7731,20 @@ paths:
             trace.
       security:
       - jwt: []
+      summary: List all allowed hosts for an NVMeoF subsystem
       tags:
       - NVMe-oF
   /api/nvmeof/hosts/{subsystem_nqn}/{host_nqn}:
     delete:
-      description: "\n            Delete an existing NVMeoF host\n            :param\
-        \ subsystem_nqn: NVMeoF subsystem NQN\n            :param host_nqn: NVMeoF\
-        \ host NQN\n            "
       parameters:
-      - in: path
+      - description: NVMeoF subsystem NQN
+        in: path
         name: subsystem_nqn
         required: true
         schema:
           type: string
-      - in: path
+      - description: NVMeoF host NQN
+        in: path
         name: host_nqn
         required: true
         schema:
@@ -7772,14 +7771,14 @@ paths:
             trace.
       security:
       - jwt: []
+      summary: Disallow hosts from accessing an NVMeoF subsystem
       tags:
       - NVMe-oF
   /api/nvmeof/listener:
     get:
-      description: "\n            List all NVMeoF listeners\n            :param nqn:\
-        \ NVMeoF subsystem NQN\n            "
       parameters:
-      - in: query
+      - description: NVMeoF subsystem NQN
+        in: query
         name: subsystem_nqn
         required: true
         schema:
@@ -7801,12 +7800,10 @@ paths:
             trace.
       security:
       - jwt: []
+      summary: List all NVMeoF listeners
       tags:
       - NVMe-oF
     post:
-      description: "\n            Create a new NVMeoF listener\n            :param\
-        \ nqn: NVMeoF subsystem NQN\n            :param gateway: NVMeoF gateway\n\
-        \            :param traddr: NVMeoF transport address\n            "
       parameters: []
       requestBody:
         content:
@@ -7814,10 +7811,13 @@ paths:
             schema:
               properties:
                 gateway:
+                  description: NVMeoF gateway
                   type: string
                 nqn:
+                  description: NVMeoF subsystem NQN
                   type: string
                 traddr:
+                  description: NVMeoF transport address
                   type: string
               required:
               - nqn
@@ -7845,25 +7845,26 @@ paths:
             trace.
       security:
       - jwt: []
+      summary: Create a new NVMeoF listener
       tags:
       - NVMe-oF
   /api/nvmeof/listener/{nqn}/{gateway}:
     delete:
-      description: "\n            Delete an existing NVMeoF listener\n           \
-        \ :param nqn: NVMeoF subsystem NQN\n            :param gateway: NVMeoF gateway\n\
-        \            :param traddr: NVMeoF transport address\n            "
       parameters:
-      - in: path
+      - description: NVMeoF subsystem NQN
+        in: path
         name: nqn
         required: true
         schema:
           type: string
-      - in: path
+      - description: NVMeoF gateway
+        in: path
         name: gateway
         required: true
         schema:
           type: string
       - allowEmptyValue: true
+        description: NVMeoF transport address
         in: query
         name: traddr
         schema:
@@ -7890,16 +7891,11 @@ paths:
             trace.
       security:
       - jwt: []
+      summary: Delete an existing NVMeoF listener
       tags:
       - NVMe-oF
   /api/nvmeof/namespace:
     post:
-      description: "\n            Create a new NVMeoF namespace\n            :param\
-        \ rbd_pool: RBD pool name\n            :param rbd_image: RBD image name\n\
-        \            :param subsystem_nqn: NVMeoF subsystem NQN\n            :param\
-        \ create_image: Create RBD image\n            :param image_size: RBD image\
-        \ size\n            :param block_size: NVMeoF namespace block size\n     \
-        \       "
       parameters: []
       requestBody:
         content:
@@ -7908,18 +7904,24 @@ paths:
               properties:
                 block_size:
                   default: 512
+                  description: NVMeoF namespace block size
                   type: integer
                 create_image:
                   default: true
+                  description: Create RBD image
                   type: boolean
                 image_size:
                   default: 1024
+                  description: RBD image size
                   type: integer
                 rbd_image:
+                  description: RBD image name
                   type: string
                 rbd_pool:
+                  description: RBD pool name
                   type: string
                 subsystem_nqn:
+                  description: NVMeoF subsystem NQN
                   type: string
               required:
               - rbd_pool
@@ -7948,14 +7950,14 @@ paths:
             trace.
       security:
       - jwt: []
+      summary: Create a new NVMeoF namespace
       tags:
       - NVMe-oF
   /api/nvmeof/namespace/{subsystem_nqn}:
     delete:
-      description: "\n            Delete an existing NVMeoF namespace\n          \
-        \  :param subsystem_nqn: NVMeoF subsystem NQN\n            "
       parameters:
-      - in: path
+      - description: NVMeoF subsystem NQN
+        in: path
         name: subsystem_nqn
         required: true
         schema:
@@ -7982,12 +7984,13 @@ paths:
             trace.
       security:
       - jwt: []
+      summary: Delete an existing NVMeoF namespace
       tags:
       - NVMe-oF
     get:
-      description: "\n            List all NVMeoF namespaces\n            "
       parameters:
-      - in: path
+      - description: NVMeoF subsystem NQN
+        in: path
         name: subsystem_nqn
         required: true
         schema:
@@ -8009,6 +8012,7 @@ paths:
             trace.
       security:
       - jwt: []
+      summary: List all NVMeoF namespaces
       tags:
       - NVMe-oF
   /api/nvmeof/subsystem:
@@ -8037,26 +8041,18 @@ paths:
             trace.
       security:
       - jwt: []
-      summary: List all NVMeoF gateways
+      summary: List all NVMeoF subsystems
       tags:
       - NVMe-oF
     post:
-      description: "\n            Create a new NVMeoF subsystem\n\n            :param\
-        \ subsystem_nqn: NVMeoF subsystem NQN\n            :param serial_number: NVMeoF\
-        \ subsystem serial number\n            :param max_namespaces: NVMeoF subsystem\
-        \ maximum namespaces\n            "
       parameters: []
       requestBody:
         content:
           application/json:
             schema:
               properties:
-                max_namespaces:
-                  default: 256
-                  type: integer
-                serial_number:
-                  type: integer
                 subsystem_nqn:
+                  description: NVMeoF subsystem NQN
                   type: string
               required:
               - subsystem_nqn
@@ -8083,20 +8079,20 @@ paths:
             trace.
       security:
       - jwt: []
+      summary: Create a new NVMeoF subsystem
       tags:
       - NVMe-oF
   /api/nvmeof/subsystem/{subsystem_nqn}:
     delete:
-      description: "\n            Delete an existing NVMeoF subsystem\n          \
-        \  :param subsystem_nqn: NVMeoF subsystem NQN\n            :param force: Force\
-        \ delete\n            "
       parameters:
-      - in: path
+      - description: NVMeoF subsystem NQN
+        in: path
         name: subsystem_nqn
         required: true
         schema:
           type: string
       - default: false
+        description: Force delete
         in: query
         name: force
         schema:
@@ -8123,6 +8119,7 @@ paths:
             trace.
       security:
       - jwt: []
+      summary: Delete an existing NVMeoF subsystem
       tags:
       - NVMe-oF
   /api/osd:

diff --git a/src/pybind/mgr/dashboard/services/nvmeof_client.py b/src/pybind/mgr/dashboard/services/nvmeof_client.py
index 131bfff2aeb9ce30a550db99a333c7fcc94936ae..c51d7e80edb70a4946393f6c49af08b25463aea8 100644 (file)
--- a/src/pybind/mgr/dashboard/services/nvmeof_client.py
+++ b/src/pybind/mgr/dashboard/services/nvmeof_client.py
@@ -25,18 +25,14 @@ else:
             logger.info('Found nvmeof gateway at %s', self.gateway_addr)
             self.stub = pb2_grpc.GatewayStub(self.channel)
 
-        def list_subsystems(self, subsystem_nqn: Optional[str] = None,
-                            serial_number: Optional[str] = None):
+        def list_subsystems(self, subsystem_nqn: Optional[str] = None):
             return self.stub.list_subsystems(pb2.list_subsystems_req(
-                subsystem_nqn=subsystem_nqn,
-                serial_number=serial_number
+                subsystem_nqn=subsystem_nqn
             ))
 
-        def create_subsystem(self, subsystem_nqn: str, serial_number: str, max_namespaces: int):
+        def create_subsystem(self, subsystem_nqn: str):
             return self.stub.create_subsystem(pb2.create_subsystem_req(
-                subsystem_nqn=subsystem_nqn,
-                serial_number=serial_number,
-                max_namespaces=int(max_namespaces)
+                subsystem_nqn=subsystem_nqn
             ))
 
         def delete_subsystem(self, subsystem_nqn: str, force: Optional[bool] = False):

diff --git a/src/pybind/mgr/dashboard/services/proto/gateway_pb2_grpc.py b/src/pybind/mgr/dashboard/services/proto/gateway_pb2_grpc.py
index cc97bb26c53bfad5a678d2dde52fca3208c538b6..599142a16668b31a62ddf6ab5a391dca5004a87e 100644 (file)
--- a/src/pybind/mgr/dashboard/services/proto/gateway_pb2_grpc.py
+++ b/src/pybind/mgr/dashboard/services/proto/gateway_pb2_grpc.py
@@ -15,120 +15,120 @@ class GatewayStub(object):
             channel: A grpc.Channel.
         """
         self.namespace_add = channel.unary_unary(
-                '/Gateway/namespace_add',
-                request_serializer=gateway__pb2.namespace_add_req.SerializeToString,
-                response_deserializer=gateway__pb2.nsid_status.FromString,
-                )
+            '/Gateway/namespace_add',
+            request_serializer=gateway__pb2.namespace_add_req.SerializeToString,
+            response_deserializer=gateway__pb2.nsid_status.FromString,
+        )
         self.create_subsystem = channel.unary_unary(
-                '/Gateway/create_subsystem',
-                request_serializer=gateway__pb2.create_subsystem_req.SerializeToString,
-                response_deserializer=gateway__pb2.req_status.FromString,
-                )
+            '/Gateway/create_subsystem',
+            request_serializer=gateway__pb2.create_subsystem_req.SerializeToString,
+            response_deserializer=gateway__pb2.req_status.FromString,
+        )
         self.delete_subsystem = channel.unary_unary(
-                '/Gateway/delete_subsystem',
-                request_serializer=gateway__pb2.delete_subsystem_req.SerializeToString,
-                response_deserializer=gateway__pb2.req_status.FromString,
-                )
+            '/Gateway/delete_subsystem',
+            request_serializer=gateway__pb2.delete_subsystem_req.SerializeToString,
+            response_deserializer=gateway__pb2.req_status.FromString,
+        )
         self.list_namespaces = channel.unary_unary(
-                '/Gateway/list_namespaces',
-                request_serializer=gateway__pb2.list_namespaces_req.SerializeToString,
-                response_deserializer=gateway__pb2.namespaces_info.FromString,
-                )
+            '/Gateway/list_namespaces',
+            request_serializer=gateway__pb2.list_namespaces_req.SerializeToString,
+            response_deserializer=gateway__pb2.namespaces_info.FromString,
+        )
         self.namespace_resize = channel.unary_unary(
-                '/Gateway/namespace_resize',
-                request_serializer=gateway__pb2.namespace_resize_req.SerializeToString,
-                response_deserializer=gateway__pb2.req_status.FromString,
-                )
+            '/Gateway/namespace_resize',
+            request_serializer=gateway__pb2.namespace_resize_req.SerializeToString,
+            response_deserializer=gateway__pb2.req_status.FromString,
+        )
         self.namespace_get_io_stats = channel.unary_unary(
-                '/Gateway/namespace_get_io_stats',
-                request_serializer=gateway__pb2.namespace_get_io_stats_req.SerializeToString,
-                response_deserializer=gateway__pb2.namespace_io_stats_info.FromString,
-                )
+            '/Gateway/namespace_get_io_stats',
+            request_serializer=gateway__pb2.namespace_get_io_stats_req.SerializeToString,
+            response_deserializer=gateway__pb2.namespace_io_stats_info.FromString,
+        )
         self.namespace_set_qos_limits = channel.unary_unary(
-                '/Gateway/namespace_set_qos_limits',
-                request_serializer=gateway__pb2.namespace_set_qos_req.SerializeToString,
-                response_deserializer=gateway__pb2.req_status.FromString,
-                )
+            '/Gateway/namespace_set_qos_limits',
+            request_serializer=gateway__pb2.namespace_set_qos_req.SerializeToString,
+            response_deserializer=gateway__pb2.req_status.FromString,
+        )
         self.namespace_change_load_balancing_group = channel.unary_unary(
-                '/Gateway/namespace_change_load_balancing_group',
-                request_serializer=gateway__pb2.namespace_change_load_balancing_group_req.SerializeToString,
-                response_deserializer=gateway__pb2.req_status.FromString,
-                )
+            '/Gateway/namespace_change_load_balancing_group',
+            request_serializer=gateway__pb2.namespace_change_load_balancing_group_req.SerializeToString,
+            response_deserializer=gateway__pb2.req_status.FromString,
+        )
         self.namespace_delete = channel.unary_unary(
-                '/Gateway/namespace_delete',
-                request_serializer=gateway__pb2.namespace_delete_req.SerializeToString,
-                response_deserializer=gateway__pb2.req_status.FromString,
-                )
+            '/Gateway/namespace_delete',
+            request_serializer=gateway__pb2.namespace_delete_req.SerializeToString,
+            response_deserializer=gateway__pb2.req_status.FromString,
+        )
         self.add_host = channel.unary_unary(
-                '/Gateway/add_host',
-                request_serializer=gateway__pb2.add_host_req.SerializeToString,
-                response_deserializer=gateway__pb2.req_status.FromString,
-                )
+            '/Gateway/add_host',
+            request_serializer=gateway__pb2.add_host_req.SerializeToString,
+            response_deserializer=gateway__pb2.req_status.FromString,
+        )
         self.remove_host = channel.unary_unary(
-                '/Gateway/remove_host',
-                request_serializer=gateway__pb2.remove_host_req.SerializeToString,
-                response_deserializer=gateway__pb2.req_status.FromString,
-                )
+            '/Gateway/remove_host',
+            request_serializer=gateway__pb2.remove_host_req.SerializeToString,
+            response_deserializer=gateway__pb2.req_status.FromString,
+        )
         self.list_hosts = channel.unary_unary(
-                '/Gateway/list_hosts',
-                request_serializer=gateway__pb2.list_hosts_req.SerializeToString,
-                response_deserializer=gateway__pb2.hosts_info.FromString,
-                )
+            '/Gateway/list_hosts',
+            request_serializer=gateway__pb2.list_hosts_req.SerializeToString,
+            response_deserializer=gateway__pb2.hosts_info.FromString,
+        )
         self.list_connections = channel.unary_unary(
-                '/Gateway/list_connections',
-                request_serializer=gateway__pb2.list_connections_req.SerializeToString,
-                response_deserializer=gateway__pb2.connections_info.FromString,
-                )
+            '/Gateway/list_connections',
+            request_serializer=gateway__pb2.list_connections_req.SerializeToString,
+            response_deserializer=gateway__pb2.connections_info.FromString,
+        )
         self.create_listener = channel.unary_unary(
-                '/Gateway/create_listener',
-                request_serializer=gateway__pb2.create_listener_req.SerializeToString,
-                response_deserializer=gateway__pb2.req_status.FromString,
-                )
+            '/Gateway/create_listener',
+            request_serializer=gateway__pb2.create_listener_req.SerializeToString,
+            response_deserializer=gateway__pb2.req_status.FromString,
+        )
         self.delete_listener = channel.unary_unary(
-                '/Gateway/delete_listener',
-                request_serializer=gateway__pb2.delete_listener_req.SerializeToString,
-                response_deserializer=gateway__pb2.req_status.FromString,
-                )
+            '/Gateway/delete_listener',
+            request_serializer=gateway__pb2.delete_listener_req.SerializeToString,
+            response_deserializer=gateway__pb2.req_status.FromString,
+        )
         self.list_listeners = channel.unary_unary(
-                '/Gateway/list_listeners',
-                request_serializer=gateway__pb2.list_listeners_req.SerializeToString,
-                response_deserializer=gateway__pb2.listeners_info.FromString,
-                )
+            '/Gateway/list_listeners',
+            request_serializer=gateway__pb2.list_listeners_req.SerializeToString,
+            response_deserializer=gateway__pb2.listeners_info.FromString,
+        )
         self.list_subsystems = channel.unary_unary(
-                '/Gateway/list_subsystems',
-                request_serializer=gateway__pb2.list_subsystems_req.SerializeToString,
-                response_deserializer=gateway__pb2.subsystems_info_cli.FromString,
-                )
+            '/Gateway/list_subsystems',
+            request_serializer=gateway__pb2.list_subsystems_req.SerializeToString,
+            response_deserializer=gateway__pb2.subsystems_info_cli.FromString,
+        )
         self.get_subsystems = channel.unary_unary(
-                '/Gateway/get_subsystems',
-                request_serializer=gateway__pb2.get_subsystems_req.SerializeToString,
-                response_deserializer=gateway__pb2.subsystems_info.FromString,
-                )
+            '/Gateway/get_subsystems',
+            request_serializer=gateway__pb2.get_subsystems_req.SerializeToString,
+            response_deserializer=gateway__pb2.subsystems_info.FromString,
+        )
         self.set_ana_state = channel.unary_unary(
-                '/Gateway/set_ana_state',
-                request_serializer=gateway__pb2.ana_info.SerializeToString,
-                response_deserializer=gateway__pb2.req_status.FromString,
-                )
+            '/Gateway/set_ana_state',
+            request_serializer=gateway__pb2.ana_info.SerializeToString,
+            response_deserializer=gateway__pb2.req_status.FromString,
+        )
         self.get_spdk_nvmf_log_flags_and_level = channel.unary_unary(
-                '/Gateway/get_spdk_nvmf_log_flags_and_level',
-                request_serializer=gateway__pb2.get_spdk_nvmf_log_flags_and_level_req.SerializeToString,
-                response_deserializer=gateway__pb2.spdk_nvmf_log_flags_and_level_info.FromString,
-                )
+            '/Gateway/get_spdk_nvmf_log_flags_and_level',
+            request_serializer=gateway__pb2.get_spdk_nvmf_log_flags_and_level_req.SerializeToString,
+            response_deserializer=gateway__pb2.spdk_nvmf_log_flags_and_level_info.FromString,
+        )
         self.disable_spdk_nvmf_logs = channel.unary_unary(
-                '/Gateway/disable_spdk_nvmf_logs',
-                request_serializer=gateway__pb2.disable_spdk_nvmf_logs_req.SerializeToString,
-                response_deserializer=gateway__pb2.req_status.FromString,
-                )
+            '/Gateway/disable_spdk_nvmf_logs',
+            request_serializer=gateway__pb2.disable_spdk_nvmf_logs_req.SerializeToString,
+            response_deserializer=gateway__pb2.req_status.FromString,
+        )
         self.set_spdk_nvmf_logs = channel.unary_unary(
-                '/Gateway/set_spdk_nvmf_logs',
-                request_serializer=gateway__pb2.set_spdk_nvmf_logs_req.SerializeToString,
-                response_deserializer=gateway__pb2.req_status.FromString,
-                )
+            '/Gateway/set_spdk_nvmf_logs',
+            request_serializer=gateway__pb2.set_spdk_nvmf_logs_req.SerializeToString,
+            response_deserializer=gateway__pb2.req_status.FromString,
+        )
         self.get_gateway_info = channel.unary_unary(
-                '/Gateway/get_gateway_info',
-                request_serializer=gateway__pb2.get_gateway_info_req.SerializeToString,
-                response_deserializer=gateway__pb2.gateway_info.FromString,
-                )
+            '/Gateway/get_gateway_info',
+            request_serializer=gateway__pb2.get_gateway_info_req.SerializeToString,
+            response_deserializer=gateway__pb2.gateway_info.FromString,
+        )
 
 
 class GatewayServicer(object):
@@ -298,518 +298,519 @@ class GatewayServicer(object):
 
 def add_GatewayServicer_to_server(servicer, server):
     rpc_method_handlers = {
-            'namespace_add': grpc.unary_unary_rpc_method_handler(
-                    servicer.namespace_add,
-                    request_deserializer=gateway__pb2.namespace_add_req.FromString,
-                    response_serializer=gateway__pb2.nsid_status.SerializeToString,
-            ),
-            'create_subsystem': grpc.unary_unary_rpc_method_handler(
-                    servicer.create_subsystem,
-                    request_deserializer=gateway__pb2.create_subsystem_req.FromString,
-                    response_serializer=gateway__pb2.req_status.SerializeToString,
-            ),
-            'delete_subsystem': grpc.unary_unary_rpc_method_handler(
-                    servicer.delete_subsystem,
-                    request_deserializer=gateway__pb2.delete_subsystem_req.FromString,
-                    response_serializer=gateway__pb2.req_status.SerializeToString,
-            ),
-            'list_namespaces': grpc.unary_unary_rpc_method_handler(
-                    servicer.list_namespaces,
-                    request_deserializer=gateway__pb2.list_namespaces_req.FromString,
-                    response_serializer=gateway__pb2.namespaces_info.SerializeToString,
-            ),
-            'namespace_resize': grpc.unary_unary_rpc_method_handler(
-                    servicer.namespace_resize,
-                    request_deserializer=gateway__pb2.namespace_resize_req.FromString,
-                    response_serializer=gateway__pb2.req_status.SerializeToString,
-            ),
-            'namespace_get_io_stats': grpc.unary_unary_rpc_method_handler(
-                    servicer.namespace_get_io_stats,
-                    request_deserializer=gateway__pb2.namespace_get_io_stats_req.FromString,
-                    response_serializer=gateway__pb2.namespace_io_stats_info.SerializeToString,
-            ),
-            'namespace_set_qos_limits': grpc.unary_unary_rpc_method_handler(
-                    servicer.namespace_set_qos_limits,
-                    request_deserializer=gateway__pb2.namespace_set_qos_req.FromString,
-                    response_serializer=gateway__pb2.req_status.SerializeToString,
-            ),
-            'namespace_change_load_balancing_group': grpc.unary_unary_rpc_method_handler(
-                    servicer.namespace_change_load_balancing_group,
-                    request_deserializer=gateway__pb2.namespace_change_load_balancing_group_req.FromString,
-                    response_serializer=gateway__pb2.req_status.SerializeToString,
-            ),
-            'namespace_delete': grpc.unary_unary_rpc_method_handler(
-                    servicer.namespace_delete,
-                    request_deserializer=gateway__pb2.namespace_delete_req.FromString,
-                    response_serializer=gateway__pb2.req_status.SerializeToString,
-            ),
-            'add_host': grpc.unary_unary_rpc_method_handler(
-                    servicer.add_host,
-                    request_deserializer=gateway__pb2.add_host_req.FromString,
-                    response_serializer=gateway__pb2.req_status.SerializeToString,
-            ),
-            'remove_host': grpc.unary_unary_rpc_method_handler(
-                    servicer.remove_host,
-                    request_deserializer=gateway__pb2.remove_host_req.FromString,
-                    response_serializer=gateway__pb2.req_status.SerializeToString,
-            ),
-            'list_hosts': grpc.unary_unary_rpc_method_handler(
-                    servicer.list_hosts,
-                    request_deserializer=gateway__pb2.list_hosts_req.FromString,
-                    response_serializer=gateway__pb2.hosts_info.SerializeToString,
-            ),
-            'list_connections': grpc.unary_unary_rpc_method_handler(
-                    servicer.list_connections,
-                    request_deserializer=gateway__pb2.list_connections_req.FromString,
-                    response_serializer=gateway__pb2.connections_info.SerializeToString,
-            ),
-            'create_listener': grpc.unary_unary_rpc_method_handler(
-                    servicer.create_listener,
-                    request_deserializer=gateway__pb2.create_listener_req.FromString,
-                    response_serializer=gateway__pb2.req_status.SerializeToString,
-            ),
-            'delete_listener': grpc.unary_unary_rpc_method_handler(
-                    servicer.delete_listener,
-                    request_deserializer=gateway__pb2.delete_listener_req.FromString,
-                    response_serializer=gateway__pb2.req_status.SerializeToString,
-            ),
-            'list_listeners': grpc.unary_unary_rpc_method_handler(
-                    servicer.list_listeners,
-                    request_deserializer=gateway__pb2.list_listeners_req.FromString,
-                    response_serializer=gateway__pb2.listeners_info.SerializeToString,
-            ),
-            'list_subsystems': grpc.unary_unary_rpc_method_handler(
-                    servicer.list_subsystems,
-                    request_deserializer=gateway__pb2.list_subsystems_req.FromString,
-                    response_serializer=gateway__pb2.subsystems_info_cli.SerializeToString,
-            ),
-            'get_subsystems': grpc.unary_unary_rpc_method_handler(
-                    servicer.get_subsystems,
-                    request_deserializer=gateway__pb2.get_subsystems_req.FromString,
-                    response_serializer=gateway__pb2.subsystems_info.SerializeToString,
-            ),
-            'set_ana_state': grpc.unary_unary_rpc_method_handler(
-                    servicer.set_ana_state,
-                    request_deserializer=gateway__pb2.ana_info.FromString,
-                    response_serializer=gateway__pb2.req_status.SerializeToString,
-            ),
-            'get_spdk_nvmf_log_flags_and_level': grpc.unary_unary_rpc_method_handler(
-                    servicer.get_spdk_nvmf_log_flags_and_level,
-                    request_deserializer=gateway__pb2.get_spdk_nvmf_log_flags_and_level_req.FromString,
-                    response_serializer=gateway__pb2.spdk_nvmf_log_flags_and_level_info.SerializeToString,
-            ),
-            'disable_spdk_nvmf_logs': grpc.unary_unary_rpc_method_handler(
-                    servicer.disable_spdk_nvmf_logs,
-                    request_deserializer=gateway__pb2.disable_spdk_nvmf_logs_req.FromString,
-                    response_serializer=gateway__pb2.req_status.SerializeToString,
-            ),
-            'set_spdk_nvmf_logs': grpc.unary_unary_rpc_method_handler(
-                    servicer.set_spdk_nvmf_logs,
-                    request_deserializer=gateway__pb2.set_spdk_nvmf_logs_req.FromString,
-                    response_serializer=gateway__pb2.req_status.SerializeToString,
-            ),
-            'get_gateway_info': grpc.unary_unary_rpc_method_handler(
-                    servicer.get_gateway_info,
-                    request_deserializer=gateway__pb2.get_gateway_info_req.FromString,
-                    response_serializer=gateway__pb2.gateway_info.SerializeToString,
-            ),
+        'namespace_add': grpc.unary_unary_rpc_method_handler(
+            servicer.namespace_add,
+            request_deserializer=gateway__pb2.namespace_add_req.FromString,
+            response_serializer=gateway__pb2.nsid_status.SerializeToString,
+        ),
+        'create_subsystem': grpc.unary_unary_rpc_method_handler(
+            servicer.create_subsystem,
+            request_deserializer=gateway__pb2.create_subsystem_req.FromString,
+            response_serializer=gateway__pb2.req_status.SerializeToString,
+        ),
+        'delete_subsystem': grpc.unary_unary_rpc_method_handler(
+            servicer.delete_subsystem,
+            request_deserializer=gateway__pb2.delete_subsystem_req.FromString,
+            response_serializer=gateway__pb2.req_status.SerializeToString,
+        ),
+        'list_namespaces': grpc.unary_unary_rpc_method_handler(
+            servicer.list_namespaces,
+            request_deserializer=gateway__pb2.list_namespaces_req.FromString,
+            response_serializer=gateway__pb2.namespaces_info.SerializeToString,
+        ),
+        'namespace_resize': grpc.unary_unary_rpc_method_handler(
+            servicer.namespace_resize,
+            request_deserializer=gateway__pb2.namespace_resize_req.FromString,
+            response_serializer=gateway__pb2.req_status.SerializeToString,
+        ),
+        'namespace_get_io_stats': grpc.unary_unary_rpc_method_handler(
+            servicer.namespace_get_io_stats,
+            request_deserializer=gateway__pb2.namespace_get_io_stats_req.FromString,
+            response_serializer=gateway__pb2.namespace_io_stats_info.SerializeToString,
+        ),
+        'namespace_set_qos_limits': grpc.unary_unary_rpc_method_handler(
+            servicer.namespace_set_qos_limits,
+            request_deserializer=gateway__pb2.namespace_set_qos_req.FromString,
+            response_serializer=gateway__pb2.req_status.SerializeToString,
+        ),
+        'namespace_change_load_balancing_group': grpc.unary_unary_rpc_method_handler(
+            servicer.namespace_change_load_balancing_group,
+            request_deserializer=gateway__pb2.namespace_change_load_balancing_group_req.FromString,
+            response_serializer=gateway__pb2.req_status.SerializeToString,
+        ),
+        'namespace_delete': grpc.unary_unary_rpc_method_handler(
+            servicer.namespace_delete,
+            request_deserializer=gateway__pb2.namespace_delete_req.FromString,
+            response_serializer=gateway__pb2.req_status.SerializeToString,
+        ),
+        'add_host': grpc.unary_unary_rpc_method_handler(
+            servicer.add_host,
+            request_deserializer=gateway__pb2.add_host_req.FromString,
+            response_serializer=gateway__pb2.req_status.SerializeToString,
+        ),
+        'remove_host': grpc.unary_unary_rpc_method_handler(
+            servicer.remove_host,
+            request_deserializer=gateway__pb2.remove_host_req.FromString,
+            response_serializer=gateway__pb2.req_status.SerializeToString,
+        ),
+        'list_hosts': grpc.unary_unary_rpc_method_handler(
+            servicer.list_hosts,
+            request_deserializer=gateway__pb2.list_hosts_req.FromString,
+            response_serializer=gateway__pb2.hosts_info.SerializeToString,
+        ),
+        'list_connections': grpc.unary_unary_rpc_method_handler(
+            servicer.list_connections,
+            request_deserializer=gateway__pb2.list_connections_req.FromString,
+            response_serializer=gateway__pb2.connections_info.SerializeToString,
+        ),
+        'create_listener': grpc.unary_unary_rpc_method_handler(
+            servicer.create_listener,
+            request_deserializer=gateway__pb2.create_listener_req.FromString,
+            response_serializer=gateway__pb2.req_status.SerializeToString,
+        ),
+        'delete_listener': grpc.unary_unary_rpc_method_handler(
+            servicer.delete_listener,
+            request_deserializer=gateway__pb2.delete_listener_req.FromString,
+            response_serializer=gateway__pb2.req_status.SerializeToString,
+        ),
+        'list_listeners': grpc.unary_unary_rpc_method_handler(
+            servicer.list_listeners,
+            request_deserializer=gateway__pb2.list_listeners_req.FromString,
+            response_serializer=gateway__pb2.listeners_info.SerializeToString,
+        ),
+        'list_subsystems': grpc.unary_unary_rpc_method_handler(
+            servicer.list_subsystems,
+            request_deserializer=gateway__pb2.list_subsystems_req.FromString,
+            response_serializer=gateway__pb2.subsystems_info_cli.SerializeToString,
+        ),
+        'get_subsystems': grpc.unary_unary_rpc_method_handler(
+            servicer.get_subsystems,
+            request_deserializer=gateway__pb2.get_subsystems_req.FromString,
+            response_serializer=gateway__pb2.subsystems_info.SerializeToString,
+        ),
+        'set_ana_state': grpc.unary_unary_rpc_method_handler(
+            servicer.set_ana_state,
+            request_deserializer=gateway__pb2.ana_info.FromString,
+            response_serializer=gateway__pb2.req_status.SerializeToString,
+        ),
+        'get_spdk_nvmf_log_flags_and_level': grpc.unary_unary_rpc_method_handler(
+            servicer.get_spdk_nvmf_log_flags_and_level,
+            request_deserializer=gateway__pb2.get_spdk_nvmf_log_flags_and_level_req.FromString,
+            response_serializer=gateway__pb2.spdk_nvmf_log_flags_and_level_info.SerializeToString,
+        ),
+        'disable_spdk_nvmf_logs': grpc.unary_unary_rpc_method_handler(
+            servicer.disable_spdk_nvmf_logs,
+            request_deserializer=gateway__pb2.disable_spdk_nvmf_logs_req.FromString,
+            response_serializer=gateway__pb2.req_status.SerializeToString,
+        ),
+        'set_spdk_nvmf_logs': grpc.unary_unary_rpc_method_handler(
+            servicer.set_spdk_nvmf_logs,
+            request_deserializer=gateway__pb2.set_spdk_nvmf_logs_req.FromString,
+            response_serializer=gateway__pb2.req_status.SerializeToString,
+        ),
+        'get_gateway_info': grpc.unary_unary_rpc_method_handler(
+            servicer.get_gateway_info,
+            request_deserializer=gateway__pb2.get_gateway_info_req.FromString,
+            response_serializer=gateway__pb2.gateway_info.SerializeToString,
+        ),
     }
     generic_handler = grpc.method_handlers_generic_handler(
-            'Gateway', rpc_method_handlers)
+        'Gateway', rpc_method_handlers)
     server.add_generic_rpc_handlers((generic_handler,))
 
-
  # This class is part of an EXPERIMENTAL API.
+
+
 class Gateway(object):
     """Missing associated documentation comment in .proto file."""
 
     @staticmethod
     def namespace_add(request,
-            target,
-            options=(),
-            channel_credentials=None,
-            call_credentials=None,
-            insecure=False,
-            compression=None,
-            wait_for_ready=None,
-            timeout=None,
-            metadata=None):
+                      target,
+                      options=(),
+                      channel_credentials=None,
+                      call_credentials=None,
+                      insecure=False,
+                      compression=None,
+                      wait_for_ready=None,
+                      timeout=None,
+                      metadata=None):
         return grpc.experimental.unary_unary(request, target, '/Gateway/namespace_add',
-            gateway__pb2.namespace_add_req.SerializeToString,
-            gateway__pb2.nsid_status.FromString,
-            options, channel_credentials,
-            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+                                             gateway__pb2.namespace_add_req.SerializeToString,
+                                             gateway__pb2.nsid_status.FromString,
+                                             options, channel_credentials,
+                                             insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
 
     @staticmethod
     def create_subsystem(request,
-            target,
-            options=(),
-            channel_credentials=None,
-            call_credentials=None,
-            insecure=False,
-            compression=None,
-            wait_for_ready=None,
-            timeout=None,
-            metadata=None):
+                         target,
+                         options=(),
+                         channel_credentials=None,
+                         call_credentials=None,
+                         insecure=False,
+                         compression=None,
+                         wait_for_ready=None,
+                         timeout=None,
+                         metadata=None):
         return grpc.experimental.unary_unary(request, target, '/Gateway/create_subsystem',
-            gateway__pb2.create_subsystem_req.SerializeToString,
-            gateway__pb2.req_status.FromString,
-            options, channel_credentials,
-            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+                                             gateway__pb2.create_subsystem_req.SerializeToString,
+                                             gateway__pb2.req_status.FromString,
+                                             options, channel_credentials,
+                                             insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
 
     @staticmethod
     def delete_subsystem(request,
-            target,
-            options=(),
-            channel_credentials=None,
-            call_credentials=None,
-            insecure=False,
-            compression=None,
-            wait_for_ready=None,
-            timeout=None,
-            metadata=None):
+                         target,
+                         options=(),
+                         channel_credentials=None,
+                         call_credentials=None,
+                         insecure=False,
+                         compression=None,
+                         wait_for_ready=None,
+                         timeout=None,
+                         metadata=None):
         return grpc.experimental.unary_unary(request, target, '/Gateway/delete_subsystem',
-            gateway__pb2.delete_subsystem_req.SerializeToString,
-            gateway__pb2.req_status.FromString,
-            options, channel_credentials,
-            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+                                             gateway__pb2.delete_subsystem_req.SerializeToString,
+                                             gateway__pb2.req_status.FromString,
+                                             options, channel_credentials,
+                                             insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
 
     @staticmethod
     def list_namespaces(request,
-            target,
-            options=(),
-            channel_credentials=None,
-            call_credentials=None,
-            insecure=False,
-            compression=None,
-            wait_for_ready=None,
-            timeout=None,
-            metadata=None):
+                        target,
+                        options=(),
+                        channel_credentials=None,
+                        call_credentials=None,
+                        insecure=False,
+                        compression=None,
+                        wait_for_ready=None,
+                        timeout=None,
+                        metadata=None):
         return grpc.experimental.unary_unary(request, target, '/Gateway/list_namespaces',
-            gateway__pb2.list_namespaces_req.SerializeToString,
-            gateway__pb2.namespaces_info.FromString,
-            options, channel_credentials,
-            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+                                             gateway__pb2.list_namespaces_req.SerializeToString,
+                                             gateway__pb2.namespaces_info.FromString,
+                                             options, channel_credentials,
+                                             insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
 
     @staticmethod
     def namespace_resize(request,
-            target,
-            options=(),
-            channel_credentials=None,
-            call_credentials=None,
-            insecure=False,
-            compression=None,
-            wait_for_ready=None,
-            timeout=None,
-            metadata=None):
+                         target,
+                         options=(),
+                         channel_credentials=None,
+                         call_credentials=None,
+                         insecure=False,
+                         compression=None,
+                         wait_for_ready=None,
+                         timeout=None,
+                         metadata=None):
         return grpc.experimental.unary_unary(request, target, '/Gateway/namespace_resize',
-            gateway__pb2.namespace_resize_req.SerializeToString,
-            gateway__pb2.req_status.FromString,
-            options, channel_credentials,
-            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+                                             gateway__pb2.namespace_resize_req.SerializeToString,
+                                             gateway__pb2.req_status.FromString,
+                                             options, channel_credentials,
+                                             insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
 
     @staticmethod
     def namespace_get_io_stats(request,
-            target,
-            options=(),
-            channel_credentials=None,
-            call_credentials=None,
-            insecure=False,
-            compression=None,
-            wait_for_ready=None,
-            timeout=None,
-            metadata=None):
+                               target,
+                               options=(),
+                               channel_credentials=None,
+                               call_credentials=None,
+                               insecure=False,
+                               compression=None,
+                               wait_for_ready=None,
+                               timeout=None,
+                               metadata=None):
         return grpc.experimental.unary_unary(request, target, '/Gateway/namespace_get_io_stats',
-            gateway__pb2.namespace_get_io_stats_req.SerializeToString,
-            gateway__pb2.namespace_io_stats_info.FromString,
-            options, channel_credentials,
-            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+                                             gateway__pb2.namespace_get_io_stats_req.SerializeToString,
+                                             gateway__pb2.namespace_io_stats_info.FromString,
+                                             options, channel_credentials,
+                                             insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
 
     @staticmethod
     def namespace_set_qos_limits(request,
-            target,
-            options=(),
-            channel_credentials=None,
-            call_credentials=None,
-            insecure=False,
-            compression=None,
-            wait_for_ready=None,
-            timeout=None,
-            metadata=None):
+                                 target,
+                                 options=(),
+                                 channel_credentials=None,
+                                 call_credentials=None,
+                                 insecure=False,
+                                 compression=None,
+                                 wait_for_ready=None,
+                                 timeout=None,
+                                 metadata=None):
         return grpc.experimental.unary_unary(request, target, '/Gateway/namespace_set_qos_limits',
-            gateway__pb2.namespace_set_qos_req.SerializeToString,
-            gateway__pb2.req_status.FromString,
-            options, channel_credentials,
-            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+                                             gateway__pb2.namespace_set_qos_req.SerializeToString,
+                                             gateway__pb2.req_status.FromString,
+                                             options, channel_credentials,
+                                             insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
 
     @staticmethod
     def namespace_change_load_balancing_group(request,
-            target,
-            options=(),
-            channel_credentials=None,
-            call_credentials=None,
-            insecure=False,
-            compression=None,
-            wait_for_ready=None,
-            timeout=None,
-            metadata=None):
+                                              target,
+                                              options=(),
+                                              channel_credentials=None,
+                                              call_credentials=None,
+                                              insecure=False,
+                                              compression=None,
+                                              wait_for_ready=None,
+                                              timeout=None,
+                                              metadata=None):
         return grpc.experimental.unary_unary(request, target, '/Gateway/namespace_change_load_balancing_group',
-            gateway__pb2.namespace_change_load_balancing_group_req.SerializeToString,
-            gateway__pb2.req_status.FromString,
-            options, channel_credentials,
-            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+                                             gateway__pb2.namespace_change_load_balancing_group_req.SerializeToString,
+                                             gateway__pb2.req_status.FromString,
+                                             options, channel_credentials,
+                                             insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
 
     @staticmethod
     def namespace_delete(request,
-            target,
-            options=(),
-            channel_credentials=None,
-            call_credentials=None,
-            insecure=False,
-            compression=None,
-            wait_for_ready=None,
-            timeout=None,
-            metadata=None):
+                         target,
+                         options=(),
+                         channel_credentials=None,
+                         call_credentials=None,
+                         insecure=False,
+                         compression=None,
+                         wait_for_ready=None,
+                         timeout=None,
+                         metadata=None):
         return grpc.experimental.unary_unary(request, target, '/Gateway/namespace_delete',
-            gateway__pb2.namespace_delete_req.SerializeToString,
-            gateway__pb2.req_status.FromString,
-            options, channel_credentials,
-            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+                                             gateway__pb2.namespace_delete_req.SerializeToString,
+                                             gateway__pb2.req_status.FromString,
+                                             options, channel_credentials,
+                                             insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
 
     @staticmethod
     def add_host(request,
-            target,
-            options=(),
-            channel_credentials=None,
-            call_credentials=None,
-            insecure=False,
-            compression=None,
-            wait_for_ready=None,
-            timeout=None,
-            metadata=None):
+                 target,
+                 options=(),
+                 channel_credentials=None,
+                 call_credentials=None,
+                 insecure=False,
+                 compression=None,
+                 wait_for_ready=None,
+                 timeout=None,
+                 metadata=None):
         return grpc.experimental.unary_unary(request, target, '/Gateway/add_host',
-            gateway__pb2.add_host_req.SerializeToString,
-            gateway__pb2.req_status.FromString,
-            options, channel_credentials,
-            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+                                             gateway__pb2.add_host_req.SerializeToString,
+                                             gateway__pb2.req_status.FromString,
+                                             options, channel_credentials,
+                                             insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
 
     @staticmethod
     def remove_host(request,
-            target,
-            options=(),
-            channel_credentials=None,
-            call_credentials=None,
-            insecure=False,
-            compression=None,
-            wait_for_ready=None,
-            timeout=None,
-            metadata=None):
+                    target,
+                    options=(),
+                    channel_credentials=None,
+                    call_credentials=None,
+                    insecure=False,
+                    compression=None,
+                    wait_for_ready=None,
+                    timeout=None,
+                    metadata=None):
         return grpc.experimental.unary_unary(request, target, '/Gateway/remove_host',
-            gateway__pb2.remove_host_req.SerializeToString,
-            gateway__pb2.req_status.FromString,
-            options, channel_credentials,
-            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+                                             gateway__pb2.remove_host_req.SerializeToString,
+                                             gateway__pb2.req_status.FromString,
+                                             options, channel_credentials,
+                                             insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
 
     @staticmethod
     def list_hosts(request,
-            target,
-            options=(),
-            channel_credentials=None,
-            call_credentials=None,
-            insecure=False,
-            compression=None,
-            wait_for_ready=None,
-            timeout=None,
-            metadata=None):
+                   target,
+                   options=(),
+                   channel_credentials=None,
+                   call_credentials=None,
+                   insecure=False,
+                   compression=None,
+                   wait_for_ready=None,
+                   timeout=None,
+                   metadata=None):
         return grpc.experimental.unary_unary(request, target, '/Gateway/list_hosts',
-            gateway__pb2.list_hosts_req.SerializeToString,
-            gateway__pb2.hosts_info.FromString,
-            options, channel_credentials,
-            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+                                             gateway__pb2.list_hosts_req.SerializeToString,
+                                             gateway__pb2.hosts_info.FromString,
+                                             options, channel_credentials,
+                                             insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
 
     @staticmethod
     def list_connections(request,
-            target,
-            options=(),
-            channel_credentials=None,
-            call_credentials=None,
-            insecure=False,
-            compression=None,
-            wait_for_ready=None,
-            timeout=None,
-            metadata=None):
+                         target,
+                         options=(),
+                         channel_credentials=None,
+                         call_credentials=None,
+                         insecure=False,
+                         compression=None,
+                         wait_for_ready=None,
+                         timeout=None,
+                         metadata=None):
         return grpc.experimental.unary_unary(request, target, '/Gateway/list_connections',
-            gateway__pb2.list_connections_req.SerializeToString,
-            gateway__pb2.connections_info.FromString,
-            options, channel_credentials,
-            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+                                             gateway__pb2.list_connections_req.SerializeToString,
+                                             gateway__pb2.connections_info.FromString,
+                                             options, channel_credentials,
+                                             insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
 
     @staticmethod
     def create_listener(request,
-            target,
-            options=(),
-            channel_credentials=None,
-            call_credentials=None,
-            insecure=False,
-            compression=None,
-            wait_for_ready=None,
-            timeout=None,
-            metadata=None):
+                        target,
+                        options=(),
+                        channel_credentials=None,
+                        call_credentials=None,
+                        insecure=False,
+                        compression=None,
+                        wait_for_ready=None,
+                        timeout=None,
+                        metadata=None):
         return grpc.experimental.unary_unary(request, target, '/Gateway/create_listener',
-            gateway__pb2.create_listener_req.SerializeToString,
-            gateway__pb2.req_status.FromString,
-            options, channel_credentials,
-            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+                                             gateway__pb2.create_listener_req.SerializeToString,
+                                             gateway__pb2.req_status.FromString,
+                                             options, channel_credentials,
+                                             insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
 
     @staticmethod
     def delete_listener(request,
-            target,
-            options=(),
-            channel_credentials=None,
-            call_credentials=None,
-            insecure=False,
-            compression=None,
-            wait_for_ready=None,
-            timeout=None,
-            metadata=None):
+                        target,
+                        options=(),
+                        channel_credentials=None,
+                        call_credentials=None,
+                        insecure=False,
+                        compression=None,
+                        wait_for_ready=None,
+                        timeout=None,
+                        metadata=None):
         return grpc.experimental.unary_unary(request, target, '/Gateway/delete_listener',
-            gateway__pb2.delete_listener_req.SerializeToString,
-            gateway__pb2.req_status.FromString,
-            options, channel_credentials,
-            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+                                             gateway__pb2.delete_listener_req.SerializeToString,
+                                             gateway__pb2.req_status.FromString,
+                                             options, channel_credentials,
+                                             insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
 
     @staticmethod
     def list_listeners(request,
-            target,
-            options=(),
-            channel_credentials=None,
-            call_credentials=None,
-            insecure=False,
-            compression=None,
-            wait_for_ready=None,
-            timeout=None,
-            metadata=None):
+                       target,
+                       options=(),
+                       channel_credentials=None,
+                       call_credentials=None,
+                       insecure=False,
+                       compression=None,
+                       wait_for_ready=None,
+                       timeout=None,
+                       metadata=None):
         return grpc.experimental.unary_unary(request, target, '/Gateway/list_listeners',
-            gateway__pb2.list_listeners_req.SerializeToString,
-            gateway__pb2.listeners_info.FromString,
-            options, channel_credentials,
-            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+                                             gateway__pb2.list_listeners_req.SerializeToString,
+                                             gateway__pb2.listeners_info.FromString,
+                                             options, channel_credentials,
+                                             insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
 
     @staticmethod
     def list_subsystems(request,
-            target,
-            options=(),
-            channel_credentials=None,
-            call_credentials=None,
-            insecure=False,
-            compression=None,
-            wait_for_ready=None,
-            timeout=None,
-            metadata=None):
+                        target,
+                        options=(),
+                        channel_credentials=None,
+                        call_credentials=None,
+                        insecure=False,
+                        compression=None,
+                        wait_for_ready=None,
+                        timeout=None,
+                        metadata=None):
         return grpc.experimental.unary_unary(request, target, '/Gateway/list_subsystems',
-            gateway__pb2.list_subsystems_req.SerializeToString,
-            gateway__pb2.subsystems_info_cli.FromString,
-            options, channel_credentials,
-            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+                                             gateway__pb2.list_subsystems_req.SerializeToString,
+                                             gateway__pb2.subsystems_info_cli.FromString,
+                                             options, channel_credentials,
+                                             insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
 
     @staticmethod
     def get_subsystems(request,
-            target,
-            options=(),
-            channel_credentials=None,
-            call_credentials=None,
-            insecure=False,
-            compression=None,
-            wait_for_ready=None,
-            timeout=None,
-            metadata=None):
+                       target,
+                       options=(),
+                       channel_credentials=None,
+                       call_credentials=None,
+                       insecure=False,
+                       compression=None,
+                       wait_for_ready=None,
+                       timeout=None,
+                       metadata=None):
         return grpc.experimental.unary_unary(request, target, '/Gateway/get_subsystems',
-            gateway__pb2.get_subsystems_req.SerializeToString,
-            gateway__pb2.subsystems_info.FromString,
-            options, channel_credentials,
-            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+                                             gateway__pb2.get_subsystems_req.SerializeToString,
+                                             gateway__pb2.subsystems_info.FromString,
+                                             options, channel_credentials,
+                                             insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
 
     @staticmethod
     def set_ana_state(request,
-            target,
-            options=(),
-            channel_credentials=None,
-            call_credentials=None,
-            insecure=False,
-            compression=None,
-            wait_for_ready=None,
-            timeout=None,
-            metadata=None):
+                      target,
+                      options=(),
+                      channel_credentials=None,
+                      call_credentials=None,
+                      insecure=False,
+                      compression=None,
+                      wait_for_ready=None,
+                      timeout=None,
+                      metadata=None):
         return grpc.experimental.unary_unary(request, target, '/Gateway/set_ana_state',
-            gateway__pb2.ana_info.SerializeToString,
-            gateway__pb2.req_status.FromString,
-            options, channel_credentials,
-            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+                                             gateway__pb2.ana_info.SerializeToString,
+                                             gateway__pb2.req_status.FromString,
+                                             options, channel_credentials,
+                                             insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
 
     @staticmethod
     def get_spdk_nvmf_log_flags_and_level(request,
-            target,
-            options=(),
-            channel_credentials=None,
-            call_credentials=None,
-            insecure=False,
-            compression=None,
-            wait_for_ready=None,
-            timeout=None,
-            metadata=None):
+                                          target,
+                                          options=(),
+                                          channel_credentials=None,
+                                          call_credentials=None,
+                                          insecure=False,
+                                          compression=None,
+                                          wait_for_ready=None,
+                                          timeout=None,
+                                          metadata=None):
         return grpc.experimental.unary_unary(request, target, '/Gateway/get_spdk_nvmf_log_flags_and_level',
-            gateway__pb2.get_spdk_nvmf_log_flags_and_level_req.SerializeToString,
-            gateway__pb2.spdk_nvmf_log_flags_and_level_info.FromString,
-            options, channel_credentials,
-            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+                                             gateway__pb2.get_spdk_nvmf_log_flags_and_level_req.SerializeToString,
+                                             gateway__pb2.spdk_nvmf_log_flags_and_level_info.FromString,
+                                             options, channel_credentials,
+                                             insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
 
     @staticmethod
     def disable_spdk_nvmf_logs(request,
-            target,
-            options=(),
-            channel_credentials=None,
-            call_credentials=None,
-            insecure=False,
-            compression=None,
-            wait_for_ready=None,
-            timeout=None,
-            metadata=None):
+                               target,
+                               options=(),
+                               channel_credentials=None,
+                               call_credentials=None,
+                               insecure=False,
+                               compression=None,
+                               wait_for_ready=None,
+                               timeout=None,
+                               metadata=None):
         return grpc.experimental.unary_unary(request, target, '/Gateway/disable_spdk_nvmf_logs',
-            gateway__pb2.disable_spdk_nvmf_logs_req.SerializeToString,
-            gateway__pb2.req_status.FromString,
-            options, channel_credentials,
-            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+                                             gateway__pb2.disable_spdk_nvmf_logs_req.SerializeToString,
+                                             gateway__pb2.req_status.FromString,
+                                             options, channel_credentials,
+                                             insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
 
     @staticmethod
     def set_spdk_nvmf_logs(request,
-            target,
-            options=(),
-            channel_credentials=None,
-            call_credentials=None,
-            insecure=False,
-            compression=None,
-            wait_for_ready=None,
-            timeout=None,
-            metadata=None):
+                           target,
+                           options=(),
+                           channel_credentials=None,
+                           call_credentials=None,
+                           insecure=False,
+                           compression=None,
+                           wait_for_ready=None,
+                           timeout=None,
+                           metadata=None):
         return grpc.experimental.unary_unary(request, target, '/Gateway/set_spdk_nvmf_logs',
-            gateway__pb2.set_spdk_nvmf_logs_req.SerializeToString,
-            gateway__pb2.req_status.FromString,
-            options, channel_credentials,
-            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+                                             gateway__pb2.set_spdk_nvmf_logs_req.SerializeToString,
+                                             gateway__pb2.req_status.FromString,
+                                             options, channel_credentials,
+                                             insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
 
     @staticmethod
     def get_gateway_info(request,
-            target,
-            options=(),
-            channel_credentials=None,
-            call_credentials=None,
-            insecure=False,
-            compression=None,
-            wait_for_ready=None,
-            timeout=None,
-            metadata=None):
+                         target,
+                         options=(),
+                         channel_credentials=None,
+                         call_credentials=None,
+                         insecure=False,
+                         compression=None,
+                         wait_for_ready=None,
+                         timeout=None,
+                         metadata=None):
         return grpc.experimental.unary_unary(request, target, '/Gateway/get_gateway_info',
-            gateway__pb2.get_gateway_info_req.SerializeToString,
-            gateway__pb2.gateway_info.FromString,
-            options, channel_credentials,
-            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+                                             gateway__pb2.get_gateway_info_req.SerializeToString,
+                                             gateway__pb2.gateway_info.FromString,
+                                             options, channel_credentials,
+                                             insecure, call_credentials, compression, wait_for_ready, timeout, metadata)