Merge pull request #117 from QualiSystems/feature/borismod_40_save_vnic

Feature/borismod 40 save vnic

Author: borismod

common/utilites/command_result.py

@@ -0,0 +1,14 @@
+from re import search
+
+COMMAND_RESULT_PREFIX = "command_json_result="
+COMMAND_RESULT_POSTFIX = "=command_json_result_end"
+
+def get_result_from_command_output(output):
+
+    match = search(COMMAND_RESULT_PREFIX + '(?P<result>.*)' + COMMAND_RESULT_POSTFIX, output)
+    if not match:
+        return None
+    return match.group('result')
+
+def set_command_result(output):
+    print COMMAND_RESULT_PREFIX + str(output) + COMMAND_RESULT_POSTFIX

common/wrappers/command_wrapper.py

@@ -1,5 +1,5 @@
 DISCONNCTING_VCENERT = 'disconnecting from vcenter: {0}'
-COMMAND_ERROR = 'error has occurred while executing command: {0} error: {1}'
+COMMAND_ERROR = 'error has occurred while executing command: {0}'
 DEBUG_COMMAND_RESULT = 'finished executing with the result: {0}'
 FINISHED_EXECUTING_COMMAND = 'finished executing command: {0}'
 DEBUG_COMMAND_PARAMS = 'command params: {0}'
@@ -66,7 +66,8 @@ def execute_command_with_connection(self, connection_details, command, *args):
 
             return results
         except Exception as e:
-            logger.error(COMMAND_ERROR.format(command_name, e))
+            logger.error(COMMAND_ERROR.format(command_name))
+            logger.exception(e)
             raise
         finally:
             if si:

deployed_app_service/__main__.py

@@ -15,7 +15,7 @@ def main():
 
     vlan_id = helpers.get_user_param('VLAN_ID')
     if not vlan_id:
-        raise ValueError('VLAN_ID is missoing')
+        raise ValueError('VLAN_ID is missing')
 
     deployed_app_service.connect(vlan_spec_type, vlan_id)
 

deployed_app_service/connect.py

@@ -1,6 +1,9 @@
 import qualipy.scripts.cloudshell_scripts_helpers as helpers
 from qualipy.api.cloudshell_api import InputNameValue
+from common.utilites.command_result import get_result_from_command_output, set_command_result
+from common.logger import getLogger
 
+_logger  = getLogger('DeployedAppService')
 
 class DeployedAppService(object):
     def __init__(self, resource_model_parser):
@@ -28,11 +31,18 @@ def connect(self, access_mode, virtual_network):
     def execute_command_on_vcenter_resource(access_mode, generic_deployed_app_resource_model, virtual_network):
         session = helpers.get_api_session()
         reservation_id = helpers.get_reservation_context_details().id
