Merge pull request #125 from QualiSystems/feature/borismod_40_save_vnic

Feature/borismod 40 save vnic
connect #40

common/utilites/command_result.py

@@ -1,15 +1,42 @@
 from re import search
+import jsonpickle
 
 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)
+    """
+    Extracts result from output
+    :param output: Console output as returned from command execution
+    :return: Deserialized object or deserialized JSON into dictionary
+    """
+    match = _extract_result_from_output(output)
     if not match:
         return None
-    return match.group('result')
+    json = match.group('result')
+    return jsonpickle.decode(json)
+
+
+def set_command_result(result, unpicklable=False):
+    """
+    Serializes output as JSON and writes it to console output wrapped with special prefix and suffix
+    :param result: Result to return
+    :param unpicklable: If True adds JSON can be deserialized as real object.
+                        When False will be deserialized as dictionary
+    """
+    json = jsonpickle.encode(result, unpicklable=unpicklable)
+    result_for_output = COMMAND_RESULT_PREFIX + str(json) + COMMAND_RESULT_POSTFIX
+    print result_for_output
+    return result_for_output
 
 
-def set_command_result(output):
-    print COMMAND_RESULT_PREFIX + str(output) + COMMAND_RESULT_POSTFIX
+def transfer_command_result(output):
+    match = _extract_result_from_output(output)
+    if match:
+        print COMMAND_RESULT_PREFIX + match.group('result') + COMMAND_RESULT_POSTFIX
+
+
+def _extract_result_from_output(output):
+    match = search(COMMAND_RESULT_PREFIX + '(?P<result>.*)' + COMMAND_RESULT_POSTFIX, output)
+    return match

common/utilites/common_utils.py

@@ -14,3 +14,18 @@ def represents_int(s):
         return True
     except ValueError:
         return False
+
+
+def get_object_as_string(obj):
+    """
+    Converts any object to JSON-like readable format, ready to be printed for debugging purposes
+    :param obj: Any object
+    :return: string
+    """
+    if isinstance(obj, str):
+        return obj
+    if isinstance(obj, list):
+        return '\r\n\;'.join([get_object_as_string(item) for item in obj])
+    attrs = vars(obj)
+    as_string = ', '.join("%s: %s" % item for item in attrs.items())
+    return as_string

deployed_app_service/proxy/deployed_app_proxy.py

@@ -1,6 +1,6 @@
 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.utilites.command_result import get_result_from_command_output, set_command_result, transfer_command_result
 from common.logger import getLogger
 
 _logger = getLogger('DeployedAppService')
@@ -111,6 +111,4 @@ def execute_command_on_vcenter_resource_and_passthrough_result(generic_deployed_
                                                                                 command,
                                                                                 inputs)
 
-        result = get_result_from_command_output(command_result.Output)
-        _logger.debug('Transferring result to the caller ' + result)
-        set_command_result(result)
+        transfer_command_result(command_result.Output)

environment_scripts/connect_all.py

@@ -1,10 +1,8 @@
-import re
-
 import qualipy.scripts.cloudshell_scripts_helpers as helpers
 from qualipy.api.cloudshell_api import InputNameValue, AttributeNameValue
+from common.logger.service import getLogger
 from common.utilites.command_result import get_result_from_command_output
 
-from common.logger.service import getLogger
 _logger = getLogger('EnvironmentConnector')
 
 VIRTUAL_NETWORK_ATTRIBUTE = 'Virtual Network'
@@ -88,19 +86,20 @@ def _execute_connect_command_on_connected_resource(access_mode, connected_resour
                                                 [InputNameValue('VLAN_ID', virtual_network),
                                                  InputNameValue('VLAN_SPEC_TYPE', access_mode)], True)
 
-        result = get_result_from_command_output(command_result.Output)
+        connect_results = get_result_from_command_output(command_result.Output)
 
-        if not result:
-            _logger.debug('Connect command did not return any result')
+        if not connect_results:
+            _logger.debug('Connect command did not return any results')
             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)])
