Exemplo n.º 1
0
def cn_sls_pillar(target, ttl=api.RUNNER_CACHE_TIME, output=False):
    '''limited cloud pillar to expose to a compute node'''
    func_name = 'mc_cloud_lxc.cn_sls_pillar {0}'.format(target)
    __salt__['mc_api.time_log']('start {0}'.format(func_name))
    def _do(target):
        pillar = {}
        imgSettings = cli('mc_cloud_images.settings')
        lxcSettings = cli('mc_cloud_lxc.settings')
        imgSettingsData = {}
        lxcSettingsData = {}
        for name, imageData in imgSettings['lxc']['images'].items():
            imgSettingsData[name] = {
                'lxc_tarball': imageData['lxc_tarball'],
                'lxc_tarball_md5': imageData['lxc_tarball_md5'],
                'lxc_tarball_name': imageData['lxc_tarball_name'],
                'lxc_tarball_ver': imageData['lxc_tarball_ver']}
        for v in ['use_bridge', 'bridge',
                  'gateway', 'netmask_full',
                  'network', 'netmask']:
            lxcSettingsData[v] = lxcSettings['defaults'][v]
        # imgSettingsData = api.json_dump(imgSettingsData)
        # lxcSettingsData = api.json_dump(lxcSettingsData)
        pillar.update({'lxcSettings': lxcSettingsData,
                       'imgSettings': imgSettingsData})
        return pillar
    cache_key = 'mc_cloud_lxc.cn_sls_pillar_{0}'.format(target)
    ret = memoize_cache(_do, [target], {}, cache_key, ttl)
    cret = result()
    cret['result'] = ret
    salt_output(cret, __opts__, output=output)
    __salt__['mc_api.time_log']('end {0}'.format(func_name))
    return ret
Exemplo n.º 2
0
def vm_settings_for(vm, ttl=60):
    '''
    VM cloud related settings
    THIS IS USED ON THE COMPUTE NODE SIDE !
    '''
    def _do(vm):
        return vm_settings('_' + vm)
    cache_key = ('mc_cloud_vm.vm_settings_for'
                 '{0}').format(vm)
    return memoize_cache(_do, [vm], {}, cache_key, ttl)
Exemplo n.º 3
0
def vm_sls_pillar(compute_node, vm, ttl=api.RUNNER_CACHE_TIME):
    '''limited cloud pillar to expose to a vm
    This will be stored locally inside a local registry

    compute_node
        compute node to gather pillar from
    vm
        vm to gather pillar from
    '''
    func_name = 'mc_cloud_vm.vm_sls_pillar {0} {1}'.format(
        compute_node, vm)
    __salt__['mc_api.time_log']('start {0}'.format(func_name))

    def _do(compute_node, vm):
        compute_node = __salt__['mc_cloud_vm.get_compute_node'](vm, compute_node)
        cloudSettings = cli('mc_cloud.settings')
        cloudSettingsData = {}
        vmSettingsData = {}
        cnSettingsData = {}
        cloudSettingsData['all_sls_dir'] = cloudSettings['all_sls_dir']
        cloudSettingsData[
            'compute_node_sls_dir'] = cloudSettings['compute_node_sls_dir']
        cloudSettingsData['root'] = cloudSettings['root']
        cloudSettingsData['prefix'] = cloudSettings['prefix']
        cnsettings = cli('mc_cloud_compute_node.settings')
        targets = cnsettings.get('targets', {})
        cnSettingsData['virt_types'] = targets.get(
            compute_node, {}).get('virt_types', [])
        vmSettingsData['vm_name'] = vm
        vt = targets.get(compute_node, {}).get('vms', {}).get(vm, None)
        vmSettingsData['vm_vt'] = vt
        # vmSettingsData = api.json_dump(vmSettingsData)
        # cloudSettingsData = api.json_dump(cloudSettingsData)
        # cnSettingsData = api.json_dump(cnSettingsData)
        pillar = {'cloudSettings': cloudSettingsData,
                  'mccloud_vmname': vm,
                  'mccloud_vm_ssh_port': cli(
                      'mc_cloud_compute_node.get_ssh_port',
                      vm, target=compute_node),
                  'mccloud_targetname': compute_node,
                  'vmSettings': vmSettingsData,
                  'isdevhost': cli('mc_nodetypes.registry')['is']['devhost'],
                  'cnSettings': cnSettingsData}
        if vt in ['lxc']:
            vtVmData = cli(
                'mc_cloud_{0}.get_settings_for_vm'.format(vt),
                compute_node, vm, full=False)
            pillar['vtVmData'] = vtVmData
        return pillar
    cache_key = 'mc_cloud_vm.vm_sls_pillar_{0}_{1}'.format(
        compute_node, vm)
    ret = memoize_cache(_do, [compute_node, vm], {}, cache_key, ttl)
    __salt__['mc_api.time_log']('end {0}'.format(func_name))
    return ret
