def get_vms_per_type(target):
    '''Return all vms indexed by virt_type for a special target'''
    all_targets = OrderedDict()
    for virt_type in VIRT_TYPES:
        per_type = all_targets.setdefault(virt_type, set())
        all_infos = get_targets_and_vms_for_virt_type(virt_type)
        for vmname in all_infos.get(target, []):
            per_type.add(vmname)
    for i in [a for a in all_targets]:
        all_targets[i] = [a for a in all_targets[i]]
    return all_targets
 def _doext_pillar(id_, prefixed, limited):
     _s = __salt__
     if not _s['mc_cloud.is_a_compute_node'](id_):
         return {}
     data = extpillar_settings(id_, limited=limited)
     # can only be done after some infos is loaded -- part2
     data['reverse_proxies']['target'] = data['target'] = id_
     data = feed_http_reverse_proxy_for_target(data)
     data = feed_sw_reverse_proxies_for_target(data)
     data = feed_network_mappings_for_target(data)
     haproxy_opts = OrderedDict()
     http_proxy = data['reverse_proxies']['http_proxy']
     https_proxy = data['reverse_proxies']['https_proxy']
     for typ, proxies in (('http', http_proxy), ('https', https_proxy)):
         spref = "{0}.mc_cloud_{1}".format(mc_haproxy.registration_prefix,
                                           typ)
         for name, bdatadict in six.iteritems(proxies):
             haproxy_opts.setdefault(spref, []).append(bdatadict)
     if prefixed:
         data = {PREFIX: data}
     data.update(haproxy_opts)
     return data
def get_vms_per_type(target):
    '''
    Return all vms indexed by vt for a special target
    '''
    all_targets = OrderedDict()
    for vt in VIRT_TYPES:
        per_type = all_targets.setdefault(vt, set())
        all_infos = get_targets_and_vms_for_vt(vt)
        for vmname in all_infos.get(target, {}).get('vms', []):
            per_type.add(vmname)
    for i in [a for a in all_targets]:
        all_targets[i] = [a for a in all_targets[i]]
    return all_targets
    def element(self, root=None, abspath=None, **kwargs):
        '''
        kwargs contain extra information for custom methods.

        This method must return a valid empty object if no vars are passed
        to allow introspection to create patterns.

        :param root:
        :param abspath:
        '''
        if root is None and abspath is None:
            root = os.path.abspath('.')
            abspath = os.path.abspath('.')
        relpath = os.path.relpath(abspath, root)

        try:
            element = self._elements.get(relpath, OrderedDict())
        except AttributeError:
            element = OrderedDict()

        if not element:
            for field in PATHINFO_FIELDS:
                element.setdefault(field, '')
            element['saltenv'] = kwargs.get('saltenv', 'base')
            element['relpath'] = relpath
            element['abspath'] = abspath
            element['is_pillar'] = kwargs.get('is_pillar', False)

        cachedir = kwargs.get('cachedir', '')
        if cachedir and os.path.commonprefix([abspath, cachedir]) == cachedir:
            element['cache_root'] = root
        else:
            element['file_root'] = root

        element_hook = kwargs.get('_element_hook', None)
        if element_hook:
            element = element_hook(self, element, **kwargs)

        return element
    def element(self, root=None, abspath=None, **kwargs):
        '''
        kwargs contain extra information for custom methods.

        This method must return a valid empty object if no vars are passed
        to allow introspection to create patterns.

        :param root:
        :param abspath:
        '''
        if root is None and abspath is None:
            root = os.path.abspath('.')
            abspath = os.path.abspath('.')
        relpath = os.path.relpath(abspath, root)

        try:
            element = self._elements.get(relpath, OrderedDict())
        except AttributeError:
            element = OrderedDict()

        if not element:
            for field in PATHINFO_FIELDS:
                element.setdefault(field, '')
            element['saltenv'] = kwargs.get('saltenv', 'base')
            element['relpath'] = relpath
            element['abspath'] = abspath
            element['is_pillar'] = kwargs.get('is_pillar', False)

        cachedir = kwargs.get('cachedir', '')
        if cachedir and os.path.commonprefix([abspath, cachedir]) == cachedir:
            element['cache_root'] = root
        else:
            element['file_root'] = root

        element_hook = kwargs.get('_element_hook', None)
        if element_hook:
            element = element_hook(self, element, **kwargs)

        return element
Beispiel #6
0
def _cache_entry(local_reg, key, ttl=1):
    data = local_reg.get(key, OrderedDict())
    if not isinstance(data, dict):
        data = OrderedDict()
    data.setdefault('ttl', ttl)
    data.setdefault('value', _default)
    data.setdefault('time', time.time())
    return data
def get_vms():
    '''Return all vms indexed by targets'''
    data = OrderedDict()
    for virt_type in VIRT_TYPES:
        all_infos = get_targets_and_vms_for_virt_type(virt_type)
        for t in all_infos:
            target = data.setdefault(t, {})
            vms = {}
            vts = set()
            for vmname in all_infos[t]:
                vms.setdefault(vmname, virt_type)
                vts.add(virt_type)
            target['virt_types'] = [a for a in vts]
            target['vms'] = vms
    return data