+        for connect_result in connect_results:
+            mac_address = connect_result['mac_address']
+            _logger.debug('Setting Target Interface to: ' + mac_address)
+            session.SetConnectorAttributes(reservation_id,
+                                           connected_resource,
+                                           vlan_service_name,
+                                           [AttributeNameValue('Target Interface', mac_address)])
+            break
 
     @staticmethod
     def _get_connected_resources(connectors, vlan_service):

models/ConnectionResult.py

@@ -0,0 +1,5 @@
+class ConnectionResult(object):
+    def __init__(self, mac_address, vm_uuid, network_name):
+        self.mac_address = mac_address
+        self.vm_uuid = vm_uuid
+        self.network_name = network_name

run_packager.bat

@@ -1,6 +1,8 @@
 @echo off
 
 REM build driver scripts
+del /F /Q "vCenterShellPackage\Resource Scripts\."
+del /F /Q "vCenterShellPackage\Topology Scripts\."
 
 python driver_packager.py packeger_configs\\deployment_service_driver.ini
 python driver_packager.py packeger_configs\\deploy_from_template_command.ini

tests/test_command_executer_service.py

@@ -20,7 +20,7 @@ def test_deploy_from_template(self):
         # arrange
         deploy_param = 'deploy_param'
         deploy_data = {'mock': Mock()}
-        deploy_result = Mock()
+        deploy_result = 'deploy_result'
 
         self.quali_helpers.get_user_param = Mock(return_value=deploy_param)
         self.serializer.decode = Mock(return_value=deploy_data)

tests/test_commands/test_connect_vm.py

@@ -50,7 +50,7 @@ def test_connect_vnic_to_network(self):
         mapping.dv_port_name = 'port_name'
 
         # act
-        mac_addresses = connect_command.connect_to_networks(self.si, self.vm_uuid, [mapping], 'default_network')
+        connect_results = 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
@@ -61,4 +61,4 @@ def test_connect_vnic_to_network(self):
         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'])
+        self.assertEqual(connect_results[0].mac_address, 'AA-BB')

tests/test_common/test_utilities/test_command_result.py

@@ -1,13 +1,50 @@
 from unittest import TestCase
-from common.utilites.command_result import get_result_from_command_output
+from common.utilites.command_result import get_result_from_command_output, set_command_result
+from models.ConnectionResult import ConnectionResult
 
 
 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_get_result_from_command_output_with_result(self):
+        result = get_result_from_command_output('command_json_result={"result":"MY RESULT"}=command_json_result_end')
+        self.assertEqual(result["result"], 'MY RESULT')
 
     def test_command_result_empty(self):
         result = get_result_from_command_output('')
         self.assertEqual(result, None)
+
+    def test_get_result_from_command_output_with_result_unpickable_true(self):
+
+        connection_result = ConnectionResult(mac_address='AA', vm_uuid='BB', network_name='CC')
+        output_result = set_command_result(result=connection_result, unpicklable=True)
+        result = get_result_from_command_output(output_result)
+
+        self.assertEqual(result.mac_address, 'AA')
+        self.assertEqual(result.vm_uuid, 'BB')
+        self.assertEqual(result.network_name, 'CC')
+
+    def test_get_result_from_command_output_with_result_unpickable_false(self):
+
+        connection_result = ConnectionResult(mac_address='AA', vm_uuid='BB', network_name='CC')
+        output_result = set_command_result(result=[connection_result], unpicklable=False)
+        results = get_result_from_command_output(output_result)
+
+        self.assertEqual(results[0]['mac_address'], 'AA')
+        self.assertEqual(results[0]['vm_uuid'], 'BB')
+        self.assertEqual(results[0]['network_name'], 'CC')
+
+    def test_get_result_from_command_output_with_result(self):
+
+        output_result = 'command_json_result=[{"py/object": "models.ConnectionResult.ConnectionResult", "vm_uuid": "422258ab-47e9-d57c-3741-6832a432bc3a", "network_name": "QualiSB/anetwork", "mac_address": "00:50:56:a2:23:76"}]=command_json_result_end'
+        results = get_result_from_command_output(output_result)
+
+        self.assertEqual(results[0].mac_address, '00:50:56:a2:23:76')
+
+    def test_get_result_from_command_output_with_result_unpickable_false(self):
+
+        output_result = 'command_json_result=[{"vm_uuid": "422258c6-15d0-0646-d5e7-f2cb411eee94", "network_name": "QualiSB/anetwork", "mac_address": "00:50:56:a2:6c:04"}]=command_json_result_end'
+        results = get_result_from_command_output(output_result)
+
+        for result in results:
+            v = dict(result)
+            self.assertEqual(result['mac_address'], '00:50:56:a2:6c:04')

