plugin replacement code

Author: earthmant

CHANGELOG.txt

@@ -0,0 +1,2 @@
+2.0.0:
+  - New version.

cicd/__init__.py

@@ -0,0 +1,12 @@
+from os import path, pardir
+from ecosystem_tests.dorkl import replace_plugin_package_on_manager
+from ecosystem_cicd_tools.validations import validate_plugin_version
+
+abs_path = path.join(
+    path.abspath(path.join(path.dirname(__file__), pardir)))
+
+if __name__ == '__main__':
+    version = validate_plugin_version(abs_path)
+    for package in ['cloudify_vcd', 'vcd_plugin_sdk']:
+        replace_plugin_package_on_manager(
+            'cloudify-vcd-plugin', version, package, )

cicd/update_test_manager.py

@@ -19,7 +19,7 @@ def __init__(self, *_, **__):
     'cloudify.nodes.vcloud.IsolatedVDCNetwork': [VCloudNetwork],
     'cloudify.nodes.vcloud.RoutedVDCNetwork': [VCloudNetwork],
     'cloudify.nodes.vcloud.VApp': [VCloudvApp],
-    'cloudify.nodes.vcloud.VM': [VCloudVM],
+    'cloudify.nodes.vcloud.VM': [VCloudVM, VCloudvApp],
     'cloudify.nodes.vcloud.Disk': [VCloudDisk],
     'cloudify.nodes.vcloud.Media': [VCloudMedia, VCloudISO],
 }

cloudify_vcd/constants.py

@@ -1,8 +1,10 @@
 
 from pyvcloud.vcd.exceptions import (
+    AccessForbiddenException,
     EntityNotFoundException,
     UnauthorizedException,
     BadRequestException,
+    NotFoundException,
     VcdTaskException)
 
 from functools import wraps
@@ -38,17 +40,35 @@ def wrapper(*_, **kwargs):
 
         if not resource_data.primary_external:
             try:
-                ctx.logger.info('Before')
+                ctx.logger.debug('Executing func {func} '
+                                 'with args {args} '
+                                 'kwargs {kwargs}'.format(
+                                     func=func, args=args, kwargs=kwargs))
                 resource, result = func(*args, **kwargs)
