def test_serial_operation_install_workflow(self, _mock, list_fn):
_ctx = MockCloudifyContext(node_id='test_node',
deployment_id='test_deployment',
index=7)
# Check that we raise if the preceder is not 'started'.
_ctx._context['workflow_id'] = 'install'
current_ctx.set(_ctx)
_mock.side_effect = lambda: rest_client_mock.MockRestclient()
_caller = Mock()
@serial_operation(workflows=['scale'])
def run_op_neither(ctx=_ctx, **kwargs):
_caller()
list_fn.return_value = [
Mock(id='test_node{x}'.format(x=n),
index=n,
state='started' if n == 6 else 'uninitialized')
for n in range(0, 6)
]
run_op_neither()
self.assertTrue(_caller.called)
current_ctx.clear()
def test_policy_get_fail(monkeypatch):
"""test policy_get operation on non dcae.nodes.policy node"""
tasks.PolicyHandler._url = tasks.PolicyHandler.DEFAULT_URL
monkeypatch.setattr('requests.get', monkeyed_policy_handler_get)
node_policy = MonkeyedNode('test_dcae_policy_node_id',
'test_dcae_policy_node_name',
tasks.DCAE_POLICY_TYPE,
{POLICY_ID: MONKEYED_POLICY_ID})
node_ms = MonkeyedNode('test_ms_id', 'test_ms_name', "ms.nodes.type", None,
[{
TARGET_NODE_ID: node_policy.node_id,
TARGET_NODE_NAME: node_policy.node_name
}])
try:
current_ctx.set(node_ms.ctx)
CtxLogger.log_ctx_info("ctx of node_ms not policy type")
with pytest.raises(NonRecoverableError) as excinfo:
tasks.policy_get()
CtxLogger.log_ctx_info("node_ms not policy type boom: {0}".format(
str(excinfo.value)))
assert "unexpected node type " in str(excinfo.value)
finally:
MockCloudifyContextFull.clear()
current_ctx.clear()
def test_policies_find_fail(monkeypatch):
"""test policy_get operation on non dcae.nodes.policies node"""
tasks.PolicyHandler._url = tasks.PolicyHandler.DEFAULT_URL
monkeypatch.setattr('requests.post', monkeyed_policy_handler_find)
node_policies = MonkeyedNode(
'test_dcae_policies_node_id', 'test_dcae_policies_node_name',
tasks.DCAE_POLICIES_TYPE, {
tasks.POLICY_FILTER: {
POLICY_NAME:
MONKEYED_POLICY_ID,
tasks.CONFIG_ATTRIBUTES:
json.dumps({CONFIG_NAME: "alex_config_name"})
}
})
node_ms_multi = MonkeyedNode('test_ms_multi_id', 'test_ms_multi_name',
"ms.nodes.type", None,
[{
TARGET_NODE_ID: node_policies.node_id,
TARGET_NODE_NAME: node_policies.node_name
}])
try:
current_ctx.set(node_ms_multi.ctx)
CtxLogger.log_ctx_info("ctx of node_ms_multi not policy type")
with pytest.raises(NonRecoverableError) as excinfo:
tasks.policy_get()
CtxLogger.log_ctx_info(
"node_ms_multi not policy type boom: {0}".format(str(
excinfo.value)))
assert "unexpected node type " in str(excinfo.value)
finally:
MockCloudifyContextFull.clear()
current_ctx.clear()
def ctx():
ctxmock = ctx_mock()
current_ctx.set(ctxmock)
yield ctxmock
current_ctx.clear()
def ctx():
ctx = Mock()
current_ctx.set(ctx)
yield ctx
current_ctx.clear()
def test_policy_get(monkeypatch):
"""test policy_get operation on dcae.nodes.policy node"""
tasks.PolicyHandler._url = tasks.PolicyHandler.DEFAULT_URL
monkeypatch.setattr('requests.get', monkeyed_policy_handler_get)
node_policy = MonkeyedNode('test_dcae_policy_node_id',
'test_dcae_policy_node_name',
tasks.DCAE_POLICY_TYPE,
{POLICY_ID: MONKEYED_POLICY_ID})
try:
current_ctx.set(node_policy.ctx)
CtxLogger.log_ctx_info("before policy_get")
tasks.policy_get()
CtxLogger.log_ctx_info("after policy_get")
expected = {
POLICY_BODY:
MonkeyedPolicyBody.create_policy_body(MONKEYED_POLICY_ID)
}
result = node_policy.ctx.instance.runtime_properties
node_policy.ctx.logger.info("expected runtime_properties: {0}".format(
json.dumps(expected)))
node_policy.ctx.logger.info("runtime_properties: {0}".format(
json.dumps(result)))
assert MonkeyedPolicyBody.is_the_same_dict(result, expected)
assert MonkeyedPolicyBody.is_the_same_dict(expected, result)
finally:
MockCloudifyContextFull.clear()
current_ctx.clear()
def ctx():
ctxmock = ctx_mock()
current_ctx.set(ctxmock)
yield ctxmock
current_ctx.clear()
def ctx():
ctx = Mock()
current_ctx.set(ctx)
yield ctx
current_ctx.clear()
def test_serial_operation_install(self, list_fn):
_ctx = MockCloudifyContext(node_id='test_node',
deployment_id='test_deployment',
index=7)
# Check that we raise if the preceder is not 'started'.
_ctx._context['workflow_id'] = 'install'
current_ctx.set(_ctx)
_caller = Mock()
@serial_operation()
def run_op_install_only(ctx=_ctx, **kwargs):
_caller()
list_fn.return_value = [
Mock(id='test_node{x}'.format(x=n), index=n, state='uninitialized')
for n in range(0, 6)
]
self.assertRaises(CloudifySerializationRetry, run_op_install_only)
self.assertFalse(_caller.called)
list_fn.return_value = [
Mock(id='test_node{x}'.format(x=n),
index=n,
state='started' if n < 7 else 'uninitialized')
for n in range(3, 10) if n != 7
]
run_op_install_only()
self.assertTrue(_caller.called)
current_ctx.clear()
def test_op_upgrade(self, mock_execute_command):
# test operation upgrade
"""
:upgrade operation test:
"""
props = {
'component_name': 'test_node',
'namespace': 'onap',
'tiller_port': '8888',
'tiller_ip': '1.1.1.1',
'tls_enable': 'false',
'config_dir': '/tmp'
}
args = {'revision': '1', 'config': '', 'chart_repo': 'repo', 'chart_version': '2',
'config_set': 'config_set', 'config_json': '', 'config_url': '',
'config_format': 'format', 'repo_user': '', 'repo_user_passwd': ''}
mock_ctx = MockCloudifyContext(node_id='test_node_id', node_name='test_node_name',
properties=props)
try:
current_ctx.set(mock_ctx)
with mock.patch('plugin.tasks.get_current_helm_value'):
with mock.patch('plugin.tasks.get_helm_history'):
with mock.patch('plugin.tasks.gen_config_str'):
plugin.tasks.upgrade(**args)
finally:
current_ctx.clear()
def install_script(name, windows, user, manager_ip):
ctx = MockCloudifyContext(
node_id='node',
properties={'agent_config': {
'user': user,
'windows': windows,
'install_method': 'provided',
'manager_ip': manager_ip,
'name': name
}})
try:
current_ctx.set(ctx)
os.environ['MANAGER_FILE_SERVER_URL'] = 'http://{0}:53229'.format(
manager_ip)
init_script = script.init_script(cloudify_agent={})
finally:
os.environ.pop('MANAGER_FILE_SERVER_URL')
current_ctx.clear()
result = '\n'.join(init_script.split('\n')[:-1])
if windows:
return '{0}\n' \
'DownloadAndExtractAgentPackage\n' \
'ExportDaemonEnv\n' \
'ConfigureAgent'.format(result)
else:
return '{0}\n' \
'install_agent'.format(result)
def test_generate():
mock_ctx = MockCloudifyContext(node_id='test_node_id', node_name='test_node_name', properties={})
try:
current_ctx.set(mock_ctx)
sshkeyshare.keyshare_plugin.generate()
pub = ctx.instance.runtime_properties['public']
pvt64 = ctx.instance.runtime_properties['base64private']
finally:
current_ctx.clear()
def test_basic(self):
self.assertRaises(RuntimeError, current_ctx.get_ctx)
self.assertRaises(RuntimeError, lambda: ctx.node_id)
value = MockCloudifyContext(node_id='1')
current_ctx.set(value)
self.assertEqual(value, current_ctx.get_ctx())
self.assertEqual(value.node_id, ctx.node_id)
current_ctx.clear()
self.assertRaises(RuntimeError, current_ctx.get_ctx)
self.assertRaises(RuntimeError, lambda: ctx.node_id)
def test_basic(self):
self.assertRaises(RuntimeError, current_ctx.get_ctx)
self.assertRaises(RuntimeError, lambda: ctx.instance.id)
value = MockCloudifyContext(node_id='1')
current_ctx.set(value)
self.assertEqual(value, current_ctx.get_ctx())
self.assertEqual(value.instance.id, ctx.instance.id)
current_ctx.clear()
self.assertRaises(RuntimeError, current_ctx.get_ctx)
self.assertRaises(RuntimeError, lambda: ctx.instance.id)
def _install_script(name, windows, user, manager, attributes, tmpdir, logger,
tenant):
# Download cert from manager in order to include its content
# in the init_script.
local_cert_path = str(tmpdir / 'cloudify_internal_cert.pem')
logger.info('Downloading internal cert from manager: %s -> %s',
attributes.LOCAL_REST_CERT_FILE,
local_cert_path)
with manager.ssh() as fabric:
fabric.get(attributes.LOCAL_REST_CERT_FILE, local_cert_path)
env_vars = {
constants.REST_HOST_KEY: manager.private_ip_address,
constants.REST_PORT_KEY: str(defaults.INTERNAL_REST_PORT),
constants.BROKER_SSL_CERT_PATH: local_cert_path,
constants.LOCAL_REST_CERT_FILE_KEY: local_cert_path,
constants.MANAGER_FILE_SERVER_URL_KEY: (
'https://{0}:{1}/resources'.format(manager.private_ip_address,
defaults.INTERNAL_REST_PORT)
),
constants.MANAGER_FILE_SERVER_ROOT_KEY: str(tmpdir),
constants.MANAGER_NAME: (
manager.client.manager.get_managers()[0].hostname
),
}
(tmpdir / 'cloudify_agent').mkdir()
ctx = MockCloudifyContext(
node_id='node',
tenant={'name': tenant},
rest_token=manager.client.tokens.get().value,
managers=manager.client.manager.get_managers(),
brokers=manager.client.manager.get_brokers(),
properties={'agent_config': {
'user': user,
'windows': windows,
'install_method': 'init_script',
'name': name
}})
try:
current_ctx.set(ctx)
os.environ.update(env_vars)
script_builder = script._get_script_builder()
install_script = script_builder.install_script()
finally:
for var_name in list(env_vars):
os.environ.pop(var_name, None)
current_ctx.clear()
# Replace the `main` call with an install call - as we only want to
# install the agent, but not configure/start it
install_method = 'InstallAgent' if windows else 'install_agent'
install_script = '\n'.join(install_script.split('\n')[:-1])
return '{0}\n{1}'.format(install_script, install_method)
def tearDown(self):
current_ctx.clear()
if self.local_env:
try:
self.local_env.execute(
'uninstall',
task_retries=50,
task_retry_interval=3,
)
except Exception as ex:
print str(ex)
super(SecurityTest, self).tearDown()
def run(queue, value):
try:
self.assertRaises(RuntimeError, current_ctx.get_ctx)
self.assertRaises(RuntimeError, lambda: ctx.node_id)
current_ctx.set(value)
self.assertEqual(value, current_ctx.get_ctx())
self.assertEqual(value.node_id, ctx.node_id)
current_ctx.clear()
self.assertRaises(RuntimeError, current_ctx.get_ctx)
self.assertRaises(RuntimeError, lambda: ctx.node_id)
except Exception, e:
queue.put(e)
def _install_script(name, windows, user, manager, attributes, tmpdir, logger,
tenant):
# Download cert from manager in order to include its content
# in the init_script.
local_cert_path = str(tmpdir / 'cloudify_internal_cert.pem')
logger.info('Downloading internal cert from manager: %s -> %s',
attributes.LOCAL_REST_CERT_FILE,
local_cert_path)
with manager.ssh() as fabric:
fabric.get(attributes.LOCAL_REST_CERT_FILE, local_cert_path)
env_vars = {
constants.REST_HOST_KEY: manager.private_ip_address,
constants.REST_PORT_KEY: str(defaults.INTERNAL_REST_PORT),
constants.BROKER_SSL_CERT_PATH: local_cert_path,
constants.LOCAL_REST_CERT_FILE_KEY: local_cert_path,
constants.MANAGER_FILE_SERVER_URL_KEY: (
'https://{0}:{1}/resources'.format(manager.private_ip_address,
defaults.INTERNAL_REST_PORT)
),
constants.MANAGER_FILE_SERVER_ROOT_KEY: str(tmpdir),
}
(tmpdir / 'cloudify_agent').mkdir()
ctx = MockCloudifyContext(
node_id='node',
tenant={'name': tenant},
rest_token=manager.client.tokens.get().value,
properties={'agent_config': {
'user': user,
'windows': windows,
'install_method': 'init_script',
'rest_host': manager.private_ip_address,
'broker_ip': manager.private_ip_address,
'name': name
}})
try:
current_ctx.set(ctx)
os.environ.update(env_vars)
script_builder = script._get_script_builder()
install_script = script_builder.install_script()
finally:
for var_name in list(env_vars):
os.environ.pop(var_name, None)
current_ctx.clear()
# Replace the `main` call with an install call - as we only want to
# install the agent, but not configure/start it
install_method = 'InstallAgent' if windows else 'install_agent'
install_script = '\n'.join(install_script.split('\n')[:-1])
return '{0}\n{1}'.format(install_script, install_method)
def test_rm_pgaas_cluster(monkeypatch):
"""
test rm_pgaas_cluster()
"""
try:
set_mock_context('test_rm_pgaas_cluster', monkeypatch)
pgaas.pgaas_plugin.rm_pgaas_cluster(args={})
except Exception as e:
print("Error: {0}".format(e))
print("Stack: {0}".format(traceback.format_exc()))
raise
finally:
current_ctx.clear()
def test_delete_database(monkeypatch):
"""
test delete_database()
"""
try:
set_mock_context('test_delete_database', monkeypatch)
pgaas.pgaas_plugin.delete_database(args={})
except Exception as e:
print("Error: {0}".format(e))
print("Stack: {0}".format(traceback.format_exc()))
raise
finally:
current_ctx.clear()
def run(queue, value):
try:
self.assertRaises(RuntimeError, current_ctx.get_ctx)
self.assertRaises(RuntimeError, lambda: ctx.instance.id)
current_ctx.set(value)
self.assertEqual(value, current_ctx.get_ctx())
self.assertEqual(value.instance.id, ctx.instance.id)
current_ctx.clear()
self.assertRaises(RuntimeError, current_ctx.get_ctx)
self.assertRaises(RuntimeError, lambda: ctx.instance.id)
except Exception as e:
queue.put(e)
else:
queue.put('ok')
def run(queue, value):
try:
self.assertRaises(RuntimeError, current_ctx.get_ctx)
self.assertRaises(RuntimeError, lambda: ctx.instance.id)
current_ctx.set(value)
self.assertEqual(value, current_ctx.get_ctx())
self.assertEqual(value.instance.id, ctx.instance.id)
current_ctx.clear()
self.assertRaises(RuntimeError, current_ctx.get_ctx)
self.assertRaises(RuntimeError, lambda: ctx.instance.id)
except Exception as e:
queue.put(e)
else:
queue.put("ok")
def newfcn(monkeypatch):
monkeypatch.setattr(requests, 'delete', _delete)
monkeypatch.setattr(requests, 'get', _get)
monkeypatch.setattr(requests, 'post', _post)
monkeypatch.setattr(requests, 'put', _put)
properties = { 'fqdn': fqdn, 'openstack': os }
if ttl is not None:
properties['ttl'] = ttl
mock_ctx = MockCloudifyContext(node_id='test_node_id', node_name='test_node_name', properties=properties)
try:
current_ctx.set(mock_ctx)
fcn()
finally:
current_ctx.clear()
def test_create_path(self, mock_put, mock_get):
# Path
properties = {}
props = {
NAME: 'path_name',
EP1_NODE_ID: 'openflow:101',
EP2_NODE_ID: 'openflow:303',
PROVIDER: 'sr',
RULES: [],
CONTRAINTS: {
WAYPOINT: []
}
}
properties.update(props)
props = {
CONTRAINTS: {
WAYPOINT: ['openflow:102', 'openflow:103']
},
}
properties.update(props)
ctx = setup_ctx('path_name', properties, PATH_TYPE)
ctx.instance.runtime_properties['node_type'] = PATH_TYPE
try:
ctx.logger.debug("properties: {}".format(properties))
# controller returns a 201 response when creating a path
put_resp = MockRequestsResponse()
mock_put.status_code = 200
mock_put.return_value = put_resp
get_resp = MockRequestsResponse()
get_resp.status_code = 200
get_resp.content = json.dumps({'path': [{'name': 'path_name'}]})
mock_get.side_effect = [get_resp]
path.create(ctx)
# check mock calls
self.assertEquals(len(mock_put.mock_calls), 1)
self.assertEquals(len(mock_get.mock_calls), 1)
ctx.logger.info("request_calls {}".format(len(
mock_put.mock_calls)))
pass
finally:
current_ctx.clear()
def set_mock_context(agent_ssl_cert, tmp_path, **override_properties):
node_properties = {
'agent_config': {
'user': getpass.getuser(),
'install_method': 'init_script',
'rest_host': '127.0.0.1',
'windows': os.name == 'nt',
'basedir': str(tmp_path),
}
}
node_properties['agent_config'].update(**override_properties)
current_ctx.set(
mock_context(agent_ssl_cert, node_id='d', properties=node_properties))
yield
current_ctx.clear()
def test_create_eline_vlan(self, mock_put, mock_get):
# Eline
properties = {}
props = {
NAME: 'eline_name',
PATH_NAME: 'path_name',
ENDPOINT1: {
'network_type': 'vlan',
'switch_id': 'openflow:101',
'switch_port': '3',
'segmentation_id': 100
},
ENDPOINT2: {
'network_type': 'vlan',
'switch_id': 'openflow:303',
'switch_port': '3',
'segmentation_id': 100 # range: 0 - 4094
},
PROTOCOL_TYPE: ''
}
properties.update(props)
ctx = setup_ctx('eline_name', properties, ELINE_TYPE)
try:
ctx.logger.debug("properties: {}".format(properties))
put_resp = MockRequestsResponse()
mock_put.status_code = 200
mock_put.return_value = put_resp
get_resp = MockRequestsResponse()
get_resp.status_code = 200
get_resp.content = json.dumps({'eline': [{'name': 'eline_name'}]})
mock_get.side_effect = [get_resp]
eline.create(ctx)
self.assertEquals(len(mock_put.mock_calls), 1)
self.assertEquals(len(mock_get.mock_calls), 1)
ctx.logger.info(
"request_calls {}".format(len(mock_put.mock_calls)))
pass
finally:
current_ctx.clear()
def test_bad_add_database(monkeypatch):
"""
test bad_add_database()
"""
try:
set_mock_context('test_add_database',
monkeypatch,
writerfqdn="bad.bar.example.com")
with pytest.raises(NonRecoverableError):
pgaas.pgaas_plugin.create_database(args={})
except Exception as e:
print("Error: {0}".format(e))
print("Stack: {0}".format(traceback.format_exc()))
raise
finally:
current_ctx.clear()
def test_discovery_kv(monkeypatch):
"""test finding policy-handler in consul"""
monkeypatch.setattr('requests.get', monkeyed_discovery_get_kv)
node_policy = MonkeyedNode('test_dcae_policy_node_id',
'test_dcae_policy_node_name',
tasks.DCAE_POLICY_TYPE,
{POLICY_ID: MONKEYED_POLICY_ID})
try:
current_ctx.set(node_policy.ctx)
tasks.PolicyHandler._lazy_init()
assert POLICY_HANDLER_FROM_KV == tasks.PolicyHandler._url
finally:
tasks.PolicyHandler._url = None
MockCloudifyContextFull.clear()
current_ctx.clear()
def test_update_database(monkeypatch):
"""
test update_database()
"""
try:
########################################################
# Subtle test implications regarding: update_database #
# --------------------------------------------------- #
# 1) update_database is a workflow and the context #
# passed to it has 'nodes' attribute which is not #
# not included in MockCloudifyContext #
# 2) the 'nodes' attribute is a list of contexts so #
# we will have to create a sub-context #
# 3) update_database will iterate through each of the #
# nodes contexts looking for the correct one #
# 4) To identify the correct sub-context it will first#
# check each sub-context for the existence of #
# properties attribute #
# 5) ****Mock_context internally saves properties as #
# variable _properties and 'properties' is defined #
# as @property...thus it is not recognized as an #
# attribute...this will cause update_database to #
# fail so we need to explicitly create properties #
# properties attribute in the subcontext #
########################################################
####################
# Main context #
####################
myctx = set_mock_context('test_update_database', monkeypatch)
###########################################################
# Create subcontext and assign it to attribute properties #
# in main context #
###########################################################
mynode = set_mock_context('test_update_database_node', monkeypatch)
# pylint: disable=protected-access
mynode.properties = mynode._properties
myctx.nodes = [mynode]
pgaas.pgaas_plugin.update_database(refctx=myctx)
except Exception as e:
print("Error: {0}".format(e))
print("Stack: {0}".format(traceback.format_exc()))
raise
finally:
current_ctx.clear()
def install_script(name, windows, user, manager_host):
env_vars = {}
env_vars[constants.MANAGER_FILE_SERVER_URL_KEY] = '{0}://{1}:{2}'.format(
defaults.FILE_SERVER_PROTOCOL, manager_host, defaults.FILE_SERVER_PORT)
env_vars[constants.FILE_SERVER_PORT_KEY] = str(defaults.FILE_SERVER_PORT)
env_vars[constants.FILE_SERVER_PROTOCOL_KEY] = \
defaults.FILE_SERVER_PROTOCOL
env_vars[constants.REST_PORT_KEY] = str(defaults.REST_PORT)
env_vars[constants.REST_PROTOCOL_KEY] = defaults.REST_PROTOCOL
env_vars[constants.SECURITY_ENABLED_KEY] = str(defaults.SECURITY_ENABLED)
env_vars[constants.VERIFY_REST_CERTIFICATE_KEY] = \
str(defaults.VERIFY_REST_CERTIFICATE)
env_vars[constants.REST_CERT_CONTENT_KEY] = ''
ctx = MockCloudifyContext(
node_id='node',
properties={'agent_config': {
'user': user,
'windows': windows,
'install_method': 'provided',
'rest_host': manager_host,
'file_server_host': manager_host,
'broker_ip': manager_host,
'name': name
}})
try:
current_ctx.set(ctx)
os.environ.update(env_vars)
init_script = script.init_script(cloudify_agent={})
finally:
for var_name in env_vars.iterkeys():
os.environ.pop(var_name)
current_ctx.clear()
result = '\n'.join(init_script.split('\n')[:-1])
if windows:
return '{0}\n' \
'DownloadAndExtractAgentPackage\n' \
'ExportDaemonEnv\n' \
'ConfigureAgent'.format(result)
else:
return '{0}\n' \
'install_agent'.format(result)
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 = CloudifyContext(ctx)
kwargs['ctx'] = ctx
try:
current_ctx.set(ctx, kwargs)
result = func(*args, **kwargs)
except BaseException:
ctx.logger.error(
'Exception raised on operation [%s] invocation',
ctx.task_name, exc_info=True)
raise
finally:
current_ctx.clear()
ctx.update()
return result
def test_serial_operation_uninstall_wait_3(self, _mock, list_fn):
_ctx = MockCloudifyContext(node_id='test_node',
deployment_id='test_deployment',
index=7)
# Check that we raise if the preceder is not 'started'.
_ctx._context['workflow_id'] = 'uninstall'
current_ctx.set(_ctx)
_mock.side_effect = lambda: rest_client_mock.MockRestclient()
_caller = Mock()
@serial_operation(threshold=3, workflows=['uninstall'])
def run_op_wait_for_3(ctx=_ctx, **kwargs):
_caller()
finished3 = []
for n in range(1, 8):
if n == 7:
continue
elif n in [1, 2, 3]:
state = 'started'
else:
state = 'uninitialized'
finished3.append(
Mock(id='test_node{x}'.format(x=n), index=n, state=state))
list_fn.return_value = finished3
self.assertRaises(CloudifySerializationRetry, run_op_wait_for_3)
self.assertFalse(_caller.called)
# Check if we cross the serialization_type threshold,
# then we do not trigger the retry.
list_fn.return_value = [
Mock(id='test_node{x}'.format(x=n),
index=n,
state='started' if n < 7 else 'uninitialized')
for n in range(3, 10) if n != 7
]
run_op_wait_for_3()
self.assertTrue(_caller.called)
current_ctx.clear()
def test_discovery(monkeypatch):
"""test finding policy-handler in consul"""
monkeypatch.setattr('requests.get', monkeyed_discovery_get)
node_policy = MonkeyedNode('test_dcae_policy_node_id',
'test_dcae_policy_node_name',
tasks.DCAE_POLICY_TYPE,
{POLICY_ID: MONKEYED_POLICY_ID})
try:
current_ctx.set(node_policy.ctx)
expected = "http://monkey-policy-handler-address:9999"
CtxLogger.log_ctx_info("before PolicyHandler._lazy_init")
tasks.PolicyHandler._lazy_init()
CtxLogger.log_ctx_info("after PolicyHandler._lazy_init")
assert expected == tasks.PolicyHandler._url
finally:
tasks.PolicyHandler._url = None
MockCloudifyContextFull.clear()
current_ctx.clear()
def test_discovery_failure(monkeypatch):
"""test finding policy-handler in consul"""
monkeypatch.setattr('requests.get', monkeyed_discovery_get_failure)
node_policy = MonkeyedNode('test_dcae_policy_node_id',
'test_dcae_policy_node_name',
tasks.DCAE_POLICY_TYPE,
{POLICY_ID: MONKEYED_POLICY_ID})
try:
current_ctx.set(node_policy.ctx)
with pytest.raises(NonRecoverableError) as excinfo:
tasks.PolicyHandler._lazy_init()
CtxLogger.log_ctx_info("test_discovery_failure: {0}".format(
str(excinfo.value)))
assert str(excinfo.value).startswith("ConnectionError")
finally:
tasks.PolicyHandler._url = None
MockCloudifyContextFull.clear()
current_ctx.clear()
def test_policies_find(monkeypatch):
"""test policy_get operation on dcae.nodes.policies node"""
tasks.PolicyHandler._url = tasks.PolicyHandler.DEFAULT_URL
monkeypatch.setattr('requests.post', monkeyed_policy_handler_find)
node_policies = MonkeyedNode(
'test_dcae_policies_node_id', 'test_dcae_policies_node_name',
tasks.DCAE_POLICIES_TYPE, {
tasks.POLICY_FILTER: {
POLICY_NAME:
MONKEYED_POLICY_ID,
tasks.CONFIG_ATTRIBUTES:
json.dumps({CONFIG_NAME: "alex_config_name"})
}
})
try:
current_ctx.set(node_policies.ctx)
CtxLogger.log_ctx_info("before policy_get")
tasks.policy_get()
CtxLogger.log_ctx_info("after policy_get")
expected = {
tasks.POLICIES_FILTERED: {
MONKEYED_POLICY_ID:
MonkeyedPolicyBody.create_policy(MONKEYED_POLICY_ID)
}
}
result = node_policies.ctx.instance.runtime_properties
node_policies.ctx.logger.info(
"expected runtime_properties: {0}".format(json.dumps(expected)))
node_policies.ctx.logger.info("runtime_properties: {0}".format(
json.dumps(result)))
assert MonkeyedPolicyBody.is_the_same_dict(result, expected)
assert MonkeyedPolicyBody.is_the_same_dict(expected, result)
finally:
MockCloudifyContextFull.clear()
current_ctx.clear()
def test_op_rollback(self, mock_execute_command):
# test operation rollback
"""
:rollback operation test:
"""
props = {
'component_name': 'test_node',
'namespace': 'onap',
'tiller_port': '8888',
'tiller_ip': '1.1.1.1',
'tls_enable': 'false'
}
args = {'revision': '1'}
mock_ctx = MockCloudifyContext(node_id='test_node_id', node_name='test_node_name',
properties=props)
try:
current_ctx.set(mock_ctx)
with mock.patch('plugin.tasks.get_current_helm_value'):
with mock.patch('plugin.tasks.get_helm_history'):
plugin.tasks.rollback(**args)
finally:
current_ctx.clear()
def test_delete_eline(self, mock_delete): # mock_get,
properties = {}
props = {
NAME: 'eline_name',
PATH_NAME: 'path_name',
}
properties.update(props)
ctx = setup_ctx('eline_name', properties, ELINE_TYPE)
try:
# controller returns a 201 response when deleting an eline
put_resp = MockRequestsResponse()
mock_delete.status_code = 201
mock_delete.return_value = put_resp
eline.delete(ctx)
self.assertEquals(len(mock_delete.mock_calls), 1)
ctx.logger.info(
"request_calls {}".format(len(mock_delete.mock_calls)))
pass
finally:
current_ctx.clear()
def test_serial_operation_uninstall(self, _mock, list_fn):
_ctx = MockCloudifyContext(node_id='test_node',
deployment_id='test_deployment',
index=7)
# Check that we raise if the preceder is not 'started'.
_ctx._context['workflow_id'] = 'uninstall'
current_ctx.set(_ctx)
_mock.side_effect = lambda: rest_client_mock.MockRestclient()
_caller = Mock()
@serial_operation(workflows=['uninstall'])
def run_op_uninstall_only(ctx=_ctx, **kwargs):
_caller()
list_fn.return_value = [
Mock(id='test_node{x}'.format(x=n), index=n, state='uninitialized')
for n in range(1, 8) if n != 7
]
self.assertRaises(CloudifySerializationRetry, run_op_uninstall_only)
self.assertFalse(_caller.called)
current_ctx.clear()
def setUp(self):
super(BaseInitScriptTest, self).setUp()
ctx = MockCloudifyContext(
node_id='d',
properties={'agent_config': {
'user': self.username,
'install_method': 'init_script',
'rest_host': 'localhost',
'windows': self.windows,
'basedir': self.temp_folder
}})
current_ctx.set(ctx)
self.addCleanup(lambda: current_ctx.clear())
self.input_cloudify_agent = {'broker_ip': 'localhost'}
def test_serial_operation_install_wait_for_1(self, list_fn):
_ctx = MockCloudifyContext(node_id='test_node',
deployment_id='test_deployment',
index=7)
# Check that we raise if the preceder is not 'started'.
_ctx._context['workflow_id'] = 'install'
current_ctx.set(_ctx)
_caller = Mock()
@serial_operation(threshold=1)
def run_op_wait_for_1(ctx=_ctx, **kwargs):
_caller()
list_fn.return_value = [
Mock(id='test_node{x}'.format(x=n),
index=n,
state='started' if n == 6 else 'uninitialized')
for n in range(0, 6)
]
run_op_wait_for_1()
self.assertTrue(_caller.called)
current_ctx.clear()
def setUp(self):
super(BaseInitScriptTest, self).setUp()
ctx = MockCloudifyContext(
node_id='d',
properties={'agent_config': {
'user': self.username,
'install_method': 'init_script',
'manager_ip': 'localhost',
'windows': self.windows,
'basedir': self.temp_folder
}})
current_ctx.set(ctx)
self.addCleanup(lambda: current_ctx.clear())
os.environ['MANAGER_FILE_SERVER_URL'] = ''
self.addCleanup(lambda: os.environ.pop('MANAGER_FILE_SERVER_URL',
None))
self.input_cloudify_agent = {}
def tearDown(self):
current_ctx.clear()
super(VsphereControllerTest, self).tearDown()
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
def tearDown(self):
current_ctx.clear()
def tearDown(self):
current_ctx.clear()
super(BackupServerTest, self).tearDown()
def cleanup(self):
tasks.eval_script = self.original_eval_script
tasks.execute = self.original_execute
os.chmod = self.original_os_chmod
current_ctx.clear()
def tearDown(self):
current_ctx.clear()
if os.path.exists(self.keyfile):
os.unlink(self.keyfile)
def tearDown(self):
current_ctx.clear()
super(ComponentTestBase, self).tearDown()
