def ssh(ssh_plain_mode, ssh_command):
logger = get_logger()
ssh_path = spawn.find_executable('ssh')
logger.debug('SSH executable path: {0}'.format(ssh_path or 'Not found'))
if not ssh_path and platform.system() == 'Windows':
msg = messages.SSH_WIN_NOT_FOUND
raise CloudifyCliError(msg)
elif not ssh_path:
msg = messages.SSH_LINUX_NOT_FOUND
raise CloudifyCliError(msg)
else:
command = [
ssh_path, '{0}@{1}'.format(get_management_user(),
get_management_server_ip())
]
if get_global_verbosity():
command.append('-v')
if not ssh_plain_mode:
command.extend(['-i', os.path.expanduser(get_management_key())])
if ssh_command:
command.extend(['--', ssh_command])
logger.debug('executing command: {0}'.format(' '.join(command)))
logger.info('Trying to connect...')
from subprocess import call
call(command)
def provider_teardown(config_file_path, ignore_validation):
logger = get_logger()
provider_deprecation_notice()
management_ip = utils.get_management_server_ip()
provider_name, provider_context = \
_get_provider_name_and_context(management_ip)
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)
pm = provider.ProviderManager(provider_config, cli.get_global_verbosity())
logger.info("tearing down {0}".format(management_ip))
with utils.protected_provider_call():
pm.teardown(provider_context, ignore_validation)
def provider_teardown(config_file_path,
ignore_validation):
logger = get_logger()
provider_deprecation_notice()
management_ip = utils.get_management_server_ip()
provider_name, provider_context = \
_get_provider_name_and_context(management_ip)
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)
pm = provider.ProviderManager(provider_config, cli.get_global_verbosity())
logger.info("tearing down {0}".format(management_ip))
with utils.protected_provider_call():
pm.teardown(provider_context, ignore_validation)
def run_command_on_manager(command,
use_sudo=False,
open_shell=False,
host_string='',
force_output=False):
"""Runs an SSH command on a Manager.
`open_shell` opens an interactive shell to the server.
`host_string` can be explicitly provided to save on REST calls.
`force_output` forces all output as if running in verbose.
"""
host_string = host_string or utils.build_manager_host_string()
port = utils.get_management_port()
def execute():
key_filename = os.path.expanduser(utils.get_management_key())
with fab.settings(
host_string=host_string,
key_filename=key_filename,
port=port,
warn_only=True):
if use_sudo:
output = fab.sudo(command)
elif open_shell:
fab.open_shell(command)
return None
else:
output = fab.run(command)
if output.failed:
raise CloudifyCliError(
'Failed to execute: {0} ({1})'.format(
output.real_command, output.stderr))
return output
if get_global_verbosity() or force_output:
return execute()
else:
with fab.hide('running', 'stdout', 'stderr', 'warnings'):
return execute()
def run_command_on_manager(command, use_sudo=False):
def execute():
key_filename = os.path.expanduser(utils.get_management_key())
with fab.settings(
host_string=utils.build_manager_host_string(),
key_filename=key_filename,
warn_only=True):
if use_sudo:
result = fab.sudo(command)
else:
result = fab.run(command)
if result.failed:
raise CloudifyCliError(
'Failed to execute: {0} ({1})'.format(
result.read_command, result.stderr))
return result
if get_global_verbosity():
return execute()
else:
with fab.hide('running', 'stdout'):
return execute()
def _print_maintenance_mode_status(client):
logger = get_logger()
status_response = client.maintenance_mode.status()
logger.info('\nMaintenance Mode Status:')
for param_name, param_value in utils.decode_dict(
status_response).iteritems():
if param_value and param_name != 'remaining_executions':
logger.info('\t{0}:\t{1}'.format(
param_name.title().replace("_", " "),
param_value))
logger.info('')
remaining_executions = status_response.remaining_executions
if remaining_executions:
if len(remaining_executions) == 1:
logger.info(
'Cloudify Manager currently has one '
'running or pending execution. Waiting for it'
' to finish before activating.')
else:
logger.info(
'Cloudify Manager currently has {0} '
'running or pending executions. Waiting for all '
'executions to finish before activating.'.format(
len(remaining_executions)))
if get_global_verbosity() != NO_VERBOSE:
pt = utils.table(['id', 'deployment_id', 'workflow_id', 'status'],
remaining_executions)
pt.max_width = 50
utils.print_table('Remaining executions:', pt)
if status_response.status == MAINTENANCE_MODE_ACTIVE:
logger.info('INFO - Cloudify Manager is currently under maintenance. '
'Most requests will be blocked '
'until maintenance mode is deactivated.\n')
def ssh(ssh_plain_mode, ssh_command):
logger = get_logger()
ssh_path = spawn.find_executable('ssh')
logger.debug('SSH executable path: {0}'.format(ssh_path or 'Not found'))
if not ssh_path and platform.system() == 'Windows':
msg = messages.SSH_WIN_NOT_FOUND
raise CloudifyCliError(msg)
elif not ssh_path:
msg = messages.SSH_LINUX_NOT_FOUND
raise CloudifyCliError(msg)
else:
command = [ssh_path, '{0}@{1}'.format(get_management_user(),
get_management_server_ip())]
if get_global_verbosity():
command.append('-v')
if not ssh_plain_mode:
command.extend(['-i', os.path.expanduser(get_management_key())])
if ssh_command:
command.extend(['--', ssh_command])
logger.debug('executing command: {0}'.format(' '.join(command)))
logger.info('Trying to connect...')
from subprocess import call
call(command)
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 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()