Beispiel #8
0
 def _dogather_exposed_data(target):
     _s = __salt__
     exposed_to_me = copy.deepcopy(gather_expositions()['indirect'].get(
         target, OrderedDict()))
     if target not in exposed_to_me:
         exposed_to_me[target] = {'access': 'full', 'kinds': []}
     kinds = exposed_to_me[target].setdefault('kinds', [])
     if is_a_vm(target):
         if 'vms' not in kinds:
             kinds.append('vms')
     if is_a_compute_node(target):
         if 'cns' not in kinds:
             kinds.append('cns')
     exposed_datas = OrderedDict()
     if not exposed_to_me:
         return {}
     for host, tdata in six.iteritems(exposed_to_me):
         for kind in tdata['kinds']:
             gepillar = copy.deepcopy(
                 ext_pillar(host, limited=True, prefixed=False))
             fun = {
                 'vms': 'mc_cloud_vm.ext_pillar',
                 'cns': 'mc_cloud_compute_node.ext_pillar'
             }[kind]
             sepillar = copy.deepcopy(_s[fun](host,
                                              prefixed=False,
                                              limited=True))
             gepillar = _s['mc_utils.dictupdate'](gepillar, sepillar)
             if kind == 'vms':
                 vms = gepillar.pop('vms', {})
                 gepillar.pop('vts', {})
                 vm = vms.get(host, {})
                 if vm:
                     gepillar = _s['mc_utils.dictupdate'](gepillar, vm)
             # only direct cloud settings
             to_remove = [
                 k for k in six.iterkeys(gepillar)
                 if (k.startswith('makina-states')
                     or k in ['ssl', 'ssl_certs'])
             ]
             for k in to_remove:
                 gepillar.pop(k, None)
             kexposed_datas = exposed_datas.setdefault(kind, OrderedDict())
             kexposed_datas[host] = _s['mc_utils.dictupdate'](
                 kexposed_datas.setdefault(host, OrderedDict()),
                 filter_exposed_data(target, gepillar, tdata['access']))
     return exposed_datas
 def _doget_targets(vt=None):
     data = OrderedDict()
     # cache warming
     __salt__['mc_cloud.extpillar_settings']()
     cloud_conf = __salt__['mc_pillar.get_cloud_conf_by_cns']()
     for t in cloud_conf:
         tdata = cloud_conf[t]
         target = data.setdefault(t, {})
         vts = target.setdefault('vts', [])
         vms = target.setdefault('vms', {})
         for cvt in tdata.get('vts'):
             if cvt not in VIRT_TYPES:
                 continue
             if cvt not in vts:
                 vts.append(cvt)
             if vt and (vt != cvt):
                 continue
         for vmname in tdata.get('vms', []):
             vm = vms.setdefault(vmname, OrderedDict())
             vm.update({'vt': cvt, 'target': t})
     return data
Beispiel #10
0
 def _dogather_expositions():
     _s = __salt__
     data = OrderedDict()
     direct = data.setdefault('direct', OrderedDict())
     indirect = data.setdefault('indirect', OrderedDict())
     vms = _s['mc_cloud_compute_node.get_vms']()
     targets = _s['mc_cloud_compute_node.get_targets']()
     for vkind, fun, mapping in [
         ('vms', 'mc_pillar.get_cloud_conf_for_vm', vms),
         ('cns', 'mc_pillar.get_cloud_conf_for_cn', targets),
     ]:
         for i, tdata in six.iteritems(mapping):
             if _s['mc_cloud.is_a_compute_node'](i):
                 kind = 'cns'
             else:
                 kind = 'vms'
             if not (is_a_vm(i) or is_a_compute_node(i)):
                 continue
             rexpose = direct.setdefault(i, OrderedDict())
             indirect_rexpose = indirect.setdefault(i, OrderedDict())
             cdata = _s[fun](i)
             if not cdata or not isinstance(cdata, dict):
                 continue
             expose = cdata.setdefault('expose', [])
             expose_limited = cdata.setdefault('expose_limited',
                                               OrderedDict())
             exposed = cdata.setdefault('exposed', [])
             exposed_limited = cdata.setdefault('expose_limited_in',
                                                OrderedDict())
             if not isinstance(expose, list):
                 expose = []
             if not isinstance(expose_limited, dict):
                 expose_limited = OrderedDict()
             if not isinstance(exposed, list):
                 exposed = []
             if not isinstance(exposed_limited, dict):
                 exposed_limited = OrderedDict()
             if not (expose or expose_limited or exposed
                     or exposed_limited):
                 continue
             for e in expose:
                 expose_limited[e] = 'full'
             for e in exposed:
                 exposed_limited[e] = 'full'
             for exposure, fdict in [(expose_limited, rexpose),
                                     (exposed_limited, indirect_rexpose)]:
                 for item, access in six.iteritems(exposure):
                     if _s['mc_cloud.is_a_compute_node'](item):
                         ikind = 'cns'
                     else:
                         ikind = 'vms'
                     dex = fdict.setdefault(item, {
                         'access': None,
                         'kinds': []
                     })
                     if ikind not in dex['kinds']:
                         dex['kinds'].append(ikind)
                     # first level try wins, be sure to set
                     # it to be consistent amongst all declaration in conf !
                     if dex['access'] is None:
                         dex['access'] = access
     directs = [a for a in direct]
     indirects = [a for a in indirect]
     for lmaps, tmap, itmap in [
         (indirects, indirect, direct),
         (directs, direct, indirect),
     ]:
         for host in lmaps:
             mapped = tmap[host]
             for ohost, odata in mapped.items():
                 expose = itmap.setdefault(ohost, OrderedDict())
                 edata = expose.setdefault(host, {
                     'access': None,
                     'kinds': []
                 })
                 if edata['access'] is None:
                     edata['access'] = odata['access']
                 for kind in odata['kinds']:
                     if kind not in edata['kinds']:
                         edata['kinds'].append(kind)
     return data