def test_get_resolver(self):
cli_runner.run_cli('cfy init -r')
resolver_configuration = create_resolver_configuration(
implementation='mock implementation', parameters='mock parameters')
update_config_file(resolver_configuration=resolver_configuration)
with mock.patch('dsl_parser.utils.create_import_resolver') as \
mock_create_import_resolver:
utils.get_import_resolver()
mock_create_import_resolver.assert_called_once_with(
resolver_configuration[IMPORT_RESOLVER_KEY])
def test_get_resolver(self):
cli_runner.run_cli('cfy init -r')
resolver_configuration = create_resolver_configuration(
implementation='mock implementation',
parameters='mock parameters')
update_config_file(resolver_configuration=resolver_configuration)
with mock.patch('dsl_parser.utils.create_import_resolver') as \
mock_create_import_resolver:
utils.get_import_resolver()
mock_create_import_resolver.assert_called_once_with(
resolver_configuration[IMPORT_RESOLVER_KEY])
def init(blueprint_path,
inputs,
install_plugins):
if os.path.isdir(_storage_dir()):
shutil.rmtree(_storage_dir())
if not utils.is_initialized():
cfy_init(reset_config=False, skip_logging=True)
try:
common.initialize_blueprint(
blueprint_path=blueprint_path,
name=_NAME,
inputs=inputs,
storage=_storage(),
install_plugins=install_plugins,
resolver=utils.get_import_resolver()
)
except ImportError as e:
# import error indicates
# some plugin modules are missing
# TODO - consider adding an error code to
# TODO - all of our exceptions. so that we
# TODO - easily identify them here
e.possible_solutions = [
"Run `cfy local init --install-plugins -p {0}`"
.format(blueprint_path),
"Run `cfy local install-plugins -p {0}`"
.format(blueprint_path)
]
raise
get_logger().info("Initiated {0}\nIf you make changes to the "
"blueprint, run `cfy local init -p {0}` "
"again to apply them".format(blueprint_path))
def init(blueprint_path, inputs, install_plugins_):
if os.path.isdir(_storage_dir()):
shutil.rmtree(_storage_dir())
if not utils.is_initialized():
cfy_init(reset_config=False, skip_logging=True)
try:
common.initialize_blueprint(blueprint_path=blueprint_path,
name=_NAME,
inputs=inputs,
storage=_storage(),
install_plugins=install_plugins_,
resolver=utils.get_import_resolver())
except ImportError as e:
# import error indicates
# some plugin modules are missing
# TODO - consider adding an error code to
# TODO - all of our exceptions. so that we
# TODO - easily identify them here
e.possible_solutions = [
"Run 'cfy local init --install-plugins -p {0}'".format(
blueprint_path),
"Run 'cfy local install-plugins -p {0}'".format(blueprint_path)
]
raise
get_logger().info("Initiated {0}\nIf you make changes to the "
"blueprint, "
"run 'cfy local init -p {0}' "
"again to apply them".format(blueprint_path))
def test_get_custom_resolver(self):
cli_runner.run_cli('cfy init -r')
parameters = {'param': 'custom-parameter'}
custom_resolver_class_path = "%s:%s" % (
CustomImportResolver.__module__, CustomImportResolver.__name__)
import_resolver_config = create_resolver_configuration(
implementation=custom_resolver_class_path, parameters=parameters)
update_config_file(resolver_configuration=import_resolver_config)
resolver = utils.get_import_resolver()
self.assertEqual(type(resolver), CustomImportResolver)
self.assertEqual(resolver.param, 'custom-parameter')
def test_get_custom_resolver(self):
cli_runner.run_cli('cfy init -r')
parameters = {'param': 'custom-parameter'}
custom_resolver_class_path = "%s:%s" % (
CustomImportResolver.__module__, CustomImportResolver.__name__)
import_resolver_config = create_resolver_configuration(
implementation=custom_resolver_class_path, parameters=parameters)
update_config_file(resolver_configuration=import_resolver_config)
resolver = utils.get_import_resolver()
self.assertEqual(type(resolver), CustomImportResolver)
self.assertEqual(resolver.param, 'custom-parameter')
def validate(blueprint_path):
logger = get_logger()
logger.info(messages.VALIDATING_BLUEPRINT.format(blueprint_path.name))
try:
resolver = utils.get_import_resolver()
parse_from_path(dsl_file_path=blueprint_path.name, resolver=resolver)
except DSLParsingException as ex:
msg = (messages.VALIDATING_BLUEPRINT_FAILED.format(
blueprint_path.name, str(ex)))
raise CloudifyCliError(msg)
logger.info(messages.VALIDATING_BLUEPRINT_SUCCEEDED)
def validate(blueprint_path):
logger = get_logger()
logger.info(
messages.VALIDATING_BLUEPRINT.format(blueprint_path.name))
try:
resolver = utils.get_import_resolver()
parse_from_path(dsl_file_path=blueprint_path.name, resolver=resolver)
except DSLParsingException as ex:
msg = (messages.VALIDATING_BLUEPRINT_FAILED
.format(blueprint_path.name, str(ex)))
raise CloudifyCliError(msg)
logger.info(messages.VALIDATING_BLUEPRINT_SUCCEEDED)
def validate(blueprint_path):
logger = get_logger()
logger.info(
'Validating blueprint: {0}'.format(blueprint_path.name))
try:
resolver = utils.get_import_resolver()
validate_version = utils.is_validate_definitions_version()
parse_from_path(dsl_file_path=blueprint_path.name,
resolver=resolver,
validate_version=validate_version)
except DSLParsingException as ex:
raise CloudifyCliError('Failed to validate blueprint {0}'.format(
str(ex)))
logger.info('Blueprint validated successfully')
def bootstrap(keep_up,
validate_only,
skip_validations,
blueprint_path,
inputs,
install_plugins,
task_retries,
task_retry_interval,
task_thread_pool_size):
logger = get_logger()
env_name = 'manager'
# Verify directory is initialized
utils.get_context_path()
# verifying no environment exists from a previous bootstrap
try:
bs.load_env(env_name)
except IOError:
# Environment is clean
pass
else:
raise RuntimeError(
"Can't bootstrap because the environment is not clean. Clean the "
'environment by calling teardown or reset it using the "cfy init '
'-r" command')
if not skip_validations:
logger.info('Executing bootstrap validation...')
bs.bootstrap_validation(
blueprint_path,
name=env_name,
inputs=inputs,
task_retries=task_retries,
task_retry_interval=task_retry_interval,
task_thread_pool_size=task_thread_pool_size,
install_plugins=install_plugins,
resolver=utils.get_import_resolver())
logger.info('Bootstrap validation completed successfully')
if not validate_only:
try:
logger.info('Executing manager bootstrap...')
details = bs.bootstrap(
blueprint_path,
name=env_name,
inputs=inputs,
task_retries=task_retries,
task_retry_interval=task_retry_interval,
task_thread_pool_size=task_thread_pool_size,
install_plugins=install_plugins)
manager_ip = details['manager_ip']
provider_context = details['provider_context']
with utils.update_wd_settings() as ws_settings:
ws_settings.set_management_server(manager_ip)
ws_settings.set_management_key(details['manager_key_path'])
ws_settings.set_management_user(details['manager_user'])
ws_settings.set_provider_context(provider_context)
ws_settings.set_rest_port(details['rest_port'])
ws_settings.set_protocol(details['protocol'])
logger.info('Bootstrap complete')
logger.info('Manager is up at {0}'.format(manager_ip))
except Exception as ex:
tpe, value, traceback = sys.exc_info()
logger.error('Bootstrap failed! ({0})'.format(str(ex)))
if not keep_up:
try:
bs.load_env(env_name)
except IOError:
# the bootstrap exception occurred before environment was
# even initialized - nothing to teardown.
pass
else:
logger.info(
'Executing teardown due to failed bootstrap...')
bs.teardown(name=env_name,
task_retries=5,
task_retry_interval=30,
task_thread_pool_size=1)
raise tpe, value, traceback
def _validate_blueprint(self, blueprint_file):
resolver = get_import_resolver()
validate_version = is_validate_definitions_version()
parse_from_path(dsl_file_path=blueprint_file,
resolver=resolver,
validate_version=validate_version)
def bootstrap(blueprint_path,
name='manager',
inputs=None,
task_retries=5,
task_retry_interval=30,
task_thread_pool_size=1,
install_plugins=False):
def get_protocol(rest_port):
return constants.SECURED_PROTOCOL \
if str(rest_port) == str(constants.SECURED_REST_PORT) \
else constants.DEFAULT_PROTOCOL
storage = local.FileStorage(storage_dir=_workdir())
try:
env = common.initialize_blueprint(
blueprint_path,
name=name,
inputs=inputs,
storage=storage,
install_plugins=install_plugins,
resolver=utils.get_import_resolver()
)
except ImportError as e:
e.possible_solutions = [
"Run 'cfy local install-plugins -p {0}'"
.format(blueprint_path),
"Run 'cfy bootstrap --install-plugins -p {0}'"
.format(blueprint_path)
]
raise
env.execute(workflow='install',
task_retries=task_retries,
task_retry_interval=task_retry_interval,
task_thread_pool_size=task_thread_pool_size)
nodes = env.storage.get_nodes()
node_instances = env.storage.get_node_instances()
nodes_by_id = {node.id: node for node in nodes}
try:
manager_node_instance = \
next(node_instance for node_instance in node_instances if
'cloudify.nodes.CloudifyManager' in
nodes_by_id[node_instance.node_id].type_hierarchy)
except Exception:
manager_node_instance = \
next(node_instance for node_instance in node_instances if
'cloudify.nodes.MyCloudifyManager' in
nodes_by_id[node_instance.node_id].type_hierarchy)
manager_node = nodes_by_id['manager_configuration']
if manager_node_instance.runtime_properties.get('provider'):
provider_context = \
manager_node_instance.runtime_properties[
PROVIDER_RUNTIME_PROPERTY]
manager_ip = \
manager_node_instance.runtime_properties[
MANAGER_IP_RUNTIME_PROPERTY]
manager_user = \
manager_node_instance.runtime_properties[
MANAGER_USER_RUNTIME_PROPERTY]
manager_key_path = manager_node_instance.runtime_properties[
MANAGER_KEY_PATH_RUNTIME_PROPERTY]
rest_port = \
manager_node_instance.runtime_properties[REST_PORT]
else:
manager_ip = env.outputs()['manager_ip']
manager_user = manager_node.properties['ssh_user']
manager_key_path = manager_node.properties['ssh_key_filename']
rest_port = manager_node_instance.runtime_properties[REST_PORT]
fabric_env = {
"host_string": manager_ip,
"user": manager_user,
"key_filename": manager_key_path
}
agent_remote_key_path = _handle_agent_key_file(fabric_env,
manager_node)
provider_context = _handle_provider_context(
agent_remote_key_path=agent_remote_key_path,
fabric_env=fabric_env,
manager_node=manager_node,
manager_node_instance=manager_node_instance)
_upload_resources(manager_node, fabric_env, manager_ip, rest_port,
get_protocol(rest_port))
protocol = get_protocol(rest_port)
return {
'provider_name': 'provider',
'provider_context': provider_context,
'manager_ip': manager_ip,
'manager_user': manager_user,
'manager_key_path': manager_key_path,
'rest_port': rest_port,
'protocol': protocol
}
def bootstrap(
keep_up,
validate_only,
skip_validations,
blueprint_path,
inputs,
install_plugins,
task_retries,
task_retry_interval,
task_thread_pool_size,
):
logger = get_logger()
env_name = "manager"
# Verify directory is initialized
utils.get_context_path()
# verifying no environment exists from a previous bootstrap
try:
bs.load_env(env_name)
except IOError:
# Environment is clean
pass
else:
raise RuntimeError(
"Can't bootstrap because the environment is not clean. Clean the "
'environment by calling teardown or reset it using the "cfy init '
'-r" command'
)
if not skip_validations:
logger.info("Executing bootstrap validation...")
bs.bootstrap_validation(
blueprint_path,
name=env_name,
inputs=inputs,
task_retries=task_retries,
task_retry_interval=task_retry_interval,
task_thread_pool_size=task_thread_pool_size,
install_plugins=install_plugins,
resolver=utils.get_import_resolver(),
)
logger.info("Bootstrap validation completed successfully")
elif inputs:
# The user expects that `--skip-validations` will also ignore
# bootstrap validations and not only creation_validations
inputs = common.add_ignore_bootstrap_validations_input(inputs)
if not validate_only:
try:
logger.info("Executing manager bootstrap...")
details = bs.bootstrap(
blueprint_path,
name=env_name,
inputs=inputs,
task_retries=task_retries,
task_retry_interval=task_retry_interval,
task_thread_pool_size=task_thread_pool_size,
install_plugins=install_plugins,
)
manager_ip = details["manager_ip"]
provider_context = details["provider_context"]
with utils.update_wd_settings() as ws_settings:
ws_settings.set_management_server(manager_ip)
ws_settings.set_management_key(details["manager_key_path"])
ws_settings.set_management_user(details["manager_user"])
ws_settings.set_management_port(details["manager_port"])
ws_settings.set_provider_context(provider_context)
ws_settings.set_rest_port(details["rest_port"])
ws_settings.set_rest_protocol(details["rest_protocol"])
logger.info("Bootstrap complete")
logger.info("Manager is up at {0}".format(manager_ip))
except Exception as ex:
tpe, value, traceback = sys.exc_info()
logger.error("Bootstrap failed! ({0})".format(str(ex)))
if not keep_up:
try:
bs.load_env(env_name)
except IOError:
# the bootstrap exception occurred before environment was
# even initialized - nothing to teardown.
pass
else:
logger.info("Executing teardown due to failed bootstrap...")
bs.teardown(name=env_name, task_retries=5, task_retry_interval=30, task_thread_pool_size=1)
raise tpe, value, traceback
def bootstrap(blueprint_path,
name='manager',
inputs=None,
task_retries=5,
task_retry_interval=30,
task_thread_pool_size=1,
install_plugins=False):
storage = local.FileStorage(storage_dir=_workdir())
try:
env = common.initialize_blueprint(
blueprint_path,
name=name,
inputs=inputs,
storage=storage,
install_plugins=install_plugins,
resolver=utils.get_import_resolver()
)
except ImportError as e:
e.possible_solutions = [
"Run 'cfy local install-plugins -p {0}'"
.format(blueprint_path),
"Run 'cfy bootstrap --install-plugins -p {0}'"
.format(blueprint_path)
]
raise
env.execute(workflow='install',
task_retries=task_retries,
task_retry_interval=task_retry_interval,
task_thread_pool_size=task_thread_pool_size)
nodes = env.storage.get_nodes()
node_instances = env.storage.get_node_instances()
nodes_by_id = {node.id: node for node in nodes}
try:
manager_node_instance = \
next(node_instance for node_instance in node_instances if
'cloudify.nodes.CloudifyManager' in
nodes_by_id[node_instance.node_id].type_hierarchy)
except Exception:
manager_node_instance = \
next(node_instance for node_instance in node_instances if
'cloudify.nodes.MyCloudifyManager' in
nodes_by_id[node_instance.node_id].type_hierarchy)
manager_node = nodes_by_id['manager_configuration']
rest_port = manager_node_instance.runtime_properties[
constants.REST_PORT_RUNTIME_PROPERTY]
rest_protocol = manager_node_instance.runtime_properties[
constants.REST_PROTOCOL_RUNTIME_PROPERTY]
if manager_node_instance.runtime_properties.get('provider'):
provider_context = \
manager_node_instance.runtime_properties[
PROVIDER_RUNTIME_PROPERTY]
manager_ip = \
manager_node_instance.runtime_properties[
MANAGER_IP_RUNTIME_PROPERTY]
manager_user = \
manager_node_instance.runtime_properties[
MANAGER_USER_RUNTIME_PROPERTY]
manager_port = \
manager_node_instance.runtime_properties[
MANAGER_PORT_RUNTIME_PROPERTY]
manager_key_path = manager_node_instance.runtime_properties[
MANAGER_KEY_PATH_RUNTIME_PROPERTY]
else:
manager_ip = env.outputs()['manager_ip']
manager_user = manager_node.properties['ssh_user']
manager_port = manager_node.properties['ssh_port']
manager_key_path = manager_node.properties['ssh_key_filename']
fabric_env = build_fabric_env(
manager_ip, manager_user, manager_key_path, manager_port)
agent_remote_key_path = _handle_agent_key_file(fabric_env,
manager_node)
# dump public rest certificate to a local file for future
# communication with the rest server
rest_public_cert = env.outputs()['rest_server_public_certificate']
if rest_public_cert:
cert_path = utils.get_default_rest_cert_local_path()
with open(cert_path, 'w') as cert_file:
cert_file.write(rest_public_cert)
rest_client = utils.get_rest_client(rest_host=manager_ip,
rest_port=rest_port,
rest_protocol=rest_protocol,
username=utils.get_username(),
password=utils.get_password(),
skip_version_check=True)
provider_context = _handle_provider_context(
rest_client=rest_client,
remote_agents_private_key_path=agent_remote_key_path,
manager_node=manager_node,
manager_node_instance=manager_node_instance)
_upload_resources(manager_node, fabric_env, rest_client, task_retries,
task_retry_interval)
_perform_sanity(env=env,
manager_ip=manager_ip,
fabric_env=fabric_env,
task_retries=task_retries,
task_retry_interval=task_retry_interval,
task_thread_pool_size=task_thread_pool_size)
return {
'provider_name': 'provider',
'provider_context': provider_context,
'manager_ip': manager_ip,
'manager_user': manager_user,
'manager_port': manager_port,
'manager_key_path': manager_key_path,
'rest_port': rest_port,
'rest_protocol': rest_protocol
}
def bootstrap(keep_up, validate_only, skip_validations, blueprint_path, inputs,
install_plugins, task_retries, task_retry_interval,
task_thread_pool_size):
logger = get_logger()
env_name = 'manager'
# Verify directory is initialized
utils.get_context_path()
# verifying no environment exists from a previous bootstrap
try:
bs.load_env(env_name)
except IOError:
# Environment is clean
pass
else:
raise RuntimeError(
"Can't bootstrap because the environment is not clean. Clean the "
'environment by calling teardown or reset it using the "cfy init '
'-r" command')
if not skip_validations:
logger.info('executing bootstrap validation')
bs.bootstrap_validation(blueprint_path,
name=env_name,
inputs=inputs,
task_retries=task_retries,
task_retry_interval=task_retry_interval,
task_thread_pool_size=task_thread_pool_size,
install_plugins=install_plugins,
resolver=utils.get_import_resolver())
logger.info('bootstrap validation completed successfully')
if not validate_only:
try:
logger.info('executing bootstrap')
details = bs.bootstrap(blueprint_path,
name=env_name,
inputs=inputs,
task_retries=task_retries,
task_retry_interval=task_retry_interval,
task_thread_pool_size=task_thread_pool_size,
install_plugins=install_plugins)
manager_ip = details['manager_ip']
provider_context = details['provider_context']
with utils.update_wd_settings() as ws_settings:
ws_settings.set_management_server(manager_ip)
ws_settings.set_management_key(details['manager_key_path'])
ws_settings.set_management_user(details['manager_user'])
ws_settings.set_provider_context(provider_context)
ws_settings.set_rest_port(details['rest_port'])
ws_settings.set_protocol(details['protocol'])
logger.info('bootstrapping complete')
logger.info('management server is up at {0}'.format(manager_ip))
except Exception as ex:
tpe, value, traceback = sys.exc_info()
logger.error('bootstrap failed! ({0})'.format(str(ex)))
if not keep_up:
try:
bs.load_env(env_name)
except IOError:
# the bootstrap exception occurred before environment was
# even initialized - nothing to teardown.
pass
else:
logger.info('executing teardown due to failed bootstrap')
bs.teardown(name=env_name,
task_retries=5,
task_retry_interval=30,
task_thread_pool_size=1)
raise tpe, value, traceback
