def deploy(target, output=True, ret=None, hooks=True, pre=True, post=True):
'''Prepare cloud controller configuration
can also apply per virtualization type configuration'''
__salt__['mc_cloud_compute_node.lazy_register_configuration'](target)
func_name = 'mc_compute_node.deploy {0}'.format(target)
__salt__['mc_api.time_log']('start {0}'.format(func_name))
if ret is None:
ret = result()
ret['comment'] += green('Installing compute node configuration\n')
if hooks and pre:
run_vt_hook('pre_deploy_compute_node',
ret=ret, target=target, output=output)
for step in [
register_configuration,
configure_prevt,
# merged in configure_prevt for perf reason
# configure_sshkeys,
# configure_grains,
install_vts,
configure_network,
configure_host,
# merged in configure_host for perf reason
# configure_hostsfile,
# configure_firewall,
# configure_sslcerts,
# configure_reverse_proxy
]:
step(target, ret=ret, output=False)
check_point(ret, __opts__, output=output)
if hooks and post:
run_vt_hook('post_deploy_compute_node',
ret=ret, target=target, output=output)
salt_output(ret, __opts__, output=output)
__salt__['mc_api.time_log']('end {0}'.format(func_name))
return ret
def vm_ping(vm, compute_node=None, vt=None, ret=None, output=True):
'''ping a specific vm on a specific compute node
compute_node
where to act
vm
vm to ping
::
mastersalt-run -lall mc_cloud_vm.vm_ping foo.domain.tld
'''
__salt__['mc_cloud_vm.lazy_register_configuration'](
vm, compute_node)
func_name = 'mc_cloud_vm.provision.ping {0}'.format(vm)
__salt__['mc_api.time_log']('start {0}'.format(func_name))
vt = __salt__['mc_cloud_vm.get_vt'](vm, vt)
compute_node = __salt__['mc_cloud_vm.get_compute_node'](vm, compute_node)
if ret is None:
ret = result()
try:
ping = cli('test.ping', salt_target=vm)
except Exception:
ret['trace'] += "{0}\n".format(traceback.format_exc())
ping = False
ret['result'] = ping
if ret['result']:
comment = green('VM {0} is pinguable\n')
else:
comment = red('VM {0} is unreachable\n')
ret['comment'] += comment.format(vm)
salt_output(ret, __opts__, output=output)
__salt__['mc_api.time_log']('end {0}'.format(func_name))
return ret
def provision(vm, compute_node=None, vt=None,
steps=None, ret=None, output=True):
'''provision a vm
compute_node
where to act
vt
virtual type
vm
vm to spawn
steps
list or comma separated list of steps
Default::
['spawn', 'hostsfile', 'sshkeys',
'grains', 'initial_setup', 'initial_highstate']
::
mastersalt-run -lall mc_cloud_vm.provision foo.domain.tld
'''
func_name = 'mc_cloud_vm.provision {0}'.format(vm)
__salt__['mc_api.time_log']('start {0}'.format(func_name))
vt = __salt__['mc_cloud_vm.get_vt'](vm, vt)
compute_node = __salt__['mc_cloud_vm.get_compute_node'](vm, compute_node)
vt = __salt__['mc_cloud_vm.get_vt'](vm, vt)
if isinstance(steps, basestring):
steps = steps.split(',')
if steps is None:
steps = ['register_configuration_on_cn',
'spawn',
'register_configuration',
'preprovision',
# 'sshkeys',
# 'hostsfile',
# 'grains',
# 'markers',
'initial_setup',
'initial_highstate']
if ret is None:
ret = result()
for step in steps:
cret = __salt__['mc_cloud_vm.step'](vm, step,
compute_node=compute_node,
vt=vt,
output=False)
merge_results(ret, cret)
if ret['result']:
ret['comment'] += green(
'{0}/{1}/{2} deployed\n').format(compute_node, vt, vm)
else:
ret['comment'] += red(
'{0}/{1}/{2} failed to deploy\n').format(compute_node, vt, vm)
salt_output(ret, __opts__, output=output)
__salt__['mc_api.time_log']('end {0}'.format(func_name))
return ret
def run_vt_hook(hook_name,
ret=None,
target=None,
vts=None,
output=True,
*args, **kwargs):
'''Run an hook for a special vt
on a controller, or a compute node or a vm'''
func_name = (
'mc_cloud_controller.run_vt_hook '
'{0} {1}').format(hook_name, target)
__salt__['mc_api.time_log']('start {0}'.format(func_name))
if target:
kwargs['target'] = target
if ret is None:
ret = result()
if not vts:
if not target:
settings = cli('mc_cloud_controller.settings')
vts = settings['vts']
else:
settings = cli('mc_cloud_compute_node.settings')
vts = settings['targets'][target]['virt_types']
if isinstance(vts, basestring):
vts = [vts]
for vt in vts:
vid_ = 'mc_cloud_{0}.{1}'.format(vt, hook_name)
if vid_ in __salt__:
ret['comment'] += (
green('\n --> ') + blue(vid_) + green(' hook\n')
)
kwargs['output'] = False
cret = __salt__[vid_](*args, **kwargs)
merge_results(ret, cret)
check_point(ret, __opts__, output=output)
__salt__['mc_api.time_log']('end {0}'.format(func_name))
return ret
def dns_conf(output=True, ret=None):
'''Prepare cloud controller dns (BIND) server'''
func_name = 'mc_cloud_controller.dns_conf'
__salt__['mc_api.time_log']('start {0}'.format(func_name))
if ret is None:
ret = result()
kw = {'ret': ret, 'output': output}
kw['ret']['comment'] += green(
'Installing cloud controller DNS configuration\n')
run_vt_hook('pre_dns_conf_on_controller', ret=kw['ret'], output=output)
__salt__['mc_api.apply_sls'](
['makina-states.cloud.generic.controller.dnsconf'], **kw)
check_point(kw['ret'], __opts__, output=output)
run_vt_hook('post_dns_conf_on_controller', ret=kw['ret'], output=output)
salt_output(kw['ret'], __opts__, output=output)
__salt__['mc_api.time_log']('end {0}'.format(func_name))
return kw['ret']
def deploy(output=True, ret=None):
'''Prepare cloud controller configuration
can also apply per virtualization type configuration'''
func_name = 'mc_cloud_controller.deploy'
__salt__['mc_api.time_log']('start {0}'.format(func_name))
if ret is None:
ret = result()
kw = {'ret': ret, 'output': output}
kw['ret']['comment'] += green(
'Installing cloud controller configuration files\n')
run_vt_hook('pre_deploy_controller', ret=kw['ret'], output=output)
__salt__['mc_api.apply_sls'](
['makina-states.cloud.generic.controller',
'makina-states.cloud.saltify'], **kw)
check_point(kw['ret'], __opts__, output=output)
run_vt_hook('post_deploy_controller', ret=kw['ret'], output=output)
salt_output(kw['ret'], __opts__, output=output)
__salt__['mc_api.time_log']('end {0}'.format(func_name))
return kw['ret']
def post_provision(vm, compute_node=None, vt=None, ret=None, output=True):
'''post provision a vm
compute_node
where to act
vt
virtual type
vm
vm to spawn
steps
list or comma separated list of steps
Default::
['ping', 'post_provision_hook']
::
mastersalt-run -lall mc_cloud_vm.post_provision foo.domain.tld
'''
func_name = 'mc_cloud_vm.post_provision {0}'.format(vm)
__salt__['mc_api.time_log']('start {0}'.format(func_name))
if ret is None:
ret = result()
vt = __salt__['mc_cloud_vm.get_vt'](vm, vt)
compute_node = __salt__['mc_cloud_vm.get_compute_node'](vm, compute_node)
for step in ['ping', 'post_provision_hook']:
cret = __salt__['mc_cloud_vm.step'](vm, step,
compute_node=compute_node,
vt=vt, output=False)
merge_results(ret, cret)
if ret['result']:
ret['comment'] += green(
'{0}/{1}/{2} deployed\n').format(compute_node, vt, vm)
else:
ret['comment'] += red(
'{0}/{1}/{2} failed to deploy\n').format(compute_node, vt, vm)
salt_output(ret, __opts__, output=output)
__salt__['mc_api.time_log']('end {0}'.format(func_name))
return ret
def saltify(name, output=True, ret=None):
'''Saltify a specific target'''
if not ret:
ret = result()
try:
already_exists = __salt__['mc_cloud_controller.exists'](name)
data = None
if already_exists:
success = green('{0} is already saltified'.format(name))
else:
try:
data = cli('mc_cloud_saltify.settings_for_target', name)
if not isinstance(data, dict):
raise SaltyficationError(red('{0}'.format(data)))
except KeyError:
data = None
if data is None:
raise SaltyficationError(
red('Saltify target {0} is not configured'.format(name)))
else:
success = green('{0} is saltified')
kwargs = {'minion': {'master': data['master'],
'master_port': data['master_port']}}
for var in [
"ssh_username", "ssh_keyfile", "keep_tmp", "gateway",
"sudo", "password", "script_args", "ssh_host",
"sudo_password",
]:
if data.get(var):
kwargs[var] = data[var]
try:
info = __salt__['cloud.profile'](
data['profile'],
[name],
vm_overrides=kwargs)
except Exception, exc:
trace = traceback.format_exc()
ret['trace'] = trace
raise FailedStepError(red('{0}'.format(exc)))
ret = process_cloud_return(
name, info, driver='saltify', ret=ret)
if ret['result']:
ret['comment'] = success
if not output:
ret['changes'] = {}
check_point(ret, __opts__)
# once saltified, also be sure that this host had
#a time to accomplish it's setup through a full initial
# highstate
if not cli('mc_cloud_compute_node.get_conf_for_target',
name, 'saltified'):
if data is None:
data = cli('mc_cloud_saltify.settings_for_target', name)
csettings = cli('mc_cloud.settings')
proxycmd = ''
if data.get('ssh_gateway', None):
args = '-oStrictHostKeyChecking=no -oUserKnownHostsFile=/dev/null'
args += '-oControlPath=none'
if 'ssh_key' in data:
args += ' -i {0}'.format(data['ssh_key'])
if 'ssh_port' in data:
args += ' -p {0}'.format(data['ssh_port'])
proxycmd = '-o\"ProxyCommand=ssh {1} {2} nc -w300 {1} 22\"'.format(
data['ssh_gateway'], name, args
)
cmd = (
'ssh {2} {0} {1}/makina-states/_scripts/boot-salt.sh '
'--initial-highstate'
).format(name, csettings['root'], proxycmd)
cmdret = cli('cmd.run_all', cmd)
if cmdret['retcode']:
ret['result'] = False
ret['trace'] += 'Using cmd: \'{0}\''.format(cmd)
ret['trace'] += '{0}\n'.format(cmdret['stdout'])
ret['trace'] += '{0}\n'.format(cmdret['stderr'])
ret['comment'] += red(
'SALTIFY: Error in highstate for {0}'.format(name))
check_point(ret, __opts__)
# ok, marking initial highstate done
cli('mc_cloud_compute_node.set_conf_for_target',
name, 'saltified', True)
saltified = ret['changes'].setdefault('saltified', [])
saltified_error = ret['changes'].setdefault('saltified_errors', [])
targets = [a for a in settings['targets']]
targets = filter_compute_nodes(targets, skip, only)
targets.sort()
for idx, compute_node in enumerate(targets):
try:
cret = saltify(compute_node, output=False)
if cret['result']:
saltified.append(compute_node)
else:
raise SaltyficationError(
'Target {0} failed to saltify:\n{1}'.format(
compute_node, cret['comment']))
except Exception, exc:
trace = traceback.format_exc()
comment += yellow(
'\nSaltyfication failed for {0}: {1}'.format(
compute_node, exc))
if not isinstance(exc, SaltyficationError):
ret['trace'] += '\n'.format(trace)
log.error(trace)
saltified_error.append(compute_node)
if not comment:
comment = green('All targets were successfuly saltified.')
ret['comment'] += '\n{0}'.format(comment)
salt_output(ret, __opts__, output=output)
return ret
#
ret['result'] = False
for k in ['trace', 'comment']:
if k in cret:
val = ret.setdefault(k, '')
val += cret[k]
if vm not in configuration_error:
configuration_error.append(vm)
cret.pop('result', False)
merge_results(ret, cret)
if len(configuration_error):
ret['comment'] += red('There were errors while configuring '
'vms nodes {0}\n'.format(configuration_error))
else:
if ret['result']:
ret['trace'] = ''
ret['comment'] += green('All vms were configured\n')
salt_output(ret, __opts__, output=output)
__salt__['mc_api.time_log']('end {0}'.format(func_name))
return ret
def provision_vms(compute_node,
skip=None, only=None, ret=None,
output=True, refresh=False):
'''Provision all or selected vms on a compute node
::
mastersalt-run -lall mc_cloud_vm.provision_vms host1.domain.tld
mastersalt-run -lall mc_cloud_vm.provision_vms host1.domain.tld only=['foo.domain.tld']
mastersalt-run -lall mc_cloud_vm.provision_vms host1.domain.tld skip=['foo2.domain.tld']
cret['output'] = ''
cret['trace'] = ''
else:
ret['result'] = False
if compute_node not in configuration_error:
configuration_error.append(compute_node)
cret.pop('result', False)
merge_results(ret, cret)
if len(configuration_error):
ret['comment'] += red('There were errors while configuring '
'computes nodes {0}\n'.format(
configuration_error))
else:
if ret['result']:
ret['trace'] = ''
ret['comment'] += green('All computes nodes were preconfigured\n')
# now for each reachable vm, also preconfigure it
for idx, compute_node in enumerate(hosts_to_configure_vms):
cret = result()
try:
__salt__['mc_cloud_vm.register_configurations'](
compute_node, skip=skip_vms, only=only_vms,
ret=cret, output=False)
check_point(cret, __opts__, output=output)
except FailedStepError:
cret['result'] = False
except Exception, exc:
trace = traceback.format_exc()
cret = {'result': False,
'output': (
'unknown error on '
