Exemplo n.º 1
0
def render(jp_data, saltenv='base', sls='', **kws):
    '''
    Accepts Java Properties as a string or as a file object and runs it through the jproperties
    parser. Uses the jproperties package https://pypi.python.org/pypi/jproperties so please
    "pip install jproperties" to use this renderer.

    Returns a flat dictionary by default:
      {'some.java.thing': 'whatever'}
    If using a 'shebang' "#!jproperties" header on the first line, an argument can be optionally
    supplied as a key to contain a dictionary of the rendered properties (ie. "#!jproperties foo"):
      {'foo': {'some.java.thing': 'whatever'}}

    :rtype: A Python data structure
    '''
    if not isinstance(jp_data, string_types):
        jp_data = jp_data.read()

    container = False
    if jp_data.startswith('#!'):
        args = jp_data[:jp_data.find('\n')].split()
        if len(args) >= 2:
            container = args[1]
        jp_data = jp_data[(jp_data.find('\n') + 1):]
    if not jp_data.strip():
        return {}
    properties = jp()
    properties.load(jp_data)
    if container:
        return {container: dict([(k, properties[k]) for k in six.iterkeys(properties)])}
    else:
        return dict([(k, properties[k]) for k in six.iterkeys(properties)])
Exemplo n.º 2
0
    def test_kill(self):
        def spin():
            salt.utils.appendproctitle('test_kill')
            while True:
                time.sleep(1)

        process_manager = salt.utils.process.ProcessManager()
        process_manager.add_process(spin)
        initial_pid = next(six.iterkeys(process_manager._process_map))
        # kill the child
        os.kill(initial_pid, signal.SIGKILL)
        # give the OS time to give the signal...
        time.sleep(0.1)
        process_manager.check_children()
        try:
            assert initial_pid != next(six.iterkeys(process_manager._process_map))
        finally:
            process_manager.stop_restarting()
            process_manager.kill_children()
            time.sleep(0.5)
            # Are there child processes still running?
            if process_manager._process_map.keys():
                process_manager.send_signal_to_processes(signal.SIGKILL)
                process_manager.stop_restarting()
                process_manager.kill_children()
Exemplo n.º 3
0
def __call_cli(jboss_config, command, retries=1):
    command_segments = [
        jboss_config['cli_path'],
        '--connect',
        '--controller="{0}"'.format(jboss_config['controller'])
    ]
    if 'cli_user' in six.iterkeys(jboss_config):
        command_segments.append('--user="{0}"'.format(jboss_config['cli_user']))
    if 'cli_password' in six.iterkeys(jboss_config):
        command_segments.append('--password="{0}"'.format(jboss_config['cli_password']))
    command_segments.append('--command="{0}"'.format(__escape_command(command)))
    cli_script = ' '.join(command_segments)

    cli_command_result = __salt__['cmd.run_all'](cli_script)
    log.debug('cli_command_result=%s', str(cli_command_result))

    log.debug('========= STDOUT:\n%s', cli_command_result['stdout'])
    log.debug('========= STDERR:\n%s', cli_command_result['stderr'])
    log.debug('========= RETCODE: %d', cli_command_result['retcode'])

    if cli_command_result['retcode'] == 127:
        raise CommandExecutionError('Could not execute jboss-cli.sh script. Have you specified server_dir variable correctly?\nCurrent CLI path: {cli_path}. '.format(cli_path=jboss_config['cli_path']))

    if cli_command_result['retcode'] == 1 and 'Unable to authenticate against controller' in cli_command_result['stderr']:
        raise CommandExecutionError('Could not authenticate against controller, please check username and password for the management console. Err code: {retcode}, stdout: {stdout}, stderr: {stderr}'.format(**cli_command_result))

    # It may happen that eventhough server is up it may not respond to the call
    if cli_command_result['retcode'] == 1 and 'JBAS012144' in cli_command_result['stderr'] and retries > 0:  # Cannot connect to cli
        log.debug('Command failed, retrying... (%d tries left)', retries)
        time.sleep(3)
        return __call_cli(jboss_config, command, retries - 1)

    return cli_command_result