-                ctx.logger.info('After')
-            except (EntityNotFoundException, BadRequestException) as e:
-                if isinstance(e, EntityNotFoundException):
+                ctx.logger.debug('Executed func {func} '
+                                 'result {result}'.format(
+                                     func=func, result=result))
+            except (AccessForbiddenException,
+                    EntityNotFoundException,
+                    BadRequestException,
+                    NotFoundException) as e:
+                ctx.logger.error(
+                    'Failed to execute func {func} '
+                    'with args {args} '
+                    'kwargs {kwargs} '
+                    'Error: {e}'.format(func=func,
+                                        args=args,
+                                        kwargs=kwargs,
+                                        e=str(e)))
+                if isinstance(e, (TypeError,
+                                  NotFoundException,
+                                  EntityNotFoundException)):
                     if operation_name not in NO_RESOURCE_OK:
                         raise NonRecoverableError(
                             'The expected resource {r} does not exist.'.format(
                                 r=resource_data.primary_id))
                     ctx.logger.error('Attempted to perform {op} '
-                                     'operation on {r},'
+                                     'operation on {r}, '
                                      'but the resource was not '
                                      'found.'.format(
                                          op=operation_name,
@@ -57,15 +77,15 @@ def wrapper(*_, **kwargs):
                     resource_data.primary_ctx.instance.runtime_properties[
                         '__RETRY_BAD_REQUEST'] = True
                     resource_data.primary_ctx.instance.update()
-                    raise OperationRetry(str(e))
+                raise OperationRetry(str(e))
             else:
                 last_task = get_last_task(result)
 
         if not resource:
             args[0] = True  # Tell the function to expect external resource.
             try:
                 resource, _ = func(*args, **kwargs)
-            except EntityNotFoundException:
+            except (TypeError, NotFoundException, EntityNotFoundException):
                 if operation_name not in NO_RESOURCE_OK:
                     raise NonRecoverableError(
                         'The expected resource {r} does not exist.'.format(

cloudify_vcd/decorators.py

@@ -1,9 +1,9 @@
 
 from cloudify import ctx
 
-from vcd_plugin_sdk.exceptions import VCloudSDKException
-from .decorators import resource_operation
 from .utils import expose_props
+from .decorators import resource_operation
+from vcd_plugin_sdk.exceptions import VCloudSDKException
 
 
 @resource_operation
@@ -252,8 +252,8 @@ def delete_nat_rules(_,
                      ____,
                      _____,
                      ______,
-                     _______,
                      nat_rule_ctx,
+                     _______,
                      gateway_id,
                      gateway_client,
                      gateway_vdc,
@@ -264,7 +264,7 @@ def delete_nat_rules(_,
     gateway = gateway_class(
         gateway_id, gateway_client, gateway_vdc)
     nat_rules = nat_rule_ctx.instance.runtime_properties.get('rules')
-    for nat_rule_id, _ in nat_rules:
+    for nat_rule_id, _ in nat_rules.items():
         try:
             gateway.delete_nat_rule(nat_rule_id)
         except VCloudSDKException:

cloudify_vcd/gateway_tasks.py

@@ -1,7 +1,6 @@
 
 from .decorators import resource_operation
-from .utils import (
-    find_resource_id_from_relationship_by_type)
+from .utils import find_resource_id_from_relationship_by_type
 
 REL_NETWORK_GW = 'cloudify.relationships.vcloud.network_connected_to_gateway'
 

cloudify_vcd/network_tasks.py

@@ -5,10 +5,11 @@
 from pyvcloud.vcd.exceptions import (
     VcdTaskException,
     EntityNotFoundException,
+    AccessForbiddenException,
 )
 
 from cloudify import ctx
-from cloudify.exceptions import NonRecoverableError
+from cloudify.exceptions import OperationRetry, NonRecoverableError
 from cloudify.constants import NODE_INSTANCE, RELATIONSHIP_INSTANCE
 
 from .constants import CLIENT_CONFIG_KEYS, CLIENT_CREDENTIALS_KEYS, TYPE_MATRIX, NO_RESOURCE_OK
@@ -65,6 +66,10 @@ def primary_ctx(self):
     def primary_external(self):
         return self._resources[0].get('external')
 
+    @property
+    def primary_vdc(self):
+        return self._resources[0].get('vdc')
+
     @property
     def primary_resource(self):
         return self.primary_class(self.primary_id,
@@ -398,6 +403,20 @@ def vcd_busy_exception(exc):
 def vcd_unclear_exception(exc):
     if 'Status code: 400/None, None' in str(exc):
         return True
+    if isinstance(exc, AccessForbiddenException):
+        return True
+    return False
+
+
+def vcd_already_exists(exc):
+    if '400/DUPLICATE_NAME' in str(exc):
+        return True
+    return False
+
+
+def vcd_unresolved_vm(exc):
+    if 'Unresolved' in str(exc):
+        return True
     return False
 
 
@@ -414,7 +433,5 @@ def check_if_task_successful(_resource, task):
         except VcdTaskException as e:
             if cannot_deploy(e):
                 raise NonRecoverableError(str(e))
-            ctx.logger.error(
-                'Unhandled state validation error: {e}.'.format(e=str(e)))
-            return False
+            raise OperationRetry('Unhandled state validation error: {e}.'.format(e=str(e)))
     return True

cloudify_vcd/utils.py

@@ -1,9 +1,21 @@
 
+from pyvcloud.vcd.exceptions import (
+    BadRequestException,
+    OperationNotSupportedException)
+
+from cloudify.exceptions import OperationRetry
+
 from .decorators import resource_operation
+from .network_tasks import get_network_type
 from .utils import (
+    find_rel_by_type,
+    vcd_unresolved_vm,
+    vcd_already_exists,
     find_resource_id_from_relationship_by_type)
 
 REL_VAPP_NETWORK = 'cloudify.relationships.vcloud.vapp_connected_to_network'
+REL_VM_NETWORK = 'cloudify.relationships.vcloud.vm_connected_to_network'
+REL_VM_VAPP = 'cloudify.relationships.vcloud.vm_contained_in_vapp'
 
 
 @resource_operation
@@ -45,6 +57,10 @@ def stop_vapp(_,
         vapp_vdc,
         kwargs=vapp_config
     )
+    # try:
+    #     vapp.undeploy()
+    # except OperationNotSupportedException:
+    #     pass
     vapp.undeploy()
     return vapp, None
 
@@ -66,3 +82,125 @@ def delete_vapp(_,
     )
     vapp.delete()
     return vapp, None
+
+
+@resource_operation
+def create_vm(vm_external,
+              vm_id,
+              vm_client,
+              vm_vdc,
+              vm_config,
+              vm_class,
+              vm_ctx):
+    vapp_name = find_resource_id_from_relationship_by_type(
+        vm_ctx.instance, REL_VM_VAPP)  # or vapp_id
+    network = find_rel_by_type(
+        vm_ctx.instance, REL_VM_NETWORK)
+    if network:
+        vm_config['network'] = vm_config.get(
+            'network',
+            network.target.instance.runtime_properties.get('resource_id'))
+
+    vm = vm_class(
+        vm_id,
+        vapp_name,
+        vm_client,
+        vdc_name=vm_vdc,
+        kwargs={},
+        vapp_kwargs=vm_config
+    )
+    if network:
+        network_type = get_network_type(network.target.node.type_hierarchy)
+        if not vm.check_network(vm_config['network'], network_type):
+            raise OperationRetry(
+                'Waiting on the network {n} to be ready'.format(
+                    n=vm_config['network']))
+    try:
+        last_task = vm.instantiate_vapp()
+    except BadRequestException as e:
+        if not vcd_already_exists(e) and not vm_external:
+            raise
+        else:
+            vm.logger.warn('The vm {name} unexpectedly exists.'.format(
+                name=vm.name))
+            last_task = None
+    vm_ctx.instance.runtime_properties['__VM_CREATE_VAPP'] = True
+    return vm, last_task
+
+
+@resource_operation
+def start_vm(_,
+             vm_id,
+             vm_client,
+             vm_vdc,
+             vm_config,
+             vm_class,
+             vm_ctx):
+    vapp_name = find_resource_id_from_relationship_by_type(
+        vm_ctx.instance, REL_VM_VAPP)
+    vm = vm_class(
+        vm_id,
+        vapp_name,
+        vm_client,
+        vdc_name=vm_vdc,
+        kwargs={},
+        vapp_kwargs=vm_config
+    )
+    last_task = vm.power_on()
+    return vm, last_task
+
+
+@resource_operation
+def stop_vm(_,
+            vm_id,
+            vm_client,
+            vm_vdc,
+            vm_config,
+            vm_class,
+            vm_ctx):
+    vapp_name = find_resource_id_from_relationship_by_type(
+        vm_ctx.instance, REL_VM_VAPP)
+    vm = vm_class(
+        vm_id,
+        vapp_name,
+        vm_client,
+        vdc_name=vm_vdc,
+        kwargs={},
+        vapp_kwargs=vm_config
+    )
+    try:
+        last_task = vm.power_off()
+    except OperationNotSupportedException as e:
+        if not vcd_unresolved_vm(e):
+            raise
+        last_task = None
+    return vm, last_task
+
+
+@resource_operation
+def delete_vm(_,
+              vm_id,
+              vm_client,
+              vm_vdc,
+              vm_config,
+              vm_class,
+              vm_ctx):
+    vapp_name = find_resource_id_from_relationship_by_type(
+        vm_ctx.instance, REL_VM_VAPP)
+    vm = vm_class(
+        vm_id,
+        vapp_name,
+        vm_client,
+        vdc_name=vm_vdc,
+        kwargs={},
+        vapp_kwargs=vm_config
+    )
+    try:
+        last_task = vm.undeploy()
+    except OperationNotSupportedException as e:
+        if not vcd_unresolved_vm(e):
+            raise
+        last_task = None
+    if vm_ctx.instance.runtime_properties.get('__VM_CREATE_VAPP'):
+        last_task = vm.vapp_object.delete()
+    return vm, last_task