Add slcli vs create by router data.

Author: Fernando Ojeda

SoftLayer/CLI/virt/create.py

@@ -95,6 +95,8 @@ def _parse_create_args(client, args):
         "private_vlan": args.get('vlan_private', None),
         "public_subnet": args.get('subnet_public', None),
         "private_subnet": args.get('subnet_private', None),
+        "public_router": args.get('router_public', None),
+        "private_router": args.get('router_private', None),
     }
 
     # The primary disk is included in the flavor and the local_disk flag is not needed
@@ -192,6 +194,10 @@ def _parse_create_args(client, args):
               help="The ID of the public SUBNET on which you want the virtual server placed")
 @click.option('--subnet-private', type=click.INT,
               help="The ID of the private SUBNET on which you want the virtual server placed")
+@click.option('--router-public', type=click.INT,
+              help="The ID of the public ROUTER on which you want the virtual server placed")
+@click.option('--router-private', type=click.INT,
+              help="The ID of the private ROUTER on which you want the virtual server placed")
 @helpers.multi_option('--public-security-group', '-S',
                       help=('Security group ID to associate with the public interface'))
 @helpers.multi_option('--private-security-group', '-s',

SoftLayer/managers/vs.py

@@ -470,6 +470,7 @@ def _generate_create_dict(
             datacenter=None, os_code=None, image_id=None,
             dedicated=False, public_vlan=None, private_vlan=None,
             private_subnet=None, public_subnet=None,
+            public_router=None, private_router=None,
             userdata=None, nic_speed=None, disks=None, post_uri=None,
             private=False, ssh_keys=None, public_security_groups=None,
             private_security_groups=None, boot_mode=None, transient=False, **kwargs):
@@ -533,6 +534,15 @@ def _generate_create_dict(
         if datacenter:
             data["datacenter"] = {"name": datacenter}
 
+        if private_router or public_router:
+            if private_vlan or public_vlan or private_subnet or public_subnet:
+                raise exceptions.SoftLayerError("You have to select network vlan or network vlan with a subnet or "
+                                                "only router, not all options")
+            network_components = self._create_network_components(public_vlan, private_vlan,
+                                                                 private_subnet, public_subnet,
+                                                                 private_router, public_router)
+            data.update(network_components)
+
         if private_vlan or public_vlan or private_subnet or public_subnet:
             network_components = self._create_network_components(public_vlan, private_vlan,
                                                                  private_subnet, public_subnet)
@@ -581,7 +591,8 @@ def _generate_create_dict(
 
     def _create_network_components(
             self, public_vlan=None, private_vlan=None,
-            private_subnet=None, public_subnet=None):
+            private_subnet=None, public_subnet=None,
+            private_router=None, public_router=None):
         parameters = {}
         if private_vlan:
             parameters['primaryBackendNetworkComponent'] = {"networkVlan": {"id": int(private_vlan)}}
@@ -598,6 +609,12 @@ def _create_network_components(
 
             parameters['primaryBackendNetworkComponent']['networkVlan']['primarySubnet'] = {'id': int(private_subnet)}
 
+        if private_router:
+            parameters['primaryBackendNetworkComponent'] = {"router": {"id": int(private_router)}}
+
+        if public_router:
+            parameters['primaryNetworkComponent'] = {"router": {"id": int(public_router)}}
+
         return parameters
 
     @retry(logger=LOGGER)
@@ -685,14 +702,31 @@ def verify_create_instance(self, **kwargs):
         kwargs.pop('tags', None)
         create_options = self._generate_create_dict(**kwargs)
         template = self.guest.generateOrderTemplate(create_options)
-        if 'private_subnet' in kwargs or 'public_subnet' in kwargs:
+        if kwargs.get('public_router') or kwargs.get('private_router'):
+            if kwargs.get('private_vlan') or kwargs.get('public_vlan') or kwargs.get('private_subnet') \
+                    or kwargs.get('public_subnet'):
+                raise exceptions.SoftLayerError("You have to select network vlan or network vlan with a subnet or "
+                                                "only router, not all options")
+            vsi = template['virtualGuests'][0]
+            network_components = self._create_network_components(kwargs.get('public_vlan', None),
+                                                                 kwargs.get('private_vlan', None),
+                                                                 kwargs.get('private_subnet', None),
+                                                                 kwargs.get('public_subnet', None),
+                                                                 kwargs.get('private_router', None),
+                                                                 kwargs.get('public_router', None))
+            vsi.update(network_components)
+
+        if kwargs.get('private_subnet') or kwargs.get('public_subnet'):
             vsi = template['virtualGuests'][0]
             network_components = self._create_network_components(kwargs.get('public_vlan', None),
                                                                  kwargs.get('private_vlan', None),
                                                                  kwargs.get('private_subnet', None),
                                                                  kwargs.get('public_subnet', None))
             vsi.update(network_components)
 
+        print("template")
+        print(template)
+
         return template
 
     def create_instance(self, **kwargs):
@@ -1121,6 +1155,7 @@ def order_guest(self, guest_object, test=False):
         if guest_object.get('placement_id'):
             template['virtualGuests'][0]['placementGroupId'] = guest_object.get('placement_id')
 
+        print(template)
         if test:
             result = self.client.call('Product_Order', 'verifyOrder', template)
         else:

tests/CLI/modules/vs/vs_create_tests.py

@@ -93,6 +93,49 @@ def test_create_vlan_subnet(self, confirm_mock):
 
         self.assert_called_with('SoftLayer_Virtual_Guest', 'generateOrderTemplate', args=args)
 
+    @mock.patch('SoftLayer.CLI.formatting.confirm')
+    def test_create_by_router(self, confirm_mock):
+        confirm_mock.return_value = True
+
+        result = self.run_command(['vs', 'create',
+                                   '--cpu=2',
+                                   '--domain=example.com',
+                                   '--hostname=host',
+                                   '--os=UBUNTU_LATEST',
+                                   '--memory=1',
+                                   '--billing=hourly',
+                                   '--datacenter=dal05',
+                                   '--router-private=577940',
+                                   '--router-public=1639255',
+                                   '--tag=dev',
+                                   '--tag=green'])
+
+        self.assert_no_fail(result)
+        self.assert_called_with('SoftLayer_Product_Order', 'placeOrder')
+        args = ({
+                    'startCpus': 2,
+                    'maxMemory': 1024,
+                    'hostname': 'host',
+                    'domain': 'example.com',
+                    'localDiskFlag': True,
+                    'hourlyBillingFlag': True,
+                    'supplementalCreateObjectOptions': {'bootMode': None},
+                    'operatingSystemReferenceCode': 'UBUNTU_LATEST',
+                    'datacenter': {'name': 'dal05'},
+                    'primaryBackendNetworkComponent': {
+                        'router': {
+                            'id': 577940
+                        }
+                    },
+                    'primaryNetworkComponent': {
+                        'router': {
+                            'id': 1639255
+                        }
+                    }
+                },)
+
+        self.assert_called_with('SoftLayer_Virtual_Guest', 'generateOrderTemplate', args=args)
+
     @mock.patch('SoftLayer.CLI.formatting.confirm')
     def test_create_with_wait_ready(self, confirm_mock):
         mock = self.set_mock('SoftLayer_Virtual_Guest', 'getObject')

tests/managers/vs/vs_tests.py

@@ -557,6 +557,38 @@ def test_generate_private_vlan(self):
 
         self.assertEqual(data, assert_data)
 
+    def test_generate_by_router_and_vlan(self):
+        actual = self.assertRaises(
+            exceptions.SoftLayerError,
+            self.vs._generate_create_dict,
+            cpus=1,
+            memory=1,
+            hostname='test',
+            domain='example.com',
+            os_code="STRING",
+            private_router=1,
+            private_vlan=1
+        )
+
+        self.assertEqual(str(actual), "You have to select network vlan or network vlan with a subnet or only router, "
+                                      "not all options")
+
+    def test_generate_by_router_and_subnet(self):
+        actual = self.assertRaises(
+            exceptions.SoftLayerError,
+            self.vs._generate_create_dict,
+            cpus=1,
+            memory=1,
+            hostname='test',
+            domain='example.com',
+            os_code="STRING",
+            private_router=1,
+            private_subnet=1
+        )
+
+        self.assertEqual(str(actual), "You have to select network vlan or network vlan with a subnet or only router, "
+                                      "not all options")
+
     def test_generate_sec_group(self):
         data = self.vs._generate_create_dict(
             cpus=1,
@@ -596,6 +628,19 @@ def test_create_network_components_vlan_subnet_private_vlan_subnet_public(self):
 
         self.assertEqual(data, assert_data)
 
+    def test_create_network_components_by_routers(self):
+        data = self.vs._create_network_components(
+            private_router=1,
+            public_router=1
+        )
+
+        assert_data = {
+            'primaryBackendNetworkComponent': {'router': {'id': 1}},
+            'primaryNetworkComponent': {'router': {'id': 1}},
+        }
+
+        self.assertEqual(data, assert_data)
+
     def test_create_network_components_vlan_subnet_private(self):
         data = self.vs._create_network_components(
             private_vlan=1,