Exemplo n.º 4
0
def table_find(table_to_find):
    '''
    Finds the schema in which the
    given table is present

    CLI Example::

        salt '*' drizzle.table_find table_name
    '''

    # Initializing the required variables
    ret_val = {}
    count = 1
    drizzle_db = _connect()
    cursor = drizzle_db.cursor()

    # Finding the schema
    schema = schemas()
    for schema_iter in six.iterkeys(schema):
        table = tables(schema[schema_iter])
        for table_iter in six.iterkeys(table):
            if table[table_iter] == table_to_find:
                ret_val[count] = schema[schema_iter]
                count = count+1

    cursor.close()
    drizzle_db.close()
    return ret_val
Exemplo n.º 5
0
 def SetIncludes(self, includes):
     if includes:
         for inc in includes:
             value = inc[next(six.iterkeys(inc))]
             include = next(six.iterkeys(inc))
             self.SetInclude(include, value)
             log.debug('was asked to set {0} to {1}'.format(include, value))
Exemplo n.º 6
0
    def test_cmd_call(self):
        result = self.HIGHSTATE.state.call_template_str(
            textwrap.dedent(
                """\
            #!pydsl
            state('A').cmd.run('echo this is state A', cwd='/')

            some_var = 12345
            def do_something(a, b, *args, **kws):
                return dict(result=True, changes={'a': a, 'b': b, 'args': args, 'kws': kws, 'some_var': some_var})

            state('C').cmd.call(do_something, 1, 2, 3, x=1, y=2) \
                          .require(state('A').cmd)

            state('G').cmd.wait('echo this is state G', cwd='/') \
                          .watch(state('C').cmd)
        """
            )
        )
        ret = next(result[k] for k in six.iterkeys(result) if "do_something" in k)
        changes = ret["changes"]
        self.assertEqual(changes, dict(a=1, b=2, args=(3,), kws=dict(x=1, y=2), some_var=12345))

        ret = next(result[k] for k in six.iterkeys(result) if "-G_" in k)
        self.assertEqual(ret["changes"]["stdout"], "this is state G")
Exemplo n.º 7
0
Arquivo: pkg.py Projeto: bryson/salt
def list_upgrades(jid, style="group", outputter="nested", ext_source=None):
    """
    Show list of available pkg upgrades using a specified format style

    CLI Example:

    .. code-block:: bash

        salt-run pkg.list_upgrades jid=20141120114114417719 style=group
    """
    mminion = salt.minion.MasterMinion(__opts__)
    returner = _get_returner((__opts__["ext_job_cache"], ext_source, __opts__["master_job_cache"]))

    data = mminion.returners["{0}.get_jid".format(returner)](jid)
    pkgs = {}

    if style == "group":
        for minion in data:
            results = data[minion]["return"]
            for pkg, pkgver in six.iteritems(results):
                if pkg not in six.iterkeys(pkgs):
                    pkgs[pkg] = {pkgver: {"hosts": []}}

                if pkgver not in six.iterkeys(pkgs[pkg]):
                    pkgs[pkg].update({pkgver: {"hosts": []}})

                pkgs[pkg][pkgver]["hosts"].append(minion)

    if outputter:
        salt.output.display_output(pkgs, outputter, opts=__opts__)

    return pkgs
