def use(management_ip, provider, rest_port):
logger = get_logger()
# first check this server is available.
client = utils.get_rest_client(manager_ip=management_ip,
rest_port=rest_port)
try:
status_result = client.manager.get_status()
except CloudifyClientError:
status_result = None
if not status_result:
msg = ("Can't use management server {0}: No response.".format(
management_ip))
raise CloudifyCliError(msg)
# check if cloudify was initialized.
if not utils.is_initialized():
utils.dump_cloudify_working_dir_settings()
utils.dump_configuration_file()
try:
response = utils.get_rest_client(management_ip).manager.get_context()
provider_name = response['name']
provider_context = response['context']
except CloudifyClientError:
provider_name = None
provider_context = None
with utils.update_wd_settings() as wd_settings:
wd_settings.set_management_server(management_ip)
wd_settings.set_provider_context(provider_context)
wd_settings.set_provider(provider_name)
wd_settings.set_rest_port(rest_port)
wd_settings.set_is_provider_config(provider)
logger.info('Using management server {0} with port {1}'.format(
management_ip, rest_port))
def use(management_ip, rest_port):
logger = get_logger()
# first check this server is available.
client = utils.get_rest_client(
manager_ip=management_ip, rest_port=rest_port)
try:
status_result = client.manager.get_status()
except CloudifyClientError:
status_result = None
if not status_result:
msg = ("Can't use management server {0}: No response."
.format(management_ip))
raise CloudifyCliError(msg)
# check if cloudify was initialized.
if not utils.is_initialized():
utils.dump_cloudify_working_dir_settings()
utils.dump_configuration_file()
try:
response = utils.get_rest_client(
management_ip).manager.get_context()
provider_context = response['context']
except CloudifyClientError:
provider_context = None
with utils.update_wd_settings() as wd_settings:
wd_settings.set_management_server(management_ip)
wd_settings.set_provider_context(provider_context)
wd_settings.set_rest_port(rest_port)
logger.info('Using management server {0} with port {1}'
.format(management_ip, rest_port))
# delete the previous manager deployment if exists.
bs.delete_workdir()
def _test(self, skip_generation=False, reset=False):
requests_path = self.workdir / 'requests.json'
port = self._start_server(requests_path)
self.claw.generate(tests.STUB_CONFIGURATION)
conf = configuration.Configuration(tests.STUB_CONFIGURATION)
with conf.dir:
sh.cfy.init()
with cli_utils.update_wd_settings() as wd_settings:
wd_settings.set_management_server('localhost')
wd_settings.set_rest_port(port)
blueprint_conf = conf.blueprint(tests.STUB_BLUEPRINT)
if skip_generation or reset:
self.claw('generate-blueprint', tests.STUB_CONFIGURATION,
tests.STUB_BLUEPRINT)
if skip_generation:
with blueprint_conf.patch.inputs as patch:
first_key = patch.obj.keys()[0]
patch.obj[first_key] = 'SOME_OTHER_VALUE'
# sanity
if reset:
with self.assertRaises(sh.ErrorReturnCode) as c:
self.claw.deploy(tests.STUB_CONFIGURATION,
tests.STUB_BLUEPRINT)
self.assertIn('Already initialized', c.exception.stderr)
self.claw.deploy(tests.STUB_CONFIGURATION,
tests.STUB_BLUEPRINT,
skip_generation=skip_generation,
reset=reset)
requests = json.loads(requests_path.text())
blueprint, deployment, execution = requests
self.assertEqual(blueprint, {'blueprint': [tests.STUB_BLUEPRINT]})
self.assertEqual(
deployment, {
'deployment': [
tests.STUB_BLUEPRINT, {
'blueprint_id': tests.STUB_BLUEPRINT,
'inputs': blueprint_conf.inputs
}
]
})
self.assertEqual(
execution, {
'execution': [{
'deployment_id': tests.STUB_BLUEPRINT,
'parameters': None,
'allow_custom_parameters': 'false',
'workflow_id': 'install',
'force': 'false'
}]
})
def teardown(force, ignore_deployments):
logger = get_logger()
management_ip = utils.get_management_server_ip()
if not force:
msg = ("This action requires additional "
"confirmation. Add the '-f' or '--force' "
"flags to your command if you are certain "
"this command should be executed.")
raise exceptions.CloudifyCliError(msg)
client = utils.get_rest_client(management_ip)
try:
if not ignore_deployments and len(client.deployments.list()) > 0:
msg = \
("Manager server {0} has existing deployments. Delete all "
"deployments first or add the '--ignore-deployments' flag to "
"your command to ignore these deployments and execute "
"teardown.".format(management_ip))
raise exceptions.CloudifyCliError(msg)
except IOError:
msg = \
"Failed querying manager server {0} about existing " \
"deployments; The Manager server may be down. If you wish to " \
'skip this check, you may use the "--ignore-deployments" flag, ' \
'in which case teardown will occur regardless of the Manager ' \
"server's status.".format(management_ip)
raise exceptions.CloudifyCliError(msg)
logger.info("tearing down {0}".format(management_ip))
# runtime properties might have changed since the last time we
# executed 'use', because of recovery. so we need to retrieve
# the provider context again
try:
logger.info('Retrieving provider context')
management_ip = utils.get_management_server_ip()
use(management_ip, utils.get_rest_port())
except BaseException as e:
logger.warning('Failed retrieving provider context: {0}. This '
'may cause a leaking management server '
'in case it has gone through a '
'recovery process'.format(str(e)))
# reload settings since the provider context maybe changed
settings = utils.load_cloudify_working_dir_settings()
provider_context = settings.get_provider_context()
bs.read_manager_deployment_dump_if_needed(
provider_context.get('cloudify', {}).get('manager_deployment'))
bs.teardown()
# cleaning relevant data from working directory settings
with utils.update_wd_settings() as wd_settings:
# wd_settings.set_provider_context(provider_context)
wd_settings.remove_management_server_context()
logger.info("teardown complete")
def test_teardown_no_management_ip_in_context_right_directory(
self, mock_load_env, mock_teardown): # NOQA
cli_runner.run_cli('cfy init')
with update_wd_settings() as wd:
wd.set_provider_context({})
cli_runner.run_cli('cfy teardown -f')
mock_teardown.assert_called_once_with()
mock_load_env.assert_called_once_with()
def test_teardown_no_management_ip_in_context_right_directory(
self, mock_load_env, mock_teardown): # NOQA
cli_runner.run_cli('cfy init')
with update_wd_settings() as wd:
wd.set_provider_context({})
cli_runner.run_cli('cfy teardown -f')
mock_teardown.assert_called_once_with()
mock_load_env.assert_called_once_with()
def _do_teardown():
# reload settings since the provider context maybe changed
settings = utils.load_cloudify_working_dir_settings()
provider_context = settings.get_provider_context()
bs.read_manager_deployment_dump_if_needed(provider_context.get("cloudify", {}).get("manager_deployment"))
bs.teardown()
# cleaning relevant data from working directory settings
with utils.update_wd_settings() as wd_settings:
# wd_settings.set_provider_context(provider_context)
wd_settings.remove_management_server_context()
def _do_teardown():
# reload settings since the provider context maybe changed
settings = utils.load_cloudify_working_dir_settings()
provider_context = settings.get_provider_context()
bs.read_manager_deployment_dump_if_needed(
provider_context.get('cloudify', {}).get('manager_deployment'))
bs.teardown()
# cleaning relevant data from working directory settings
with utils.update_wd_settings() as wd_settings:
# wd_settings.set_provider_context(provider_context)
wd_settings.remove_management_server_context()
def _test(self, skip_generation=False, reset=False):
requests_path = self.workdir / 'requests.json'
port = self._start_server(requests_path)
self.claw.generate(tests.STUB_CONFIGURATION)
conf = configuration.Configuration(tests.STUB_CONFIGURATION)
with conf.dir:
sh.cfy.init()
with cli_utils.update_wd_settings() as wd_settings:
wd_settings.set_management_server('localhost')
wd_settings.set_rest_port(port)
blueprint_conf = conf.blueprint(tests.STUB_BLUEPRINT)
if skip_generation or reset:
self.claw('generate-blueprint',
tests.STUB_CONFIGURATION,
tests.STUB_BLUEPRINT)
if skip_generation:
with blueprint_conf.patch.inputs as patch:
first_key = patch.obj.keys()[0]
patch.obj[first_key] = 'SOME_OTHER_VALUE'
# sanity
if reset:
with self.assertRaises(sh.ErrorReturnCode) as c:
self.claw.deploy(tests.STUB_CONFIGURATION,
tests.STUB_BLUEPRINT)
self.assertIn('Configuration already initialized',
c.exception.stderr)
self.claw.deploy(tests.STUB_CONFIGURATION, tests.STUB_BLUEPRINT,
skip_generation=skip_generation,
reset=reset)
requests = json.loads(requests_path.text())
blueprint, deployment, execution = requests
self.assertEqual(blueprint, {
'blueprint': [tests.STUB_BLUEPRINT]})
self.assertEqual(deployment, {
'deployment': [tests.STUB_BLUEPRINT, {
'blueprint_id': tests.STUB_BLUEPRINT,
'inputs': blueprint_conf.inputs}]})
self.assertEqual(execution, {
'execution': [{
'deployment_id': tests.STUB_BLUEPRINT,
'parameters': None,
'allow_custom_parameters': 'false',
'workflow_id': 'install',
'force': 'false'
}]})
def test_recover_from_same_directory_as_bootstrap(self, *_):
cli_runner.run_cli("cfy init")
# mock bootstrap behavior by setting the management key path
# in the local context
key_path = os.path.join(TEST_WORK_DIR, "key.pem")
open(key_path, "w").close()
with update_wd_settings() as wd:
wd.set_management_key(key_path)
wd.set_provider_context({})
# now run recovery and make sure no exception was raised
cli_runner.run_cli("cfy recover -f -s {0}".format(key_path))
def test_recover_from_same_directory_as_bootstrap_missing_key(self, *_):
cli_runner.run_cli("cfy init")
# mock bootstrap behavior by setting the management key path
# in the local context. however, don't actually create the key file
key_path = os.path.join(TEST_WORK_DIR, "key.pem")
with update_wd_settings() as wd:
wd.set_management_key(key_path)
wd.set_provider_context({})
# recovery command should not fail because the key file specified in
# the context file does not exist
self._assert_ex("cfy recover -f", "Cannot perform recovery. manager key " "file does not exist")
def test_recover_from_same_directory_as_bootstrap(self, *_):
cli_runner.run_cli('cfy init')
# mock bootstrap behavior by setting the management key path
# in the local context
key_path = os.path.join(TEST_WORK_DIR, 'key.pem')
open(key_path, 'w').close()
with update_wd_settings() as wd:
wd.set_management_key(key_path)
wd.set_provider_context({})
# now run recovery and make sure no exception was raised
cli_runner.run_cli('cfy recover -f -s {0}'.format(key_path))
def test_recover_from_different_directory_than_bootstrap_with_env_variable(self, *_): # NOQA
cli_runner.run_cli("cfy init")
key_path = os.path.join(TEST_WORK_DIR, "key.pem")
open(key_path, "w").close()
# mock provider context
with update_wd_settings() as wd:
wd.set_provider_context({})
try:
os.environ["CLOUDIFY_MANAGER_PRIVATE_KEY_PATH"] = key_path
cli_runner.run_cli("cfy recover -f -s {0}".format(key_path))
finally:
del os.environ["CLOUDIFY_MANAGER_PRIVATE_KEY_PATH"]
def test_recover_from_different_directory_than_bootstrap_with_env_variable(self, *_): # NOQA
cli_runner.run_cli('cfy init')
key_path = os.path.join(TEST_WORK_DIR, 'key.pem')
open(key_path, 'w').close()
# mock provider context
with update_wd_settings() as wd:
wd.set_provider_context({})
try:
os.environ['CLOUDIFY_MANAGER_PRIVATE_KEY_PATH'] = key_path
cli_runner.run_cli('cfy recover -f')
finally:
del os.environ['CLOUDIFY_MANAGER_PRIVATE_KEY_PATH']
def test_recover_from_same_directory_as_bootstrap_missing_key(self, *_):
cli_runner.run_cli('cfy init')
# mock bootstrap behavior by setting the management key path
# in the local context. however, don't actually create the key file
key_path = os.path.join(TEST_WORK_DIR, 'key.pem')
with update_wd_settings() as wd:
wd.set_management_key(key_path)
wd.set_provider_context({})
# recovery command should not fail because the key file specified in
# the context file does not exist
self._assert_ex('cfy recover -f',
'Cannot perform recovery. manager key '
'file does not exist')
def _update_manager_deployment(local_only=False):
# get the current provider from the runtime property set on bootstrap
provider_context = ctx.instance.runtime_properties[PROVIDER_RUNTIME_PROPERTY]
# construct new manager deployment
provider_context["cloudify"]["manager_deployment"] = _dump_manager_deployment()
# update locally
ctx.instance.runtime_properties[PROVIDER_RUNTIME_PROPERTY] = provider_context
with utils.update_wd_settings() as wd_settings:
wd_settings.set_provider_context(provider_context)
if not local_only:
# update on server
rest_client = utils.get_rest_client()
rest_client.manager.update_context("provider", provider_context)
def test_teardown_manager_down_ignore_deployments(self, mock_teardown):
def raise_client_error():
raise CloudifyClientError('this is an IOError')
self.client.deployments.list = raise_client_error
self.client.manager.get_context = MagicMock(
return_value={'name': 'mock_provider', 'context': {'key': 'value'}}
)
cli_runner.run_cli('cfy init')
with update_wd_settings() as wd:
wd.set_management_server('10.0.0.1')
wd.set_provider_context({})
cli_runner.run_cli('cfy teardown -f --ignore-deployments')
mock_teardown.assert_called_once_with()
def use(management_ip, rest_port):
logger = get_logger()
# check if cloudify was initialized.
if not utils.is_initialized():
utils.dump_cloudify_working_dir_settings()
utils.dump_configuration_file()
# determine SSL mode by port
if rest_port == constants.SECURED_REST_PORT:
protocol = constants.SECURED_PROTOCOL
else:
protocol = constants.DEFAULT_PROTOCOL
client = utils.get_rest_client(
rest_host=management_ip, rest_port=rest_port, rest_protocol=protocol,
skip_version_check=True)
try:
# first check this server is available.
client.manager.get_status()
except UserUnauthorizedError:
msg = "Can't use manager {0}: User is unauthorized.".format(
management_ip)
raise CloudifyCliError(msg)
except CloudifyClientError as e:
msg = "Can't use manager {0}: {1}".format(management_ip, str(e))
raise CloudifyCliError(msg)
try:
response = client.manager.get_context()
provider_context = response['context']
except CloudifyClientError:
provider_context = None
with utils.update_wd_settings() as wd_settings:
wd_settings.set_management_server(management_ip)
wd_settings.set_provider_context(provider_context)
wd_settings.set_rest_port(rest_port)
wd_settings.set_rest_protocol(protocol)
logger.info('Using management server {0} with port {1}'
.format(management_ip, rest_port))
# delete the previous manager deployment if exists.
bs.delete_workdir()
def use(management_ip, rest_port):
logger = get_logger()
# determine SSL mode by port
if rest_port == constants.SECURED_REST_PORT:
protocol = constants.SECURED_PROTOCOL
else:
protocol = constants.DEFAULT_PROTOCOL
client = utils.get_rest_client(manager_ip=management_ip,
rest_port=rest_port,
protocol=protocol)
try:
# first check this server is available.
client.manager.get_status()
except UserUnauthorizedError:
msg = "Can't use management server {0}: User is unauthorized.".format(
management_ip)
raise CloudifyCliError(msg)
except CloudifyClientError:
msg = "Can't use management server {0}: No response.".format(
management_ip)
raise CloudifyCliError(msg)
# check if cloudify was initialized.
if not utils.is_initialized():
utils.dump_cloudify_working_dir_settings()
utils.dump_configuration_file()
try:
response = client.manager.get_context()
provider_context = response['context']
except CloudifyClientError:
provider_context = None
with utils.update_wd_settings() as wd_settings:
wd_settings.set_management_server(management_ip)
wd_settings.set_provider_context(provider_context)
wd_settings.set_rest_port(rest_port)
wd_settings.set_protocol(protocol)
logger.info('Using management server {0} with port {1}'.format(
management_ip, rest_port))
# delete the previous manager deployment if exists.
bs.delete_workdir()
def test_teardown_manager_down_ignore_deployments(self, mock_teardown):
def raise_client_error():
raise CloudifyClientError('this is an IOError')
self.client.deployments.list = raise_client_error
self.client.manager.get_context = MagicMock(return_value={
'name': 'mock_provider',
'context': {
'key': 'value'
}
})
cli_runner.run_cli('cfy init')
with update_wd_settings() as wd:
wd.set_management_server('10.0.0.1')
wd.set_provider_context({})
cli_runner.run_cli('cfy teardown -f --ignore-deployments')
mock_teardown.assert_called_once_with()
def _update_manager_deployment(local_only=False, agent_remote_key_path=None):
# get the current provider from the runtime property set on bootstrap
provider_context = ctx.instance.runtime_properties[
PROVIDER_RUNTIME_PROPERTY]
# construct new manager deployment
provider_context['cloudify'][
'manager_deployment'] = _dump_manager_deployment()
# update locally
ctx.instance.runtime_properties[
PROVIDER_RUNTIME_PROPERTY] = provider_context
with utils.update_wd_settings() as wd_settings:
wd_settings.set_provider_context(provider_context)
if not local_only:
# update on server
_upload_provider_context(
remote_agents_private_key_path=agent_remote_key_path,
provider_context=provider_context, update_context=True)
def _update_manager_deployment(local_only=False, agent_remote_key_path=None):
# get the current provider from the runtime property set on bootstrap
provider_context = ctx.instance.runtime_properties[
PROVIDER_RUNTIME_PROPERTY]
# construct new manager deployment
provider_context['cloudify'][
'manager_deployment'] = _dump_manager_deployment()
# update locally
ctx.instance.runtime_properties[
PROVIDER_RUNTIME_PROPERTY] = provider_context
with utils.update_wd_settings() as wd_settings:
wd_settings.set_provider_context(provider_context)
if not local_only:
# update on server
_upload_provider_context(
remote_agents_private_key_path=agent_remote_key_path,
provider_context=provider_context, update_context=True)
def teardown(force, ignore_deployments, config_file_path, ignore_validation):
logger = get_logger()
management_ip = utils.get_management_server_ip()
if not force:
msg = ("This action requires additional "
"confirmation. Add the '-f' or '--force' "
"flags to your command if you are certain "
"this command should be executed.")
raise exceptions.CloudifyCliError(msg)
client = utils.get_rest_client(management_ip)
if not ignore_deployments and len(client.deployments.list()) > 0:
msg = ("Management server {0} has active deployments. Add the "
"'--ignore-deployments' flag to your command to ignore "
"these deployments and execute topology teardown."
.format(management_ip))
raise exceptions.CloudifyCliError(msg)
settings = utils.load_cloudify_working_dir_settings()
if settings.get_is_provider_config():
provider_common.provider_teardown(config_file_path, ignore_validation)
else:
logger.info("tearing down {0}".format(management_ip))
provider_context = settings.get_provider_context()
bs.read_manager_deployment_dump_if_needed(
provider_context.get('cloudify', {}).get('manager_deployment'))
bs.teardown(name='manager',
task_retries=0,
task_retry_interval=0,
task_thread_pool_size=1)
# cleaning relevant data from working directory settings
with utils.update_wd_settings() as wd_settings:
# wd_settings.set_provider_context(provider_context)
wd_settings.remove_management_server_context()
logger.info("teardown complete")
def teardown(force, ignore_deployments, config_file_path, ignore_validation):
logger = get_logger()
management_ip = utils.get_management_server_ip()
if not force:
msg = ("This action requires additional "
"confirmation. Add the '-f' or '--force' "
"flags to your command if you are certain "
"this command should be executed.")
raise exceptions.CloudifyCliError(msg)
client = utils.get_rest_client(management_ip)
if not ignore_deployments and len(client.deployments.list()) > 0:
msg = ("Management server {0} has active deployments. Add the "
"'--ignore-deployments' flag to your command to ignore "
"these deployments and execute topology teardown.".format(
management_ip))
raise exceptions.CloudifyCliError(msg)
settings = utils.load_cloudify_working_dir_settings()
if settings.get_is_provider_config():
provider_common.provider_teardown(config_file_path, ignore_validation)
else:
logger.info("tearing down {0}".format(management_ip))
provider_context = settings.get_provider_context()
bs.read_manager_deployment_dump_if_needed(
provider_context.get('cloudify', {}).get('manager_deployment'))
bs.teardown(name='manager',
task_retries=0,
task_retry_interval=0,
task_thread_pool_size=1)
# cleaning relevant data from working directory settings
with utils.update_wd_settings() as wd_settings:
# wd_settings.set_provider_context(provider_context)
wd_settings.remove_management_server_context()
logger.info("teardown complete")
import sys
from cloudify_cli import utils
from cloudify_cli.bootstrap import bootstrap as bs
from cloudify_cli.bootstrap import tasks as bstasks
with utils.update_wd_settings() as settings:
settings.set_management_key(sys.argv[1])
print 'Manager key set to path: ' + sys.argv[1]
provider_context = settings.get_provider_context()
bs.read_manager_deployment_dump_if_needed(
provider_context.get('cloudify', {}).get('manager_deployment')
)
env = bs.load_env('manager')
storage = env.storage
for instance in storage.get_node_instances():
manager_user = instance.runtime_properties.get(
bstasks.MANAGER_USER_RUNTIME_PROPERTY
)
if manager_user:
settings.set_management_user(manager_user)
print 'Manager user set to: ' + manager_user
break
import sys
from cloudify_cli import utils
from cloudify_cli.bootstrap import bootstrap as bs
from cloudify_cli.bootstrap import tasks as bstasks
with utils.update_wd_settings() as settings:
settings.set_management_key(sys.argv[1])
print 'Manager key set to path: ' + sys.argv[1]
provider_context = settings.get_provider_context()
bs.read_manager_deployment_dump_if_needed(
provider_context.get('cloudify', {}).get('manager_deployment'))
env = bs.load_env('manager')
storage = env.storage
for instance in storage.get_node_instances():
manager_user = instance.runtime_properties.get(
bstasks.MANAGER_USER_RUNTIME_PROPERTY)
if manager_user:
settings.set_management_user(manager_user)
print 'Manager user set to: ' + manager_user
break
def _set_management_creds(self, user, key):
with self.workdir, update_wd_settings() as ws_settings:
ws_settings.set_management_user(user)
ws_settings.set_management_key(key)
def provider_bootstrap(config_file_path,
keep_up,
validate_only, skip_validations):
logger = get_logger()
provider_deprecation_notice()
provider_name = utils.get_provider()
provider = utils.get_provider_module(provider_name)
try:
provider_dir = provider.__path__[0]
except:
provider_dir = os.path.dirname(provider.__file__)
provider_config = utils.read_config(config_file_path,
provider_dir)
logger.info("Prefix for all resources: '{0}'"
.format(provider_config.resources_prefix))
pm = provider.ProviderManager(provider_config, cli.get_global_verbosity())
pm.keep_up_on_failure = keep_up
if skip_validations and validate_only:
raise exceptions.CloudifyCliError(
'Please choose one of skip-validations or '
'validate-only flags, not both.')
logger.info('Bootstrapping using {0}'.format(provider_name))
if skip_validations:
pm.update_names_in_config() # Prefixes
else:
logger.info('Validating provider resources and configuration')
pm.augment_schema_with_common()
if pm.validate_schema():
raise exceptions.CloudifyValidationError('Provider schema '
'validations failed!')
pm.update_names_in_config() # Prefixes
if pm.validate():
raise exceptions.CloudifyValidationError(
'Provider validations failed!')
logger.info('Provider validations completed successfully')
if validate_only:
return
with utils.protected_provider_call():
logger.info('Provisioning resources for management server...')
params = pm.provision()
installed = False
provider_context = {}
def keep_up_or_teardown():
if keep_up:
logger.info('topology will remain up')
else:
logger.info('tearing down topology'
' due to bootstrap failure')
pm.teardown(provider_context)
if params:
mgmt_ip, private_ip, ssh_key, ssh_user, provider_context = params
logger.info('provisioning complete')
logger.info('ensuring connectivity with the management server...')
if pm.ensure_connectivity_with_management_server(
mgmt_ip, ssh_key, ssh_user):
logger.info('connected with the management server successfully')
logger.info('bootstrapping the management server...')
try:
installed = pm.bootstrap(mgmt_ip, private_ip, ssh_key,
ssh_user)
except BaseException:
logger.error('bootstrapping failed!')
keep_up_or_teardown()
raise
logger.info('bootstrapping complete') if installed else \
logger.error('bootstrapping failed!')
else:
logger.error('failed connecting to the management server!')
else:
logger.error('provisioning failed!')
if installed:
_update_provider_context(provider_config,
provider_context)
mgmt_ip = mgmt_ip.encode('utf-8')
with utils.update_wd_settings() as wd_settings:
wd_settings.set_management_server(mgmt_ip)
wd_settings.set_management_key(ssh_key)
wd_settings.set_management_user(ssh_user)
wd_settings.set_provider_context(provider_context)
# storing provider context on management server
utils.get_rest_client(mgmt_ip).manager.create_context(provider_name,
provider_context)
logger.info('management server is up at {0} '
'(is now set as the default management server)'
.format(mgmt_ip))
else:
keep_up_or_teardown()
raise exceptions.CloudifyBootstrapError()
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 provider_bootstrap(config_file_path, keep_up, validate_only,
skip_validations):
logger = get_logger()
provider_deprecation_notice()
provider_name = utils.get_provider()
provider = utils.get_provider_module(provider_name)
try:
provider_dir = provider.__path__[0]
except:
provider_dir = os.path.dirname(provider.__file__)
provider_config = utils.read_config(config_file_path, provider_dir)
logger.info("Prefix for all resources: '{0}'".format(
provider_config.resources_prefix))
pm = provider.ProviderManager(provider_config, cli.get_global_verbosity())
pm.keep_up_on_failure = keep_up
if skip_validations and validate_only:
raise exceptions.CloudifyCliError(
'Please choose one of skip-validations or '
'validate-only flags, not both.')
logger.info('Bootstrapping using {0}'.format(provider_name))
if skip_validations:
pm.update_names_in_config() # Prefixes
else:
logger.info('Validating provider resources and configuration')
pm.augment_schema_with_common()
if pm.validate_schema():
raise exceptions.CloudifyValidationError('Provider schema '
'validations failed!')
pm.update_names_in_config() # Prefixes
if pm.validate():
raise exceptions.CloudifyValidationError(
'Provider validations failed!')
logger.info('Provider validations completed successfully')
if validate_only:
return
with utils.protected_provider_call():
logger.info('Provisioning resources for management server...')
params = pm.provision()
installed = False
provider_context = {}
def keep_up_or_teardown():
if keep_up:
logger.info('topology will remain up')
else:
logger.info('tearing down topology' ' due to bootstrap failure')
pm.teardown(provider_context)
if params:
mgmt_ip, private_ip, ssh_key, ssh_user, provider_context = params
logger.info('provisioning complete')
logger.info('ensuring connectivity with the management server...')
if pm.ensure_connectivity_with_management_server(
mgmt_ip, ssh_key, ssh_user):
logger.info('connected with the management server successfully')
logger.info('bootstrapping the management server...')
try:
installed = pm.bootstrap(mgmt_ip, private_ip, ssh_key,
ssh_user)
except BaseException:
logger.error('bootstrapping failed!')
keep_up_or_teardown()
raise
logger.info('bootstrapping complete') if installed else \
logger.error('bootstrapping failed!')
else:
logger.error('failed connecting to the management server!')
else:
logger.error('provisioning failed!')
if installed:
_update_provider_context(provider_config, provider_context)
mgmt_ip = mgmt_ip.encode('utf-8')
with utils.update_wd_settings() as wd_settings:
wd_settings.set_management_server(mgmt_ip)
wd_settings.set_management_key(ssh_key)
wd_settings.set_management_user(ssh_user)
wd_settings.set_provider_context(provider_context)
# storing provider context on management server
utils.get_rest_client(mgmt_ip).manager.create_context(
provider_name, provider_context)
logger.info(
'management server is up at {0} '
'(is now set as the default management server)'.format(mgmt_ip))
else:
keep_up_or_teardown()
raise exceptions.CloudifyBootstrapError()
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
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 bootstrap(config_file_path, keep_up, validate_only, skip_validations,
blueprint_path, inputs, install_plugins, task_retries,
task_retry_interval, task_thread_pool_size):
logger = get_logger()
settings = utils.load_cloudify_working_dir_settings()
if settings.get_is_provider_config():
if blueprint_path or inputs:
raise ValueError(
'the "blueprint_path" and "inputs" parameters '
'are not to be used with the deprecated provider API')
return provider_common.provider_bootstrap(config_file_path, keep_up,
validate_only,
skip_validations)
env_name = 'manager'
# 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)
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_name = details['provider_name']
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(provider_name)
ws_settings.set_provider_context(provider_context)
logger.info('bootstrapping complete')
logger.info('management server is up at {0}'.format(manager_ip))
except Exception:
tpe, value, traceback = sys.exc_info()
logger.error('bootstrap failed!')
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
