def test_ctx_type(self):
ctx = context.CloudifyContext({})
self.assertEqual(constants.DEPLOYMENT, ctx.type)
ctx = context.CloudifyContext({'node_id': 'node-instance-id'})
self.assertEqual(constants.NODE_INSTANCE, ctx.type)
ctx = context.CloudifyContext({
'node_id': 'node-instance-id',
'related': {
'node_id': 'related-instance-id',
'is_target': True
},
'relationships': ['related-instance-id']
})
self.assertEqual(constants.RELATIONSHIP_INSTANCE, ctx.type)
def setUpClass(cls):
state.current_ctx.set(context.CloudifyContext({}), {})
os.environ[constants.REST_PORT_KEY] = '53333'
os.environ[constants.REST_HOST_KEY] = "localhost"
os.environ[constants.MANAGER_FILE_SERVER_SCHEME] = "http"
_, os.environ[constants.LOCAL_REST_CERT_FILE_KEY] = tempfile.mkstemp()
def test_operation_retry(self):
ctx = context.CloudifyContext({})
e = self.assertRaises(exceptions.OperationRetry,
retry_operation,
ctx)
self.assertEqual(RETRY_AFTER, e.retry_after)
self.assertIn(RETRY_MESSAGE, str(e))
def setup_tenant_context(self):
self.context = context.CloudifyContext({
'blueprint_id': 'test_blueprint',
'tenant': {
'name': 'default_tenant'
}
})
self.redirect_log_to_stdout(self.context.logger)
def setUp(self):
super(CloudifyContextTest, self).setUp()
self.context = context.CloudifyContext({
'blueprint_id': '',
'tenant': {'name': 'default_tenant'}
})
# the context logger will try to publish messages to rabbit, which is
# not available here. instead, we redirect the output to stdout.
self.redirect_log_to_stdout(self.context.logger)
def test_operation_retry_api(self):
op_name = 'operation'
ctx = context.CloudifyContext({
'operation': {
'name': op_name,
'retry_number': 0,
'max_retries': 10
}
})
self.assertEqual(op_name, ctx.operation.name)
self.assertEqual(0, ctx.operation.retry_number)
self.assertEqual(10, ctx.operation.max_retries)
def test_source_target_not_in_relationship(self):
ctx = context.CloudifyContext({})
e = self.assertRaises(exceptions.NonRecoverableError,
lambda: ctx.source)
self.assertIn('ctx.source/ctx.target can only be used in a '
'relationship-instance context but used in a '
'deployment context.', str(e))
e = self.assertRaises(exceptions.NonRecoverableError,
lambda: ctx.target)
self.assertIn('ctx.source/ctx.target can only be used in a '
'relationship-instance context but used in a '
'deployment context.', str(e))
def setUpClass(cls):
state.current_ctx.set(context.CloudifyContext({}), {})
resources_path = os.path.join(dirname(tests_path.__file__))
from cloudify.tests.file_server import FileServer
from cloudify.tests.file_server import PORT
cls.file_server_process = FileServer(resources_path)
cls.file_server_process.start()
os.environ[constants.MANAGER_FILE_SERVER_URL_KEY] = \
"http://localhost:{0}".format(PORT)
_, os.environ[constants.LOCAL_REST_CERT_FILE_KEY] = tempfile.mkstemp()
cls.context = context.CloudifyContext({
'blueprint_id': '',
'tenant': {
'name': 'default_tenant'
}
})
# the context logger will try to publish messages to rabbit, which is
# not available here. instead, we redirect the output to stdout.
cls.redirect_log_to_stdout(cls.context.logger)
def setUpClass(cls):
state.current_ctx.set(context.CloudifyContext({}), {})
resources_path = os.path.join(dirname(tests_path.__file__))
from cloudify.tests.file_server import FileServer
from cloudify.tests.file_server import PORT
cls.file_server_process = FileServer(resources_path)
cls.file_server_process.start()
os.environ[constants.REST_PORT_KEY] = "{0}".format(PORT)
os.environ[constants.REST_HOST_KEY] = "localhost"
os.environ[constants.MANAGER_FILE_SERVER_SCHEME] = "http"
_, os.environ[constants.LOCAL_REST_CERT_FILE_KEY] = tempfile.mkstemp()
def setUpClass(cls):
resources_path = os.path.join(dirname(tests_path.__file__),
"resources")
from cloudify.tests.file_server import FileServer
from cloudify.tests.file_server import PORT
cls.file_server_process = FileServer(resources_path)
cls.file_server_process.start()
os.environ[constants.MANAGER_FILE_SERVER_BLUEPRINTS_ROOT_URL_KEY] \
= "http://localhost:{0}".format(PORT)
os.environ[constants.MANAGER_FILE_SERVER_URL_KEY] = \
"http://localhost:{0}".format(PORT)
cls.context = context.CloudifyContext({'blueprint_id': ''})
def setUp(self):
super(PluginContextTests, self).setUp()
self.plugin_name = 'test_plugin'
self.plugin_pacakge_name = 'test-plugin'
self.plugin_pacakge_version = '0.1.1'
self.deployment_id = 'test_deployment'
self.tenant_name = 'default_tenant'
self.ctx = context.CloudifyContext({
'deployment_id': self.deployment_id,
'tenant': {'name': self.tenant_name},
'plugin': {
'name': self.plugin_name,
'package_name': self.plugin_pacakge_name,
'package_version': self.plugin_pacakge_version
}
})
self.test_prefix = tempfile.mkdtemp(prefix='context-plugin-test-')
self.addCleanup(lambda: shutil.rmtree(self.test_prefix,
ignore_errors=True))
def setUpClass(cls):
resources_path = os.path.join(dirname(tests_path.__file__),
"resources")
from cloudify.tests.file_server import FileServer
from cloudify.tests.file_server import PORT
cls.file_server_process = FileServer(resources_path)
cls.file_server_process.start()
os.environ[constants.MANAGER_FILE_SERVER_BLUEPRINTS_ROOT_URL_KEY] \
= "http://localhost:{0}".format(PORT)
os.environ[constants.MANAGER_FILE_SERVER_URL_KEY] = \
"http://localhost:{0}".format(PORT)
cls.context = context.CloudifyContext({'blueprint_id': ''})
# the context logger will try to publish messages to rabbit, which is
# not available here. instead, we redirect the output to stdout.
cls.redirect_log_to_stdout(cls.context.logger)
def test_ctx_instance_in_relationship(self):
ctx = context.CloudifyContext({
'node_id': 'node-instance-id',
'related': {
'node_id': 'related-instance-id',
'is_target': True
},
'relationships': ['related-instance-id']
})
self.assertEqual('node-instance-id', ctx.source.instance.id)
self.assertEqual('related-instance-id', ctx.target.instance.id)
e = self.assertRaises(exceptions.NonRecoverableError,
lambda: ctx.node)
self.assertIn('ctx.node/ctx.instance can only be used in a '
'node-instance context but used in a '
'relationship-instance context.', str(e))
e = self.assertRaises(exceptions.NonRecoverableError,
lambda: ctx.instance)
self.assertIn('ctx.node/ctx.instance can only be used in a '
'node-instance context but used in a '
'relationship-instance context.', str(e))
def install_local(agent_file, output_agent_file, rest_token, rest_cert_path):
if agent_file is None:
raise click.ClickException('--agent-file should be specified.')
cloudify_agent = json.load(agent_file)
ctx = context.CloudifyContext({'rest_token': rest_token})
state.current_ctx.set(ctx, {})
if not cloudify_agent.get('rest_port'):
cloudify_agent['rest_port'] = defaults.INTERNAL_REST_PORT
os.environ[utils.internal.CLOUDIFY_DAEMON_USER_KEY] = str(
cloudify_agent['user'])
os.environ[CLOUDIFY_LOCAL_REST_CERT_PATH] = str(rest_cert_path)
if 'basedir' not in cloudify_agent:
cloudify_agent['basedir'] = utils.get_home_dir(cloudify_agent['user'])
configuration.directory_attributes(cloudify_agent)
installer = prepare_local_installer(cloudify_agent)
installer.create_agent()
installer.configure_agent()
installer.start_agent()
if output_agent_file is not None:
with open(output_agent_file, 'w') as out:
out.write(json.dumps(cloudify_agent))
# Remove the temporary cert file, as it was copied to the agent's dir
os.remove(rest_cert_path)
def wrapper(*args, **kwargs):
ctx = _find_context_arg(args, kwargs, _is_cloudify_context)
if ctx is None:
ctx = {}
if not _is_cloudify_context(ctx):
ctx = context.CloudifyContext(ctx)
# remove __cloudify_context
raw_context = kwargs.pop(CLOUDIFY_CONTEXT_PROPERTY_KEY, {})
if ctx.task_target is None:
# task is local (not through celery) so we need to
# clone kwarg
kwargs = copy.deepcopy(kwargs)
if raw_context.get('has_intrinsic_functions') is True:
kwargs = ctx._endpoint.evaluate_functions(payload=kwargs)
kwargs['ctx'] = ctx
try:
current_ctx.set(ctx, kwargs)
result = func(*args, **kwargs)
except BaseException as e:
ctx.logger.error(
'Exception raised on operation [%s] invocation',
ctx.task_name, exc_info=True)
if ctx.task_target is None:
# local task execution
# no serialization issues
raise
# extract exception details
# type, value, traceback
tpe, value, tb = sys.exc_info()
# we re-create the exception here
# since it will be sent
# over the wire. And the original exception
# may cause de-serialization issues
# on the other side.
# preserve original type in the message
message = '{0}: {1}'.format(tpe.__name__, str(e))
# if the exception type is directly one of our exception
# than there is no need for conversion and we can just
# raise the original exception
if type(e) in [exceptions.OperationRetry,
exceptions.RecoverableError,
exceptions.NonRecoverableError,
exceptions.HttpException]:
raise
# if the exception inherits from our base exceptions, there
# still might be a de-serialization problem caused by one of
# the types in the inheritance tree.
if isinstance(e, exceptions.NonRecoverableError):
value = exceptions.NonRecoverableError(message)
elif isinstance(e, exceptions.OperationRetry):
value = exceptions.OperationRetry(message, e.retry_after)
elif isinstance(e, exceptions.RecoverableError):
value = exceptions.RecoverableError(message, e.retry_after)
else:
# convert pure user exceptions
# to a RecoverableError
value = exceptions.RecoverableError(message)
raise type(value), value, tb
finally:
current_ctx.clear()
if ctx.type == context.NODE_INSTANCE:
ctx.instance.update()
elif ctx.type == context.RELATIONSHIP_INSTANCE:
ctx.source.instance.update()
ctx.target.instance.update()
if ctx.operation._operation_retry:
raise ctx.operation._operation_retry
return result