Exemplo n.º 8
0
    def stages_iter(self):
        '''
        Return an iterator that yields the state call data as it is processed
        '''

        def yielder(gen_ret):
            if (not isinstance(gen_ret, list)
                    and not isinstance(gen_ret, dict)
                    and hasattr(gen_ret, 'next')):
                for sub_ret in gen_ret:
                    for yret in yielder(sub_ret):
                        yield yret
            else:
                yield gen_ret

        self.over_run = {}
        yield self.over
        for comp in self.over:
            name = next(six.iterkeys(comp))
            stage = comp[name]
            if name not in self.over_run:
                v_stage = self.verify_stage(stage)
                if isinstance(v_stage, list):
                    yield [comp]
                    yield v_stage
                else:
                    for sret in self.call_stage(name, stage):
                        for yret in yielder(sret):
                            sname = next(six.iterkeys(yret))
                            yield [self.get_stage(sname)]
                            final = {}
                            for minion in yret[sname]:
                                final[minion] = yret[sname][minion]['ret']
                            yield final
Exemplo n.º 9
0
    def test_basic(self):
        '''
        Make sure that the process is alive 2s later
        '''
        def spin():
            salt.utils.appendproctitle('test_basic')
            while True:
                time.sleep(1)

        process_manager = salt.utils.process.ProcessManager()
        process_manager.add_process(spin)
        initial_pid = next(six.iterkeys(process_manager._process_map))
        time.sleep(2)
        process_manager.check_children()
        try:
            assert initial_pid == next(six.iterkeys(process_manager._process_map))
        finally:
            process_manager.stop_restarting()
            process_manager.kill_children()
            time.sleep(0.5)
            # Are there child processes still running?
            if process_manager._process_map.keys():
                process_manager.send_signal_to_processes(signal.SIGKILL)
                process_manager.stop_restarting()
                process_manager.kill_children()
Exemplo n.º 10
0
def user_role_add(user_id=None, user=None, tenant_id=None,
                  tenant=None, role_id=None, role=None, profile=None,
                  project_id=None, project_name=None, **connection_args):
    '''
    Add role for user in tenant (keystone user-role-add)

    CLI Examples:

    .. code-block:: bash

        salt '*' keystone.user_role_add \
user_id=298ce377245c4ec9b70e1c639c89e654 \
tenant_id=7167a092ece84bae8cead4bf9d15bb3b \
role_id=ce377245c4ec9b70e1c639c89e8cead4
        salt '*' keystone.user_role_add user=admin tenant=admin role=admin
    '''
    kstone = auth(profile, **connection_args)

    if project_id and not tenant_id:
        tenant_id = project_id
    elif project_name and not tenant:
        tenant = project_name

    if user:
        user_id = user_get(name=user, profile=profile,
                           **connection_args)[user].get('id')
    else:
        user = next(six.iterkeys(user_get(user_id, profile=profile,
                                          **connection_args)))['name']
    if not user_id:
        return {'Error': 'Unable to resolve user id'}

    if tenant:
        tenant_id = tenant_get(name=tenant, profile=profile,
                               **connection_args)[tenant].get('id')
    else:
        tenant = next(six.iterkeys(tenant_get(tenant_id, profile=profile,
                                              **connection_args)))['name']
    if not tenant_id:
        return {'Error': 'Unable to resolve tenant/project id'}

    if role:
        role_id = role_get(name=role, profile=profile,
                           **connection_args)[role]['id']
    else:
        role = next(six.iterkeys(role_get(role_id, profile=profile,
                                          **connection_args)))['name']
    if not role_id:
        return {'Error': 'Unable to resolve role id'}

    if _OS_IDENTITY_API_VERSION > 2:
        kstone.roles.grant(role_id, user=user_id, project=tenant_id)
    else:
        kstone.roles.add_user_role(user_id, role_id, tenant_id)
    ret_msg = '"{0}" role added for user "{1}" for "{2}" tenant/project'
    return ret_msg.format(role, user, tenant)
Exemplo n.º 11
0
    def test_restarting(self):
        '''
        Make sure that the process is alive 2s later
        '''
        def die():
            time.sleep(1)

        process_manager = salt.utils.process.ProcessManager()
        process_manager.add_process(die)
        initial_pid = next(six.iterkeys(process_manager._process_map))
        time.sleep(2)
        process_manager.check_children()
        assert initial_pid != next(six.iterkeys(process_manager._process_map))
        process_manager.kill_children()
