--- /dev/null
+#
+# Copyright (c) 2017 GigaSpaces Technologies Ltd. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+#
+
+import os
+import tempfile
+
+from aria.orchestrator.context import operation
+
+
+DEPLOYMENT = 'deployment'
+NODE_INSTANCE = 'node-instance'
+RELATIONSHIP_INSTANCE = 'relationship-instance'
+
+
+class CloudifyContextAdapter(object):
+
+ def __init__(self, ctx):
+ self._ctx = ctx
+ self._blueprint = BlueprintAdapter(ctx)
+ self._deployment = DeploymentAdapter(ctx)
+ self._operation = OperationAdapter(ctx)
+ self._bootstrap_context = BootstrapAdapter(ctx)
+ self._plugin = PluginAdapter(ctx)
+ self._agent = CloudifyAgentAdapter()
+ self._node = None
+ self._node_instance = None
+ self._source = None
+ self._target = None
+ if isinstance(ctx, operation.NodeOperationContext):
+ self._node = NodeAdapter(ctx, ctx.node_template, ctx.node)
+ self._instance = NodeInstanceAdapter(ctx, ctx.node, True)
+ elif isinstance(ctx, operation.RelationshipOperationContext):
+ self._source = RelationshipTargetAdapter(
+ ctx,
+ ctx.source_node_template,
+ ctx.source_node,
+ True
+ )
+ self._target = RelationshipTargetAdapter(
+ ctx,
+ ctx.target_node_template,
+ ctx.target_node,
+ True
+ )
+
+ def __getattr__(self, item):
+ try:
+ return getattr(self._ctx, item)
+ except AttributeError:
+ return super(CloudifyContextAdapter, self).__getattribute__(item)
+
+ @property
+ def blueprint(self):
+ return self._blueprint
+
+ @property
+ def deployment(self):
+ return self._deployment
+
+ @property
+ def operation(self):
+ return self._operation
+
+ @property
+ def bootstrap_context(self):
+ return self._bootstrap_context
+
+ @property
+ def plugin(self):
+ return self._plugin
+
+ @property
+ def agent(self):
+ return self._agent
+
+ @property
+ def type(self):
+ if self._source:
+ return RELATIONSHIP_INSTANCE
+ elif self._instance:
+ return NODE_INSTANCE
+ else:
+ return DEPLOYMENT
+
+ @property
+ def instance(self):
+ self._verify_in_node_operation()
+ return self._instance
+
+ @property
+ def node(self):
+ self._verify_in_node_operation()
+ return self._node
+
+ @property
+ def source(self):
+ self._verify_in_relationship_operation()
+ return self._source
+
+ @property
+ def target(self):
+ self._verify_in_relationship_operation()
+ return self._target
+
+ @property
+ def execution_id(self):
+ return self._ctx.task.execution.id
+
+ @property
+ def workflow_id(self):
+ return self._ctx.task.execution.workflow_name
+
+ @property
+ def rest_token(self):
+ return None
+
+ @property
+ def task_id(self):
+ return self._ctx.task.id
+
+ @property
+ def task_name(self):
+ return self._ctx.task.function
+
+ @property
+ def task_target(self):
+ return None
+
+ @property
+ def task_queue(self):
+ return None
+
+ @property
+ def logger(self):
+
+
+ def getChild( self, name ):
+ loggertype = type(self)
+
+ childlogger = self._logger.getChild(name)
+ finallogger = loggertype(childlogger, self._task_id)
+ return finallogger
+
+
+ loggertype = type(self._ctx.logger)
+
+ childloggertype = type(self._ctx.logger.getChild("test"))
+ if loggertype != childloggertype:
+ loggertype.getChild = getChild
+
+ return self._ctx.logger
+
+ def send_event(self, event):
+ self.logger.info(event)
+
+ @property
+ def provider_context(self):
+ return {}
+
+ def get_resource(self, resource_path):
+ return self._ctx.get_resource(resource_path)
+
+ def get_resource_and_render(self, resource_path, template_variables=None):
+ return self._ctx.get_resource_and_render(resource_path, variables=template_variables)
+
+ def download_resource(self, resource_path, target_path=None):
+ target_path = self._get_target_path(target_path, resource_path)
+ self._ctx.download_resource(
+ destination=target_path,
+ path=resource_path
+ )
+ return target_path
+
+ def download_resource_and_render(self,
+ resource_path,
+ target_path=None,
+ template_variables=None):
+ target_path = self._get_target_path(target_path, resource_path)
+ self._ctx.download_resource_and_render(
+ destination=target_path,
+ path=resource_path,
+ variables=template_variables
+ )
+ return target_path
+
+ @staticmethod
+ def _get_target_path(target_path, resource_path):
+ if target_path:
+ return target_path
+ fd, target_path = tempfile.mkstemp(suffix=os.path.basename(resource_path))
+ os.close(fd)
+ return target_path
+
+ def _verify_in_node_operation(self):
+ if self.type != NODE_INSTANCE:
+ self._ctx.task.abort(
+ 'ctx.node/ctx.instance can only be used in a {0} context but '
+ 'used in a {1} context.'.format(NODE_INSTANCE, self.type)
+ )
+
+ def _verify_in_relationship_operation(self):
+ if self.type != RELATIONSHIP_INSTANCE:
+ self._ctx.task.abort(
+ 'ctx.source/ctx.target can only be used in a {0} context but '
+ 'used in a {1} context.'.format(RELATIONSHIP_INSTANCE,
+ self.type)
+ )
+
+
+class BlueprintAdapter(object):
+
+ def __init__(self, ctx):
+ self._ctx = ctx
+
+ @property
+ def id(self):
+ return self._ctx.service_template.id
+
+
+class DeploymentAdapter(object):
+
+ def __init__(self, ctx):
+ self._ctx = ctx
+
+ @property
+ def id(self):
+ return self._ctx.service.id
+
+
+class NodeAdapter(object):
+
+ def __init__(self, ctx, node_template, node):
+ self._ctx = ctx
+ self._node_template = node_template
+ self._node = node
+
+ @property
+ def id(self):
+ return self._node_template.id
+
+ @property
+ def name(self):
+ return self._node_template.name
+
+ @property
+ def properties(self):
+ # Cloudify Azure plugin will request the resource_config and merge it with new configurations.
+ # This creates an problem when the resource_config is None. Fix this by replacing an empty
+ # resource_config with an empth dict.
+ if 'resource_config' in self._node.properties and self._node.properties.get('resource_config') == None:
+ self._node.properties['resource_config']={}
+ return self._node.properties
+
+ @property
+ def type(self):
+ return self._node_template.type.name
+
+ @property
+ def type_hierarchy(self):
+ # We needed to modify the type hierarchy to be a list of strings that include the word
+ # 'cloudify' in each one of them instead of 'aria', since in the Cloudify AWS plugin, that
+ # we currently wish to support, if we want to attach an ElasticIP to a node, this node's
+ # type_hierarchy property must be a list of strings only, and it must contain either the
+ # string 'cloudify.aws.nodes.Instance', or the string 'cloudify.aws.nodes.Interface'.
+ # In any other case, we won't be able to attach an ElasticIP to a node using the Cloudify
+ # AWS plugin.
+ type_hierarchy_names = [type_.name for type_ in self._node_template.type.hierarchy
+ if type_.name is not None]
+ return [type_name.replace('aria', 'cloudify') for type_name in type_hierarchy_names]
+
+
+class NodeInstanceAdapter(object):
+
+ def __init__(self, ctx, node, modifiable):
+ self._ctx = ctx
+ self._node = node
+ self._modifiable = modifiable
+
+ @property
+ def id(self):
+ return self._node.id
+
+ @property
+ def runtime_properties(self):
+ return self._node.attributes
+
+ @runtime_properties.setter
+ def runtime_properties(self, value):
+ self._node.attributes = value
+
+ def update(self, on_conflict=None):
+ self._ctx.model.node.update(self._node)
+
+ def refresh(self, force=False):
+ self._ctx.model.node.refresh(self._node)
+
+ @property
+ def host_ip(self):
+ return self._node.host_address
+
+ @property
+ def relationships(self):
+ return [RelationshipAdapter(self._ctx, relationship=relationship) for
+ relationship in self._node.outbound_relationships]
+
+ #def __getattr__(self, item):
+ # print "requsting "
+ # print self._node.attributes
+ # print dir(self._ctx)
+ # return getattr(self._ctx.instance, item)
+
+
+class RelationshipAdapter(object):
+
+ def __init__(self, ctx, relationship):
+ self._ctx = ctx
+ self._relationship = relationship
+ node = relationship.target_node
+ node_template = node.node_template
+ self.target = RelationshipTargetAdapter(ctx, node_template, node, False)
+
+ @property
+ def type(self):
+ return self._relationship.type.name
+
+ #@property
+ #def type_hierarchy(self):
+ # return self._relationship.type.hierarchy
+
+
+
+ @property
+ def type_hierarchy(self):
+ # We needed to modify the type hierarchy to be a list of strings that include the word
+ # 'cloudify' in each one of them instead of 'aria', since in the Cloudify AWS plugin, that
+ # we currently wish to support, if we want to attach an ElasticIP to a node, this node's
+ # type_hierarchy property must be a list of strings only, and it must contain either the
+ # string 'cloudify.aws.nodes.Instance', or the string 'cloudify.aws.nodes.Interface'.
+ # In any other case, we won't be able to attach an ElasticIP to a node using the Cloudify
+ # AWS plugin.
+ type_hierarchy_names = [type_.name for type_ in self._relationship.type.hierarchy
+ if type_.name is not None]
+ return [type_name.replace('aria', 'cloudify') for type_name in type_hierarchy_names]
+
+
+
+
+
+
+
+
+
+
+
+class RelationshipTargetAdapter(object):
+
+ def __init__(self, ctx, node_template, node, modifiable):
+ self._ctx = ctx
+ self.node = NodeAdapter(ctx, node_template=node_template, node=node)
+ self.instance = NodeInstanceAdapter(ctx, node=node, modifiable=modifiable)
+
+
+class OperationAdapter(object):
+
+ def __init__(self, ctx):
+ self._ctx = ctx
+
+ @property
+ def name(self):
+ # We needed to modify the operation's 'name' property in order to support the Cloudify AWS
+ # plugin. It can't use ARIA's operation naming convention, as any operation we want to run
+ # using the Cloudify AWS plugin must have its name in the format:
+ # '<something>.<operation_name>'.
+ aria_name = self._ctx.task.name
+ return aria_name.split('@')[0].replace(':', '.')
+
+ @property
+ def retry_number(self):
+ return self._ctx.task.attempts_count - 1
+
+ @property
+ def max_retries(self):
+ task = self._ctx.task
+ if task.max_attempts == task.INFINITE_RETRIES:
+ return task.INFINITE_RETRIES
+ else:
+ return task.max_attempts - 1 if task.max_attempts > 0 else 0
+
+ def retry(self, message=None, retry_after=None):
+ self._ctx.task.retry(message, retry_after)
+
+
+class BootstrapAdapter(object):
+
+ def __init__(self, ctx):
+ self._ctx = ctx
+ self.cloudify_agent = _Stub()
+ self.resources_prefix = ''
+
+ def broker_config(self, *args, **kwargs):
+ return {}
+
+
+class CloudifyAgentAdapter(object):
+
+ def init_script(self, *args, **kwargs):
+ return None
+
+
+class PluginAdapter(object):
+
+ def __init__(self, ctx):
+ self._ctx = ctx
+ self._plugin = None
+
+ @property
+ def name(self):
+ return self._ctx.task.plugin.name
+
+ @property
+ def package_name(self):
+ return self._plugin_attr('package_name')
+
+ @property
+ def package_version(self):
+ return self._plugin_attr('package_version')
+
+ @property
+ def prefix(self):
+ # TODO
+ return self._plugin_attr('prefix')
+
+ @property
+ def workdir(self):
+ return self._ctx.plugin_workdir
+
+ def _plugin_attr(self, attr):
+ if not self._plugin:
+ self._plugin = self._ctx.task.plugin
+ if not self._plugin:
+ return None
+ return getattr(self._plugin, attr, None)
+
+
+
+class _Stub(object):
+ def __getattr__(self, _):
+ return None
Code Review / multicloud / azure.git / blobdiff