Merge pull request #1442 from FernandoOjeda/ft/virtual_authorize_storage

Add authorize block, file and portable storage to a vs.

Author: allmightyspiff

SoftLayer/CLI/routes.py

@@ -45,6 +45,7 @@
     ('virtual:upgrade', 'SoftLayer.CLI.virt.upgrade:cli'),
     ('virtual:usage', 'SoftLayer.CLI.virt.usage:cli'),
     ('virtual:credentials', 'SoftLayer.CLI.virt.credentials:cli'),
+    ('virtual:authorize-storage', 'SoftLayer.CLI.virt.authorize_storage:cli'),
     ('virtual:capacity', 'SoftLayer.CLI.virt.capacity:cli'),
     ('virtual:placementgroup', 'SoftLayer.CLI.virt.placementgroup:cli'),
     ('virtual:migrate', 'SoftLayer.CLI.virt.migrate:cli'),

SoftLayer/CLI/virt/authorize_storage.py

@@ -0,0 +1,40 @@
+"""Authorize File, Block and Portable Storage to a Virtual Server"""
+# :license: MIT, see LICENSE for more details.
+
+import click
+
+import SoftLayer
+from SoftLayer.CLI import environment
+from SoftLayer.CLI import exceptions
+from SoftLayer.CLI import formatting
+from SoftLayer.CLI import helpers
+
+
+@click.command()
+@click.argument('identifier')
+@click.option('--username-storage', '-u', type=click.STRING,
+              help="The storage username to be added to the virtual server")
+@click.option('--portable-id', type=click.INT,
+              help="The portable storage id to be added to the virtual server")
+@environment.pass_env
+def cli(env, identifier, username_storage, portable_id):
+    """Authorize File, Block and Portable Storage to a Virtual Server."""
+    virtual = SoftLayer.VSManager(env.client)
+    virtual_id = helpers.resolve_id(virtual.resolve_ids, identifier, 'virtual')
+    table = formatting.KeyValueTable(['name', 'value'], title="Portable Storage Detail")
+    table.align['name'] = 'r'
+    table.align['value'] = 'l'
+
+    if username_storage:
+        if not virtual.authorize_storage(virtual_id, username_storage):
+            raise exceptions.CLIAbort('Authorize Volume Failed')
+        env.fout('Successfully Volume: %s was Added.' % username_storage)
+    if portable_id:
+        portable_id = helpers.resolve_id(virtual.resolve_ids, portable_id, 'storage')
+        portable_result = virtual.attach_portable_storage(virtual_id, portable_id)
+
+        env.fout('Successfully Portable Storage: %i was Added.' % portable_id)
+
+        table.add_row(['Id', portable_result['id']])
+        table.add_row(['createDate', portable_result['createDate']])
+        env.fout(table)

SoftLayer/fixtures/SoftLayer_Account.py

@@ -1057,3 +1057,22 @@
             "statusId": 2
         }
     }]
+
+getNetworkStorage = [
+    {
+        "accountId": 1111111,
+        "capacityGb": 20,
+        "createDate": "2016-01-21T12:11:07-06:00",
+        "id": 1234567,
+        "nasType": "ISCSI",
+        "username": "SL01SEL301234-11",
+    },
+    {
+        "accountId": 1111111,
+        "capacityGb": 20,
+        "createDate": "2015-04-29T07:55:55-06:00",
+        "id": 4917123,
+        "nasType": "NAS",
+        "username": "SL01SEV1234567_111"
+    }
+]

SoftLayer/fixtures/SoftLayer_Virtual_Guest.py

@@ -876,3 +876,9 @@
 
 migrate = True
 migrateDedicatedHost = True
+allowAccessToNetworkStorageList = True
+
+attachDiskImage = {
+            "createDate": "2021-03-22T13:15:31-06:00",
+            "id": 1234567
+        }

SoftLayer/managers/vs.py

@@ -1404,3 +1404,45 @@ def get_hardware_guests(self):
         object_filter = {"hardware": {"virtualHost": {"id": {"operation": "not null"}}}}
         mask = "mask[virtualHost[guests[powerState]]]"
         return self.client.call('SoftLayer_Account', 'getHardware', mask=mask, filter=object_filter)