Exemplo n.º 12
0
    def test_kill(self):
        def spin():
            while True:
                time.sleep(1)

        process_manager = salt.utils.process.ProcessManager()
        process_manager.add_process(spin)
        initial_pid = next(six.iterkeys(process_manager._process_map))
        # kill the child
        os.kill(initial_pid, signal.SIGTERM)
        # give the OS time to give the signal...
        time.sleep(0.1)
        process_manager.check_children()
        assert initial_pid != next(six.iterkeys(process_manager._process_map))
        process_manager.kill_children()
Exemplo n.º 13
0
    def test_basic(self):
        '''
        Make sure that the process is alive 2s later
        '''
        def spin():
            while True:
                time.sleep(1)

        process_manager = salt.utils.process.ProcessManager()
        process_manager.add_process(spin)
        initial_pid = next(six.iterkeys(process_manager._process_map))
        time.sleep(2)
        process_manager.check_children()
        assert initial_pid == next(six.iterkeys(process_manager._process_map))
        process_manager.kill_children()
Exemplo n.º 14
0
Arquivo: virt.py Projeto: DaveQB/salt
def purge(name, delete_key=True):
    '''
    Destroy the named vm
    '''
    ret = {}
    client = salt.client.get_local_client(__opts__['conf_file'])
    data = vm_info(name, quiet=True)
    if not data:
        __jid_event__.fire_event({'error': 'Failed to find vm {0} to purge'.format(name)}, 'progress')
        return 'fail'
    hyper = next(six.iterkeys(data))
    try:
        cmd_ret = client.cmd_iter(
                hyper,
                'virt.purge',
                [name, True],
                timeout=600)
    except SaltClientError as client_error:
        return 'Virtual machine {0} could not be purged: {1}'.format(name, client_error)

    for comp in cmd_ret:
        ret.update(comp)

    if delete_key:
        skey = salt.key.Key(__opts__)
        skey.delete_key(name)
    __jid_event__.fire_event({'message': 'Purged VM {0}'.format(name)}, 'progress')
    return 'good'
Exemplo n.º 15
0
Arquivo: virt.py Projeto: DaveQB/salt
def force_off(name):
    '''
    Force power down the named virtual machine
    '''
    ret = {}
    client = salt.client.get_local_client(__opts__['conf_file'])
    data = vm_info(name, quiet=True)
    if not data:
        print('Failed to find vm {0} to destroy'.format(name))
        return 'fail'
    hyper = next(six.iterkeys(data))
    if data[hyper][name]['state'] == 'shutdown':
        print('VM {0} is already shutdown'.format(name))
        return'bad state'
    try:
        cmd_ret = client.cmd_iter(
                hyper,
                'virt.destroy',
                [name],
                timeout=600)
    except SaltClientError as client_error:
        return 'Virtual machine {0} could not be forced off: {1}'.format(name, client_error)
    for comp in cmd_ret:
        ret.update(comp)
    __jid_event__.fire_event({'message': 'Powered off VM {0}'.format(name)}, 'progress')
    return 'good'
Exemplo n.º 16
0
Arquivo: virt.py Projeto: DaveQB/salt
def start(name):
    '''
    Start a named virtual machine
    '''
    ret = {}
    client = salt.client.get_local_client(__opts__['conf_file'])
    data = vm_info(name, quiet=True)
    if not data:
        __jid_event__.fire_event({'message': 'Failed to find vm {0} to start'.format(name)}, 'progress')
        return 'fail'
    hyper = next(six.iterkeys(data))
    if data[hyper][name]['state'] == 'running':
        print('VM {0} is already running'.format(name))
        return 'bad state'
    try:
        cmd_ret = client.cmd_iter(
                hyper,
                'virt.start',
                [name],
                timeout=600)
    except SaltClientError as client_error:
        return 'Virtual machine {0} not started: {1}'. format(name, client_error)
    for comp in cmd_ret:
        ret.update(comp)
    __jid_event__.fire_event({'message': 'Started VM {0}'.format(name)}, 'progress')
    return 'good'