-        session.ExecuteCommand(reservation_id, generic_deployed_app_resource_model.cloud_provider,
+
+        _logger.debug('Executing Connect VM command on ' + generic_deployed_app_resource_model.cloud_provider)
+
+        command_result = session.ExecuteCommand(reservation_id, generic_deployed_app_resource_model.cloud_provider,
                                'Resource',
                                'Connect VM',
                                [InputNameValue('COMMAND', "connect"),
                                 InputNameValue('VLAN_ID', virtual_network),
                                 InputNameValue('VLAN_SPEC_TYPE', access_mode),
                                 InputNameValue('VM_UUID', generic_deployed_app_resource_model.vm_uuid)],
                                True)
+
+        result = get_result_from_command_output(command_result.Output)
+        _logger.debug('Transferring result to the caller ' + result)
+        set_command_result(result)

environment_scripts/connect_all.py

@@ -1,12 +1,17 @@
+import re
+
 import qualipy.scripts.cloudshell_scripts_helpers as helpers
-from qualipy.api.cloudshell_api import InputNameValue
-from common.utilites.common_utils import first_or_default
+from qualipy.api.cloudshell_api import InputNameValue, AttributeNameValue
+from common.utilites.command_result import get_result_from_command_output
 
-from common.model_factory import ResourceModelParser
+from common.logger.service import getLogger
+_logger = getLogger('EnvironmentConnector')
 
+VIRTUAL_NETWORK_ATTRIBUTE = 'Virtual Network'
+ACCESS_MODE_ATTRIBUTE = 'Access Mode'
 
-class EnvironmentConnector(object):
 
+class EnvironmentConnector(object):
     def connect_all(self):
         """
         Connects all the VLAN Auto services to all the Deployed Apps in the same Environment
@@ -26,26 +31,39 @@ def connect_all(self):
 
         for vlan_service in vlan_services:
 
-            if not len(vlan_service.Attributes):
-                raise ValueError('No attributes on service {0}'.format(vlan_service.ServiceName))
+            _logger.debug('Connecting \'{0}\' '.format(vlan_service.ServiceName))
 
-            access_mode = self._get_attribute(vlan_service.Attributes, 'Access Mode')
-            virtual_network = self._get_attribute(vlan_service.Attributes, 'Virtual Network')
+            access_mode = self._get_attribute(vlan_service.Attributes, ACCESS_MODE_ATTRIBUTE)
+            virtual_network = self._get_attribute(vlan_service.Attributes, VIRTUAL_NETWORK_ATTRIBUTE)
 
             # Get Deployed App connected to VLAN Auto service
             connected_resources = self._get_connected_resources(connectors, vlan_service)
 
             if not connected_resources:
                 continue
 
+            if not virtual_network or virtual_network == '':
+
+                _logger.debug('Executing Auto Resolve Vlan on \'{0}\''.format(vlan_service.ServiceName))
+
+                command_result = session.ExecuteCommand(reservation_id, vlan_service.ServiceName, 'Service',
+                                                        'Auto Resolve Vlan', [], True)
+
+                virtual_network = get_result_from_command_output(command_result.Output)
+
+                _logger.debug('Auto Resolve Vlan returned Virtual Network \'{0}\''.format(virtual_network))
+
+                if not virtual_network or virtual_network == '':
+                    raise ValueError('Auto Resolve Vlan command did not return Virtual Network')
+
             for connected_resource in connected_resources:
                 self._execute_connect_command_on_connected_resource(access_mode, connected_resource, reservation_id,
-                                                                    session, virtual_network)
+                                                                    session, virtual_network, vlan_service.ServiceName)
 
     @staticmethod
     def _get_attribute(attributes, attribute_name):
         attribute = next(item for item in attributes if item.Name == attribute_name)
-        if not attribute or not attribute.Value:
+        if not attribute:
             raise ValueError('Attribute {0} is missing'.format(attribute_name))
         return attribute.Value
 
@@ -57,16 +75,32 @@ def _get_connectors(reservation_details):
     @staticmethod
     def _get_vlan_auto_services(reservation_details):
         vlan_services = [service for service in reservation_details.ReservationDescription.Services
-                         if service.ServiceName == 'VLAN Auto']
+                         if VIRTUAL_NETWORK_ATTRIBUTE in [attr.Name for attr in service.Attributes]]
         return vlan_services
 
     @staticmethod
     def _execute_connect_command_on_connected_resource(access_mode, connected_resource, reservation_id, session,
-                                                       virtual_network):
-        session.ExecuteCommand(reservation_id, connected_resource, 'Resource', 'Connect',
-                               [InputNameValue('VLAN_ID', virtual_network),
-                                InputNameValue('VLAN_SPEC_TYPE', access_mode)],
-                               True)
+                                                       virtual_network, vlan_service_name):
+
+        _logger.debug('Executing Connect command on: ' + connected_resource)
+
+        command_result = session.ExecuteCommand(reservation_id, connected_resource, 'Resource', 'Connect',
+                                                [InputNameValue('VLAN_ID', virtual_network),
+                                                 InputNameValue('VLAN_SPEC_TYPE', access_mode)], True)
+
+        result = get_result_from_command_output(command_result.Output)
+
+        if not result:
+            _logger.debug('Connect command did not return any result')
+            return
+
+        mac_address = result.replace('[\'', '').replace('\']', '')
+        _logger.debug('Setting Target Interface to: ' + mac_address)
+
+        session.SetConnectorAttributes(reservation_id,
+                                       connected_resource,
+                                       vlan_service_name,
+                                       [AttributeNameValue('Target Interface', mac_address)])
 
     @staticmethod
     def _get_connected_resources(connectors, vlan_service):

integration/integration_commands/integration_test_connect.py

@@ -12,7 +12,6 @@
 from vCenterShell.network.vlan.factory import VlanSpecFactory
 from vCenterShell.network.vlan.range_parser import VLanIdRangeParser
 from vCenterShell.network.vnic.vnic_service import VNicService
-from vCenterShell.network.vnic.vnic_updater import VnicUpdater
 from vCenterShell.vm.dvswitch_connector import VmNetworkMapping, VirtualSwitchToMachineConnector
 from vCenterShell.vm.portgroup_configurer import VirtualMachinePortGroupConfigurer
 from vCenterShell.vm.vnic_to_network_mapper import VnicToNetworkMapper

integration/integration_commands/integration_test_vnic_updater.py

@@ -1,21 +1,47 @@
+import os
 from unittest import TestCase
 
 from pyVim.connect import SmartConnect, Disconnect
 
 from common.vcenter.vmomi_service import pyVmomiService
 from tests.utils.testing_credentials import TestCredentials
-from vCenterShell.network.vnic.vnic_updater import VnicUpdater
+from vCenterShell.bootstrap import Bootstrapper
 import qualipy.scripts.cloudshell_scripts_helpers as helpers
-import qualipy.scripts.cloudshell_dev_helpers as dev_helpers
+from pyVmomi import vim
 
 class VirtualSwitchToMachineCommandIntegrationTest(TestCase):
 
+    def integration_test(self):
+
+        py_vmomi_service = pyVmomiService(SmartConnect, Disconnect)
+        cred = TestCredentials()
+        si = py_vmomi_service.connect(cred.host, cred.username, cred.password, cred.port)
+        vm = py_vmomi_service.find_vm_by_name(si, 'QualiSB/Alex', 'Ubuntu_a287f573')
+
+        os.environ['VM_UUID'] = vm.config.uuid
+        os.environ['VLAN_ID'] = '25'
+        os.environ['VLAN_SPEC_TYPE'] = 'Access'
+
+        bootstrapper = Bootstrapper()
+        executer_service = bootstrapper.get_command_executer_service()
+        executer_service.connect()
+
     def integration_test_update_vnics(self):
 
-        dev_helpers.attach_to_cloudshell_as("admin", "admin", "Global", "4571b4fe-be5d-4556-aed9-54c91b9b1bb1")
+
+        dev_helpers.attach_to_cloudshell_as("admin", "admin", "Global", "1205e711-edf7-4b12-8a5e-e0ff53768ce7")
         details = helpers.get_reservation_context_details()
         py_vmomi_service = pyVmomiService(SmartConnect, Disconnect)
         cred = TestCredentials()
         si = py_vmomi_service.connect(cred.host, cred.username, cred.password, cred.port)
+        vm = py_vmomi_service.find_vm_by_name(si, 'QualiSB/Alex', 'Ubuntu_a287f573')
+
+        nics = [x for x in vm.config.hardware.device
+                if isinstance(x, vim.vm.device.VirtualEthernetCard)]
+
+        for nic in nics:
+            network_name = nic.backing.network.name
+            mac_address = nic.macAddress
+
+            print network_name + mac_address
 
-        vnic_updater = VnicUpdater(helpers)

tests/test_commands/test_connect_vm.py

@@ -1,10 +1,10 @@
 from unittest import TestCase
-
-from mock import Mock
-
+from mock import Mock, create_autospec
 from common.logger.service import LoggingService
 from vCenterShell.commands.connect_dvswitch import VirtualSwitchConnectCommand
 from vCenterShell.vm.dvswitch_connector import VmNetworkMapping
+from vCenterShell.vm.portgroup_configurer import VNicDeviceMapper
+from pyVmomi import vim
 
 
 class TestVirtualSwitchToMachineDisconnectCommand(TestCase):
@@ -25,8 +25,13 @@ def setUp(self):
         self.vcenter_context.default_dvswitch_path = 'default_dvswitch_path'
         self.vcenter_context.default_dvswitch_name = 'default_dvswitch_name'
         self.vcenter_context.default_port_group_path = 'default_port_group_path'
+
+        vnic_device_mapper = create_autospec(spec=VNicDeviceMapper)
+        vnic_device_mapper.vnic = create_autospec(spec=vim.vm.device.VirtualEthernetCard)
+        vnic_device_mapper.vnic.macAddress = 'AA-BB'
+
         self.dv_connector = Mock()
-        self.dv_connector.connect_by_mapping = Mock(return_value=True)
+        self.dv_connector.connect_by_mapping = Mock(return_value=[vnic_device_mapper])
         self.dv_port_name_gen = Mock()
         self.vlan_spec_factory = Mock()
         self.vlan_id_range_parser = Mock()
@@ -37,22 +42,23 @@ def setUp(self):
     def test_connect_vnic_to_network(self):
         # arrange
         connect_command = VirtualSwitchConnectCommand(self.pv_service, self.dv_connector, self.dv_port_name_gen,
-                                                      self.vlan_spec_factory, self.vlan_id_range_parser, Mock(), Mock())
+                                                      self.vlan_spec_factory, self.vlan_id_range_parser, Mock())
         mapping = VmNetworkMapping()
         mapping.vnic_name = 'name'
         mapping.vlan_id = 'vlan_id'
         mapping.vlan_spec = 'trunc'
         mapping.dv_port_name = 'port_name'
 
         # act
-        connect_command.connect_to_networks(self.si, self.vm_uuid, [mapping], 'default_network')
+        mac_addresses = connect_command.connect_to_networks(self.si, self.vm_uuid, [mapping], 'default_network')
 
         mapping.dv_switch_path = self.vcenter_context.default_dvswitch_path
         mapping.dv_switch_name = self.vcenter_context.default_dvswitch_name
         mapping.port_group_path = self.vcenter_context.default_port_group_path
+
         # assert
         self.assertTrue(self.vlan_id_range_parser.parse_vlan_id.called_with(self.vlan_id))
         self.assertTrue(self.dv_port_name_gen.generate_port_group_name.called_with(self.vlan_id))
         self.assertTrue(self.vlan_spec_factory.get_vlan_spec.called_with(self.spec_type))
-
         self.assertTrue(self.dv_connector.connect_by_mapping.called_with(self.si, self.vm, [mapping]))
+        self.assertSequenceEqual(mac_addresses, ['AA-BB'])

tests/test_common/test_utilities/test_command_result.py

@@ -0,0 +1,13 @@
+from unittest import TestCase
+from common.utilites.command_result import get_result_from_command_output
+
+
+class TestCommandResult(TestCase):
+
+    def test_command_result_with_result(self):
+        result = get_result_from_command_output('command_json_result=MY RESULT=command_json_result_end')
+        self.assertEqual(result, 'MY RESULT')
+
+    def test_command_result_empty(self):
+        result = get_result_from_command_output('')
+        self.assertEqual(result, None)

tests/test_network/test_dvswitch/test_connector.py

@@ -94,13 +94,11 @@ def test_map_vnc(self):
         self.connector.connect_and_get_vm = Mock(return_value=(1, 1,))
 
         res = self.connector.connect_by_mapping(self.si, self.vm, [], 'default_network')
-        self.assertIsNone(res)
+        self.assertEqual(res, 'OK')
         res = self.connector.connect_by_mapping(self.si, self.vm, [], None)
-        #self.assertEqual(res, 'OK')
-        self.assertIsNone(res)
+        self.assertEqual(res, 'OK')
 
         res = self.connector.connect_by_mapping(self.si, self.vm, mapp, 'default_network')
-        self.assertIsNone(res)
+        self.assertEqual(res, 'OK')
         res = self.connector.connect_by_mapping(self.si, self.vm, mapp, None)
-        #self.assertEqual(res, 'OK')
-        self.assertIsNone(res)
+        self.assertEqual(res, 'OK')