Exemplo n.º 4
0
def cli(*args, **kwargs):
    '''Correctly forward salt globals to a regular
    python module
    '''
    def _do(args, kwargs):
        if not kwargs:
            kwargs = {}
        kwargs.update({
            'salt_cfgdir': __opts__.get('config_dir', None),
            'salt_cfg': __opts__.get('conf_file', None),
            'salt___opts__': __opts__,
        })
        return client(*args, **kwargs)
    fun_ = args[0]

    defaults_ttls = {}
    #    'mc_cloud_compute_node.target_for_vm': 60,
    #    'mc_cloud_compute_node.vt_for_vm': 60,
    #    'mc_cloud_compute_node.get_reverse_proxies_for_target': 60,
    #    'mc_cloud_compute_node.get_settings_for_target': 60,
    #    'mc_cloud_saltify.settings_for_target': 60,
    #}
    ttl = kwargs.pop('cache_ttl',
                     defaults_ttls.get(fun_,
                                       api.RUNNER_CACHE_TIME))
    cache_key = ''
    if (
        fun_ in [
            'mc_cloud_compute_node.target_for_vm',
            'mc_cloud_compute_node.vt_for_vm',
            'mc_cloud_compute_node.get_reverse_proxies_for_target',
            'mc_cloud_compute_node.get_settings_for_target',
            'mc_cloud_saltify.settings_for_target',
        ]
    ) or (
        fun_.endswith('.get_settings_for_vm')
    ):
        cache_key = ' '.join(['{0}'.format(a) for a in args])
    if (
        fun_ in [
            'mc_nodetypes.registry'
        ]
    ) or (
        fun_.endswith('.settings')
        and len(args) == 1
        and not kwargs
    ):
            cache_key = fun_
    if cache_key:
        __salt__['mc_api.time_log'](cache_key, categ='CLOUD_CACHE')
        return memoize_cache(_do, [args, kwargs], {}, cache_key, ttl)
    else:
        return _do(args, kwargs)
Exemplo n.º 5
0
def cn_settings(ttl=60):
    '''
    compute node related settings
    THIS IS USED ON THE COMPUTE NODE SIDE !
    '''
    def _do():
        reg = __salt__['mc_macros.get_local_registry'](
            'cloud_compute_node_settings',
            registry_format='pack')
        if 'cnSettings' not in reg:
            raise ValueError(
                'Registry not yet configured')
        return reg
    cache_key = 'mc_cloud_compute_node.cn_settings'
    return memoize_cache(_do, [], {}, cache_key, ttl)
Exemplo n.º 6
0
def lazy_register_configuration(cn, ttl=5*60, *args, **kwargs):
    '''
    Wrapper to register_configuration at the exception
    that only one shared call can de done in a five minutes row.

    This can be used as a decorator in orchestrations functions
    to ensure configuration has been dropped on target tenants.
    '''
    cache_key = ('mc_cloud_compute_node.lazy_'
                 'register_configuration_{0}').format(cn)

    def _do(cn, *args, **kwargs):
        return __salt__['mc_cloud_compute_node.register_configuration'](
            cn, *args, **kwargs)
    ret = memoize_cache(_do, [cn] + list(args), kwargs, cache_key, ttl)
    return ret
Exemplo n.º 7
0
def vm_settings(suf='', ttl=60):
    '''
    VM cloud related settings
    THIS IS USED ON THE VM SIDE !
    '''
    def _do(suf):
        reg = __salt__['mc_macros.get_local_registry'](
            'cloud_vm_settings{0}'.format(suf),
            registry_format='pack')
        if 'vmSettings' not in reg:
            raise ValueError(
                'Registry not yet configured {0}'.format(
                    suf))
        return reg
    cache_key = 'mc_cloud_vm.vm_settings{0}'.format(suf)
    return memoize_cache(_do, [suf], {}, cache_key, ttl)
Exemplo n.º 8
0
def lazy_register_configuration(vm, *args, **kwargs):
    '''
    Wrapper to register_configuration at the exception
    that only one shared call can de done in a five minutes row.

    This can be used as a decorator in orchestrations functions
    to ensure configuration has been dropped on target tenants
    and is enoughtly up to date.
    '''
    ttl = kwargs.get('ttl', 5 * 60)
    salt_target = kwargs.get('salt_target', '')
    cache_key = 'mc_cloud_vm.lazy_register_configuration_{0}_{1}'.format(
        vm, salt_target)

    def _do(vm, *args, **kwargs):
        return __salt__['mc_cloud_vm.register_configuration'](
            vm, *args, **kwargs)
    ret = memoize_cache(_do, [vm] + list(args), kwargs, cache_key, ttl)
    return ret
Exemplo n.º 9
0
def cn_sls_pillar(target, ttl=api.RUNNER_CACHE_TIME):
    '''limited cloud pillar to expose to a compute node
    This will be stored locally inside a local registry'''
    func_name = 'mc_cloud_compute_node.cn_sls_pillar {0}'.format(
        target)
    __salt__['mc_api.time_log']('end {0}'.format(func_name))

    def _do(target):
        cloudSettings = cli('mc_cloud.settings')
        cloudSettingsData = {}
        cnSettingsData = {}
        cnSettingsData['cn'] = cli(
            'mc_cloud_compute_node.get_settings_for_target', target)
        vt_data = cnSettingsData['cn'].get('virt_types', {})
        vts = []
        for vt, enabled in vt_data.items():
            if enabled:
                vts.append(vt)
        cnSettingsData['rp'] = cli(
            'mc_cloud_compute_node.get_reverse_proxies_for_target', target)
        cloudSettingsData['all_sls_dir'] = cloudSettings['all_sls_dir']
        cloudSettingsData[
            'compute_node_sls_dir'] = cloudSettings['compute_node_sls_dir']
        cloudSettingsData['prefix'] = cloudSettings['prefix']
        cloudSettingsData = cloudSettingsData
        cnSettingsData = cnSettingsData
        pillar = {'cloudSettings': cloudSettingsData,
                  'cnSettings': cnSettingsData}
        # add to the compute node pillar all the VT specific pillars
        for vt in vts:
            cid = 'mc_cloud_{0}.cn_sls_pillar'.format(vt)
            if cid in __salt__:
                pillar.update(__salt__[cid](target))
        # add to the compute node pillar all the VM pillars
        return pillar
    cache_key = 'mc_cloud_compute_node.cn_sls_pillar_{0}'.format(target)
    ret = memoize_cache(_do, [target], {}, cache_key, ttl)
    __salt__['mc_api.time_log']('end {0}'.format(func_name))
    return ret