Exemplo n.º 17
0
def pause(name):
    '''
    Pause the named VM
    '''
    ret = {}
    client = salt.client.get_local_client(__opts__['conf_file'])

    data = vm_info(name, quiet=True)
    if not data:
        __jid_event__.fire_event({'error': 'Failed to find VM {0} to pause'.format(name)}, 'progress')
        return 'fail'
    host = next(six.iterkeys(data))
    if data[host][name]['state'] == 'paused':
        __jid_event__.fire_event({'error': 'VM {0} is already paused'.format(name)}, 'progress')
        return 'bad state'
    try:
        cmd_ret = client.cmd_iter(
                host,
                'virt.pause',
                [name],
                timeout=600)
    except SaltClientError as client_error:
        return 'Virtual machine {0} could not be pasued: {1}'.format(name, client_error)
    for comp in cmd_ret:
        ret.update(comp)
    __jid_event__.fire_event({'message': 'Paused VM {0}'.format(name)}, 'progress')
    return 'good'
Exemplo n.º 18
0
def list_renderers(*args):
    """
    List the renderers loaded on the minion

    .. versionadded:: 2015.5.0

    CLI Example:

    .. code-block:: bash

        salt '*' sys.list_renderers

    Render names can be specified as globs.

    .. code-block:: bash

        salt '*' sys.list_renderers 'yaml*'

    """
    ren_ = salt.loader.render(__opts__, [])
    ren = set()

    if not args:
        for func in six.iterkeys(ren_):
            ren.add(func)
        return sorted(ren)

    for module in args:
        for func in fnmatch.filter(ren_, module):
            ren.add(func)
    return sorted(ren)
Exemplo n.º 19
0
    def attrs(self):
        kwargs = self.kwargs

        # handle our requisites
        for attr in REQUISITES:
            if attr in kwargs:
                # our requisites should all be lists, but when you only have a
                # single item it's more convenient to provide it without
                # wrapping it in a list. transform them into a list
                if not isinstance(kwargs[attr], list):
                    kwargs[attr] = [kwargs[attr]]

                # rebuild the requisite list transforming any of the actual
                # StateRequisite objects into their representative dict
                kwargs[attr] = [
                    req() if isinstance(req, StateRequisite) else req
                    for req in kwargs[attr]
                ]

        # build our attrs from kwargs. we sort the kwargs by key so that we
        # have consistent ordering for tests
        return [
            {k: kwargs[k]}
            for k in sorted(six.iterkeys(kwargs))
        ]
Exemplo n.º 20
0
def _list_iter(host=None, path=None):
    '''
    Return a generator iterating over hosts

    path
        path to the container parent
        default: /var/lib/lxc (system default)

        .. versionadded:: Beryllium
    '''
    tgt = host or '*'
    client = salt.client.get_local_client(__opts__['conf_file'])
    for container_info in client.cmd_iter(
        tgt, 'lxc.list', kwarg={'path': path}
    ):
        if not container_info:
            continue
        if not isinstance(container_info, dict):
            continue
        chunk = {}
        id_ = next(six.iterkeys(container_info))
        if host and host != id_:
            continue
        if not isinstance(container_info[id_], dict):
            continue
        if 'ret' not in container_info[id_]:
            continue
        if not isinstance(container_info[id_]['ret'], dict):
            continue
        chunk[id_] = container_info[id_]['ret']
        yield chunk
Exemplo n.º 21
0
def avail_images(call=None):
    '''
    Return a list of the images that are on the provider
    '''
    if call == 'action':
        raise SaltCloudSystemExit(
            'The avail_images function must be called with '
            '-f or --function, or with the --list-images option'
        )

    fetch = True
    page = 1
    ret = {}

    while fetch:
        items = query(method='images', command='?page=' + str(page) + '&per_page=200')

        for image in items['images']:
            ret[image['name']] = {}
            for item in six.iterkeys(image):
                ret[image['name']][item] = image[item]

        page += 1
        try:
            fetch = 'next' in items['links']['pages']
        except KeyError:
            fetch = False

    return ret