+
+    def authorize_storage(self, vs_id, username_storage):
+        """Authorize File or Block Storage to a Virtual Server.
+
+        :param int vs_id: Virtual server id.
+        :param string username_storage: Storage username.
+
+        :return: bool.
+        """
+        _filter = {"networkStorage": {"username": {"operation": username_storage}}}
+
+        storage_result = self.client.call('Account', 'getNetworkStorage', filter=_filter)
+
+        if len(storage_result) == 0:
+            raise SoftLayerError("The Storage with username: %s was not found, please"
+                                 " enter a valid storage username" % username_storage)
+
+        storage_template = [
+            {
+                "id": storage_result[0]['id'],
+                "username": username_storage
+            }
+        ]
+
+        result = self.client.call('SoftLayer_Virtual_Guest', 'allowAccessToNetworkStorageList',
+                                  storage_template, id=vs_id)
+
+        return result
+
+    def attach_portable_storage(self, vs_id, portable_id):
+        """Attach portal storage to a Virtual Server.
+
+        :param int vs_id: Virtual server id.
+        :param int portable_id: Portal storage id.
+
+        :return: SoftLayer_Provisioning_Version1_Transaction.
+        """
+        disk_id = portable_id
+        result = self.client.call('SoftLayer_Virtual_Guest', 'attachDiskImage',
+                                  disk_id, id=vs_id)
+
+        return result

docs/cli/vs.rst

@@ -267,6 +267,10 @@ If no timezone is specified, IMS local time (CST) will be assumed, which might n
    :prog: virtual migrate
    :show-nested:
 
+.. click:: SoftLayer.CLI.virt.authorize_storage:cli
+   :prog: virtual authorize-storage
+   :show-nested:
+
 Manages the migration of virutal guests. Supports migrating virtual guests on Dedicated Hosts as well.
 
 Reserved Capacity

tests/CLI/modules/vs/vs_tests.py

@@ -892,3 +892,38 @@ def test_credentail(self):
             "username": "user",
             "password": "pass"
         }])
+
+    @mock.patch('SoftLayer.CLI.formatting.confirm')
+    def test_authorize_storage_vs_no_confirm(self, confirm_mock):
+        confirm_mock.return_value = False
+        result = self.run_command(['vs', 'authorize-storage', '-u', '1234'])
+
+        self.assertEqual(result.exit_code, 2)
+
+    @mock.patch('SoftLayer.CLI.formatting.confirm')
+    def test_authorize_vs_empty(self, confirm_mock):
+        confirm_mock.return_value = True
+        storage_result = self.set_mock('SoftLayer_Account', 'getNetworkStorage')
+        storage_result.return_value = []
+        result = self.run_command(['vs', 'authorize-storage', '--username-storage=#', '1234'])
+
+        self.assertEqual(str(result.exception), "The Storage with username: # was not found, "
+                                                "please enter a valid storage username")
+
+    def test_authorize_storage_vs(self):
+        result = self.run_command(['vs', 'authorize-storage', '--username-storage=SL01SEL301234-11', '1234'])
+        self.assert_no_fail(result)
+
+    def test_authorize_portable_storage_vs(self):
+        mock = self.set_mock('SoftLayer_Virtual_Guest', 'attachDiskImage')
+        mock.return_value = {
+            "createDate": "2021-03-22T13:15:31-06:00",
+            "id": 1234567
+        }
+        result = self.run_command(['vs', 'authorize-storage', '--portable-id=12345', '1234'])
+        self.assert_no_fail(result)
+
+    def test_authorize_volume_and_portable_storage_vs(self):
+        result = self.run_command(['vs', 'authorize-storage', '--username-storage=SL01SEL301234-11',
+                                   '--portable-id=12345', '1234'])
+        self.assert_no_fail(result)

tests/managers/vs/vs_tests.py

@@ -1309,3 +1309,19 @@ def test_get_hardware_guests(self):
 
         result = self.vs.get_hardware_guests()
         self.assertEqual("NSX-T Manager", result[0]['virtualHost']['guests'][0]['hostname'])
+
+    def test_authorize_storage(self):
+        options = self.vs.authorize_storage(1234, "SL01SEL301234-11")
+
+        self.assertEqual(True, options)
+
+    def test_authorize_storage_empty(self):
+        mock = self.set_mock('SoftLayer_Account', 'getNetworkStorage')
+        mock.return_value = []
+        self.assertRaises(SoftLayer.exceptions.SoftLayerError,
+                          self.vs.authorize_storage,
+                          1234, "#")
+
+    def test_authorize_portable_storage(self):
+        options = self.vs.attach_portable_storage(1234, 1234567)
+        self.assertEqual(1234567, options['id'])