tests/test_common/test_utilities/test_common_utils.py

@@ -0,0 +1,16 @@
+import unittest
+from common.utilites.common_utils import get_object_as_string
+
+
+class TestCommonUtils(unittest.TestCase):
+    def test_get_object_as_string_list(self):
+
+        result = get_object_as_string(['value'])
+
+        self.assertEqual(result, 'value')
+
+    def test_get_object_as_string_string(self):
+
+        result = get_object_as_string('value')
+
+        self.assertEqual(result, 'value')

vCenterShell/command_executer.py

@@ -2,6 +2,7 @@
 from vCenterShell.vm.dvswitch_connector import VmNetworkMapping
 from common.utilites.command_result import set_command_result
 
+
 class CommandExecuterService(object):
     """ main class that publishes all available commands """
 
@@ -61,11 +62,12 @@ def connect(self):
         connection_details = self.connection_retriever.connection_details()
 
         # execute command
-        mac_addresses = self.command_wrapper.execute_command_with_connection(connection_details,
-                                                                          self.virtual_switch_connect_command.connect_to_networks,
-                                                                          uuid, [vnic_to_network], default_network)
-
-        set_command_result(','.join(mac_addresses))
+        connection_results = self.command_wrapper.execute_command_with_connection(connection_details,
+                                                                                  self.virtual_switch_connect_command.connect_to_networks,
+                                                                                  uuid,
+                                                                                  [vnic_to_network],
+                                                                                  default_network)
+        set_command_result(result=connection_results, unpicklable=False)
 
     def disconnect_all(self):
         vm_uuid = self.qualipy_helpers.get_user_param('VM_UUID')
@@ -123,7 +125,7 @@ def deploy_from_template(self):
                 self.deployFromTemplateCommand.execute_deploy_from_template,
                 data_holder)
 
-        set_command_result(self.serializer.encode(result, unpicklable=False))
+        set_command_result(result=result, unpicklable=False)
 
     def power_off(self):
         # get command parameters from the environment
@@ -166,5 +168,3 @@ def refresh_ip(self):
                                                              self.refresh_ip_command.refresh_ip,
                                                              vm_uuid,
                                                              resource_name)
-
-

vCenterShell/commands/connect_dvswitch.py

@@ -1,3 +1,6 @@
+from models.ConnectionResult import ConnectionResult
+from common.utilites.common_utils import get_object_as_string
+
 
 class VirtualSwitchConnectCommand:
     def __init__(self,
@@ -43,11 +46,15 @@ def connect_to_networks(self, si, vm_uuid, vm_network_mappings, default_network_
         updated_mappings = self.virtual_switch_to_machine_connector.connect_by_mapping(
             si, vm, mappings, default_network_instance)
 
-        mac_addresses = []
+        connection_results = []
         for updated_mapping in updated_mappings:
-            mac_addresses.append(updated_mapping.vnic.macAddress)
 
-        return mac_addresses
+            connection_result = ConnectionResult(mac_address=updated_mapping.vnic.macAddress,
+                                                 vm_uuid=vm_uuid,
+                                                 network_name=default_network_name)
+            connection_results.append(connection_result)
+
+        return connection_results
 
     def _prepare_mappings(self, vm_network_mappings):
         mappings = []