Exemplo n.º 22
0
def _execute_pillar(pillar_name, run_type):
    '''
    Run one or more nagios plugins from pillar data and get the result of run_type
    The pillar have to be in this format:
    ------
    webserver:
        Ping_google:
            - check_icmp: 8.8.8.8
            - check_icmp: google.com
        Load:
            - check_load: -w 0.8 -c 1
        APT:
            - check_apt
    -------
    '''
    groups = __salt__['pillar.get'](pillar_name)

    data = {}
    for group in groups:
        data[group] = {}
        commands = groups[group]
        for command in commands:
            # Check if is a dict to get the arguments
            # in command if not set the arguments to empty string
            if isinstance(command, dict):
                plugin = next(six.iterkeys(command))
                args = command[plugin]
            else:
                plugin = command
                args = ''
            command_key = _format_dict_key(args, plugin)
            data[group][command_key] = run_type(plugin, args)
    return data
Exemplo n.º 23
0
def _expand_one_key_dictionary(_dict):
    '''
    Returns the only one key and it's value from a dictionary.
    '''
    key = next(six.iterkeys(_dict))
    value = _dict[key]
    return key, value
Exemplo n.º 24
0
    def destroy(self, linger=5000):
        if self.cpub is True and self.sub.closed is False:
            # Wait at most 2.5 secs to send any remaining messages in the
            # socket or the context.term() below will hang indefinitely.
            # See https://github.com/zeromq/pyzmq/issues/102
            self.sub.close()
        if self.cpush is True and self.push.closed is False:
            self.push.close()
        # If sockets are not unregistered from a poller, nothing which touches
        # that poller gets garbage collected. The Poller itself, its
        # registered sockets and the Context
        if isinstance(self.poller.sockets, dict):
            for socket in six.iterkeys(self.poller.sockets):
                if socket.closed is False:
                    socket.setsockopt(zmq.LINGER, linger)
                    socket.close()
                self.poller.unregister(socket)
        else:
            for socket in self.poller.sockets:
                if socket[0].closed is False:
                    socket[0].setsockopt(zmq.LINGER, linger)
                    socket[0].close()
                self.poller.unregister(socket[0])
        if self.context.closed is False:
            self.context.term()

        # Hardcore destruction
        if hasattr(self.context, 'destroy'):
            self.context.destroy(linger=1)

        # https://github.com/zeromq/pyzmq/issues/173#issuecomment-4037083
        # Assertion failed: get_load () == 0 (poller_base.cpp:32)
        time.sleep(0.025)
Exemplo n.º 25
0
Arquivo: nova.py Projeto: bryson/salt
    def _sanatize_network_params(self, kwargs):
        """
        Sanatize novaclient network parameters
        """
        params = [
            "label",
            "bridge",
            "bridge_interface",
            "cidr",
            "cidr_v6",
            "dns1",
            "dns2",
            "fixed_cidr",
            "gateway",
            "gateway_v6",
            "multi_host",
            "priority",
            "project_id",
            "vlan_start",
            "vpn_start",
        ]

        for variable in six.iterkeys(kwargs):  # iterate over a copy, we might delete some
            if variable not in params:
                del kwargs[variable]
        return kwargs
Exemplo n.º 26
0
    def __gather_minions(self):
        '''
        Return a list of minions to use for the batch run
        '''
        args = [self.opts['tgt'],
                'test.ping',
                [],
                self.opts['timeout'],
                ]

        selected_target_option = self.opts.get('selected_target_option', None)
        if selected_target_option is not None:
            args.append(selected_target_option)
        else:
            args.append(self.opts.get('expr_form', 'glob'))

        ping_gen = self.local.cmd_iter(*args, **self.eauth)

        fret = set()
        try:
            for ret in ping_gen:
                m = next(six.iterkeys(ret))
                if m is not None:
                    fret.add(m)
            return (list(fret), ping_gen)
        except StopIteration:
            raise salt.exceptions.SaltClientError('No minions matched the target.')
Exemplo n.º 27
0
Arquivo: virt.py Projeto: DaveQB/salt
def resume(name):
    '''
    Resume a paused vm
    '''
    ret = {}
    client = salt.client.get_local_client(__opts__['conf_file'])
    data = vm_info(name, quiet=True)
    if not data:
        __jid_event__.fire_event({'error': 'Failed to find VM {0} to pause'.format(name)}, 'progress')
        return 'not found'
    hyper = next(six.iterkeys(data))
    if data[hyper][name]['state'] != 'paused':
        __jid_event__.fire_event({'error': 'VM {0} is not paused'.format(name)}, 'progress')
        return 'bad state'
    try:
        cmd_ret = client.cmd_iter(
                hyper,
                'virt.resume',
                [name],
                timeout=600)
    except SaltClientError as client_error:
        return 'Virtual machine {0} could not be resumed: {1}'.format(name, client_error)
    for comp in cmd_ret:
        ret.update(comp)
    __jid_event__.fire_event({'message': 'Resumed VM {0}'.format(name)}, 'progress')
    return 'good'
Exemplo n.º 28
0
def list_keypairs(call=None):
    '''
    Return a dict of all available VM locations on the cloud provider with
    relevant data
    '''
    if call != 'function':
        log.error(
            'The list_keypairs function must be called with -f or --function.'
        )
        return False

    items = query(method='account/keys')
    ret = {}
    for key_pair in items['ssh_keys']:
        name = key_pair['name']
        if name in ret:
            raise SaltCloudSystemExit(
                'A duplicate key pair name, \'{0}\', was found in DigitalOcean\'s '
                'key pair list. Please change the key name stored by DigitalOcean. '
                'Be sure to adjust the value of \'ssh_key_file\' in your cloud '
                'profile or provider configuration, if necessary.'.format(
                    name
                )
            )
        ret[name] = {}
        for item in six.iterkeys(key_pair):
            ret[name][item] = str(key_pair[item])

    return ret
Exemplo n.º 29
0
 def spec_check(self, auth_list, fun, form):
     '''
     Check special API permissions
     '''
     if form != 'cloud':
         comps = fun.split('.')
         if len(comps) != 2:
             return False
         mod = comps[0]
         fun = comps[1]
     else:
         mod = fun
     for ind in auth_list:
         if isinstance(ind, six.string_types):
             if ind.startswith('@') and ind[1:] == mod:
                 return True
             if ind == '@{0}'.format(form):
                 return True
             if ind == '@{0}s'.format(form):
                 return True
         elif isinstance(ind, dict):
             if len(ind) != 1:
                 continue
             valid = next(six.iterkeys(ind))
             if valid.startswith('@') and valid[1:] == mod:
                 if isinstance(ind[valid], six.string_types):
                     if self.match_check(ind[valid], fun):
                         return True
                 elif isinstance(ind[valid], list):
                     for regex in ind[valid]:
                         if self.match_check(regex, fun):
                             return True
     return False
Exemplo n.º 30
0
def config(name, config, edit=True):
    '''
    Create VirtualHost configuration files

    name
        File for the virtual host
    config
        VirtualHost configurations

    .. note::

        This function is not meant to be used from the command line.
        Config is meant to be an ordered dict of all of the apache configs.

    CLI Example:

    .. code-block:: bash

        salt '*' apache.config /etc/httpd/conf.d/ports.conf config="[{'Listen': '22'}]"
    '''

    for entry in config:
        key = next(six.iterkeys(entry))
        configs = _parse_config(entry[key], key)
        if edit:
            with salt.utils.fopen(name, 'w') as configfile:
                configfile.write('# This file is managed by saltstack.\n')
                configfile.write(configs)
    return configs