コード例 #1
0
def main():
    """ main entry point for module execution
    """
    argument_spec = dict(
        hostname=dict(),
        domain_name=dict(),
        domain_search=dict(type='list'),
        name_servers=dict(type='list'),
        state=dict(choices=['present', 'absent'], default='present'),
        active=dict(default=True, type='bool')
    )

    argument_spec.update(junos_argument_spec)

    params = ['hostname', 'domain_name', 'domain_search', 'name_servers']
    required_if = [('state', 'present', params, True),
                   ('state', 'absent', params, True),
                   ('state', 'active', params, True),
                   ('state', 'suspend', params, True)]

    module = AnsibleModule(argument_spec=argument_spec,
                           required_if=required_if,
                           supports_check_mode=True)

    warnings = list()
    result = {'changed': False}

    if warnings:
        result['warnings'] = warnings

    top = 'system'

    param_to_xpath_map = collections.OrderedDict()
    param_to_xpath_map.update([
        ('hostname', {'xpath': 'host-name', 'leaf_only': True}),
        ('domain_name', {'xpath': 'domain-name', 'leaf_only': True}),
        ('domain_search', {'xpath': 'domain-search', 'leaf_only': True, 'value_req': True}),
        ('name_servers', {'xpath': 'name-server/name', 'is_key': True})
    ])

    validate_param_values(module, param_to_xpath_map)

    want = map_params_to_obj(module, param_to_xpath_map)
    ele = map_obj_to_ele(module, want, top)

    with locked_config(module):
        diff = load_config(module, tostring(ele), warnings, action='merge')

        commit = not module.check_mode
        if diff:
            if commit:
                commit_configuration(module)
            else:
                discard_changes(module)
            result['changed'] = True

            if module._diff:
                result['diff'] = {'prepared': diff}

    module.exit_json(**result)
コード例 #2
0
def main():
    """ main entry point for module execution
    """
    element_spec = dict(
        name=dict(),
        full_name=dict(),
        role=dict(choices=ROLES),
        encrypted_password=dict(no_log=True),
        sshkey=dict(),
        state=dict(choices=['present', 'absent'], default='present'),
        active=dict(type='bool', default=True)
    )

    aggregate_spec = deepcopy(element_spec)
    aggregate_spec['name'] = dict(required=True)

    # remove default in aggregate spec, to handle common arguments
    remove_default_spec(aggregate_spec)

    argument_spec = dict(
        aggregate=dict(type='list', elements='dict', options=aggregate_spec, aliases=['collection', 'users']),
        purge=dict(default=False, type='bool')
    )

    argument_spec.update(element_spec)
    argument_spec.update(junos_argument_spec)

    mutually_exclusive = [['aggregate', 'name']]

    module = AnsibleModule(argument_spec=argument_spec,
                           mutually_exclusive=mutually_exclusive,
                           supports_check_mode=True)

    warnings = list()
    result = {'changed': False, 'warnings': warnings}

    want = map_params_to_obj(module)
    ele = map_obj_to_ele(module, want)

    purge_request = None
    if module.params['purge']:
        purge_request = handle_purge(module, want)

    with locked_config(module):
        if purge_request:
            load_config(module, tostring(purge_request), warnings, action='replace')
        diff = load_config(module, tostring(ele), warnings, action='merge')

        commit = not module.check_mode
        if diff:
            if commit:
                commit_configuration(module)
            else:
                discard_changes(module)
            result['changed'] = True

            if module._diff:
                result['diff'] = {'prepared': diff}

    module.exit_json(**result)
コード例 #3
0
    def execute_module(self):
        """ Execute the module
        :rtype: A dictionary
        :returns: The result from module execution
        """
        result = {"changed": False}
        warnings = list()

        existing_lag_interfaces_facts = self.get_lag_interfaces_facts()
        config_xmls = self.set_config(existing_lag_interfaces_facts)

        with locked_config(self._module):
            for config_xml in to_list(config_xmls):
                diff = load_config(self._module, config_xml, warnings)

            commit = not self._module.check_mode
            if diff:
                if commit:
                    commit_configuration(self._module)
                else:
                    discard_changes(self._module)
                result["changed"] = True

                if self._module._diff:
                    result["diff"] = {"prepared": diff}

        result["xml"] = config_xmls

        changed_lag_interfaces_facts = self.get_lag_interfaces_facts()

        result["before"] = existing_lag_interfaces_facts
        if result["changed"]:
            result["after"] = changed_lag_interfaces_facts

        return result
コード例 #4
0
    def execute_module(self):
        """ Execute the module

        :rtype: A dictionary
        :returns: The result from module execution
        """
        result = {'changed': False}

        existing_interfaces_facts = self.get_interfaces_facts()

        config_xmls = self.set_config(existing_interfaces_facts)
        with locked_config(self._module):
            for config_xml in to_list(config_xmls):
                diff = load_config(self._module, config_xml, [])

            commit = not self._module.check_mode
            if diff:
                if commit:
                    commit_configuration(self._module)
                else:
                    discard_changes(self._module)
                result['changed'] = True

                if self._module._diff:
                    result['diff'] = {'prepared': diff}

        result['commands'] = config_xmls

        changed_interfaces_facts = self.get_interfaces_facts()

        result['before'] = existing_interfaces_facts
        if result['changed']:
            result['after'] = changed_interfaces_facts

        return result
コード例 #5
0
def main():
    """ main entry point for module execution
    """
    argument_spec = dict(
        banner=dict(required=True, choices=["login", "motd"]),
        text=dict(),
        state=dict(default="present", choices=["present", "absent"]),
        active=dict(default=True, type="bool"),
    )

    argument_spec.update(junos_argument_spec)

    required_if = [("state", "present", ("text", ))]

    module = AnsibleModule(
        argument_spec=argument_spec,
        required_if=required_if,
        supports_check_mode=True,
    )

    warnings = list()
    result = {"changed": False}

    if warnings:
        result["warnings"] = warnings

    top = "system/login"

    param_to_xpath_map = collections.OrderedDict()

    param_to_xpath_map.update([(
        "text",
        {
            "xpath": "message"
            if module.params["banner"] == "login" else "announcement",
            "leaf_only": True,
        },
    )])

    validate_param_values(module, param_to_xpath_map)

    want = map_params_to_obj(module, param_to_xpath_map)
    ele = map_obj_to_ele(module, want, top)

    with locked_config(module):
        diff = load_config(module, tostring(ele), warnings, action="merge")

        commit = not module.check_mode
        if diff:
            if commit:
                commit_configuration(module)
            else:
                discard_changes(module)
            result["changed"] = True

            if module._diff:
                result["diff"] = {"prepared": diff}

    module.exit_json(**result)
コード例 #6
0
def main():
    """ main entry point for module execution
    """
    argument_spec = dict(
        name=dict(),
        state=dict(default='present',
                   choices=['present', 'absent', 'enabled', 'disabled']),
        active=dict(default=True, type='bool'))

    argument_spec.update(junos_argument_spec)

    module = AnsibleModule(argument_spec=argument_spec,
                           supports_check_mode=True)

    warnings = list()
    result = {'changed': False}

    if warnings:
        result['warnings'] = warnings

    top = 'protocols/lldp/interface'

    param_to_xpath_map = collections.OrderedDict()
    param_to_xpath_map.update([('name', {
        'xpath': 'name',
        'is_key': True
    }), ('disable', {
        'xpath': 'disable',
        'tag_only': True
    })])

    item = module.params.copy()
    state = item.get('state')
    item['disable'] = True if state in ('disabled', 'absent') else False

    if state in ('enabled', 'disabled'):
        item['state'] = 'present'

    want = map_params_to_obj(module, param_to_xpath_map, param=item)
    ele = map_obj_to_ele(module, want, top, param=item)

    with locked_config(module):
        diff = load_config(module, tostring(ele), warnings, action='merge')

        commit = not module.check_mode
        if diff:
            if commit:
                commit_configuration(module)
            else:
                discard_changes(module)
            result['changed'] = True

            if module._diff:
                result['diff'] = {'prepared': diff}

    module.exit_json(**result)
コード例 #7
0
def main():
    """ main entry point for module execution
    """
    argument_spec = dict(banner=dict(required=True, choices=['login', 'motd']),
                         text=dict(),
                         state=dict(default='present',
                                    choices=['present', 'absent']),
                         active=dict(default=True, type='bool'))

    argument_spec.update(junos_argument_spec)

    required_if = [('state', 'present', ('text', ))]

    module = AnsibleModule(argument_spec=argument_spec,
                           required_if=required_if,
                           supports_check_mode=True)

    warnings = list()
    result = {'changed': False}

    if warnings:
        result['warnings'] = warnings

    top = 'system/login'

    param_to_xpath_map = collections.OrderedDict()

    param_to_xpath_map.update([('text', {
        'xpath':
        'message' if module.params['banner'] == 'login' else 'announcement',
        'leaf_only':
        True
    })])

    validate_param_values(module, param_to_xpath_map)

    want = map_params_to_obj(module, param_to_xpath_map)
    ele = map_obj_to_ele(module, want, top)

    with locked_config(module):
        diff = load_config(module, tostring(ele), warnings, action='merge')

        commit = not module.check_mode
        if diff:
            if commit:
                commit_configuration(module)
            else:
                discard_changes(module)
            result['changed'] = True

            if module._diff:
                result['diff'] = {'prepared': diff}

    module.exit_json(**result)
コード例 #8
0
def main():
    """ main entry point for module execution
    """
    element_spec = dict(
        name=dict(),
        description=dict(),
        rd=dict(type="list"),
        interfaces=dict(type="list"),
        target=dict(type="list"),
        state=dict(default="present", choices=["present", "absent"]),
        active=dict(default=True, type="bool"),
        table_label=dict(default=True, type="bool"),
    )

    aggregate_spec = deepcopy(element_spec)
    aggregate_spec["name"] = dict(required=True)

    # remove default in aggregate spec, to handle common arguments
    remove_default_spec(aggregate_spec)

    argument_spec = dict(
        aggregate=dict(type="list", elements="dict", options=aggregate_spec))

    argument_spec.update(element_spec)
    argument_spec.update(junos_argument_spec)

    required_one_of = [["aggregate", "name"]]
    mutually_exclusive = [["aggregate", "name"]]

    module = AnsibleModule(
        argument_spec=argument_spec,
        supports_check_mode=True,
        required_one_of=required_one_of,
        mutually_exclusive=mutually_exclusive,
    )

    warnings = list()
    result = {"changed": False}

    if warnings:
        result["warnings"] = warnings

    top = "routing-instances/instance"

    param_to_xpath_map = collections.OrderedDict()
    param_to_xpath_map.update([
        ("name", {
            "xpath": "name",
            "is_key": True
        }),
        ("description", "description"),
        ("type", "instance-type"),
        ("rd", "route-distinguisher/rd-type"),
        ("interfaces", "interface/name"),
        ("target", "vrf-target/community"),
        ("table_label", {
            "xpath": "vrf-table-label",
            "tag_only": True
        }),
    ])

    params = to_param_list(module)
    requests = list()

    for param in params:
        # if key doesn't exist in the item, get it from module.params
        for key in param:
            if param.get(key) is None:
                param[key] = module.params[key]

        item = param.copy()
        item["type"] = "vrf"

        want = map_params_to_obj(module, param_to_xpath_map, param=item)
        requests.append(map_obj_to_ele(module, want, top, param=item))

    with locked_config(module):
        for req in requests:
            diff = load_config(module, tostring(req), warnings, action="merge")

        commit = not module.check_mode
        if diff:
            if commit:
                commit_configuration(module)
            else:
                discard_changes(module)
            result["changed"] = True

            if module._diff:
                result["diff"] = {"prepared": diff}

    module.exit_json(**result)
コード例 #9
0
def main():
    """ main entry point for module execution
    """
    element_spec = dict(name=dict(),
                        ipv4=dict(),
                        ipv6=dict(),
                        filter_input=dict(),
                        filter_output=dict(),
                        filter6_input=dict(),
                        filter6_output=dict(),
                        unit=dict(default=0, type='int'),
                        state=dict(default='present',
                                   choices=['present', 'absent']),
                        active=dict(default=True, type='bool'))

    aggregate_spec = deepcopy(element_spec)
    aggregate_spec['name'] = dict(required=True)

    # remove default in aggregate spec, to handle common arguments
    remove_default_spec(aggregate_spec)

    argument_spec = dict(aggregate=dict(type='list',
                                        elements='dict',
                                        options=aggregate_spec), )

    argument_spec.update(element_spec)
    argument_spec.update(junos_argument_spec)

    required_one_of = [['name', 'aggregate']]
    mutually_exclusive = [['name', 'aggregate']]

    module = AnsibleModule(argument_spec=argument_spec,
                           supports_check_mode=True,
                           mutually_exclusive=mutually_exclusive,
                           required_one_of=required_one_of)

    warnings = list()
    result = {'changed': False}

    if warnings:
        result['warnings'] = warnings

    top = 'interfaces/interface'

    param_to_xpath_map = collections.OrderedDict()
    param_to_xpath_map.update([
        ('name', {
            'xpath': 'name',
            'parent_attrib': False,
            'is_key': True
        }),
        ('unit', {
            'xpath': 'name',
            'top': 'unit',
            'parent_attrib': False,
            'is_key': True
        }),
        ('ipv4', {
            'xpath': 'inet/address/name',
            'top': 'unit/family',
            'is_key': True
        }),
        ('ipv6', {
            'xpath': 'inet6/address/name',
            'top': 'unit/family',
            'is_key': True
        }),
        ('filter_input', {
            'xpath': 'inet/filter/input',
            'top': 'unit/family'
        }),
        ('filter_output', {
            'xpath': 'inet/filter/output',
            'top': 'unit/family'
        }),
        ('filter6_input', {
            'xpath': 'inet6/filter/input',
            'top': 'unit/family'
        }),
        ('filter6_output', {
            'xpath': 'inet6/filter/output',
            'top': 'unit/family'
        }),
    ])

    params = to_param_list(module)

    requests = list()
    for param in params:
        # if key doesn't exist in the item, get it from module.params
        for key in param:
            if param.get(key) is None:
                param[key] = module.params[key]

        item = param.copy()
        if not item['ipv4'] and not item['ipv6']:
            module.fail_json(msg="one of the following is required: ipv4,ipv6")

        want = map_params_to_obj(module, param_to_xpath_map, param=item)
        requests.append(map_obj_to_ele(module, want, top, param=item))

    diff = None
    with locked_config(module):
        for req in requests:
            diff = load_config(module, tostring(req), warnings, action='merge')

        commit = not module.check_mode
        if diff:
            if commit:
                commit_configuration(module)
            else:
                discard_changes(module)
            result['changed'] = True

            if module._diff:
                result['diff'] = {'prepared': diff}

    module.exit_json(**result)
コード例 #10
0
def main():
    """ main entry point for module execution
    """
    element_spec = dict(
        name=dict(),
        full_name=dict(),
        role=dict(choices=ROLES),
        encrypted_password=dict(),
        sshkey=dict(),
        state=dict(choices=["present", "absent"], default="present"),
        active=dict(type="bool", default=True),
    )

    aggregate_spec = deepcopy(element_spec)
    aggregate_spec["name"] = dict(required=True)

    # remove default in aggregate spec, to handle common arguments
    remove_default_spec(aggregate_spec)

    argument_spec = dict(
        aggregate=dict(
            type="list",
            elements="dict",
            options=aggregate_spec,
            aliases=["collection", "users"],
        ),
        purge=dict(default=False, type="bool"),
    )

    argument_spec.update(element_spec)
    argument_spec.update(junos_argument_spec)

    mutually_exclusive = [["aggregate", "name"]]

    module = AnsibleModule(
        argument_spec=argument_spec,
        mutually_exclusive=mutually_exclusive,
        supports_check_mode=True,
    )

    warnings = list()
    result = {"changed": False, "warnings": warnings}

    want = map_params_to_obj(module)
    ele = map_obj_to_ele(module, want)

    purge_request = None
    if module.params["purge"]:
        purge_request = handle_purge(module, want)

    with locked_config(module):
        if purge_request:
            load_config(module,
                        tostring(purge_request),
                        warnings,
                        action="replace")
        diff = load_config(module, tostring(ele), warnings, action="merge")

        commit = not module.check_mode
        if diff:
            if commit:
                commit_configuration(module)
            else:
                discard_changes(module)
            result["changed"] = True

            if module._diff:
                result["diff"] = {"prepared": diff}

    module.exit_json(**result)
コード例 #11
0
def main():
    """ main entry point for module execution
    """
    element_spec = dict(
        name=dict(),
        ipv4=dict(),
        ipv6=dict(),
        filter_input=dict(),
        filter_output=dict(),
        filter6_input=dict(),
        filter6_output=dict(),
        unit=dict(default=0, type="int"),
        state=dict(default="present", choices=["present", "absent"]),
        active=dict(default=True, type="bool"),
    )

    aggregate_spec = deepcopy(element_spec)
    aggregate_spec["name"] = dict(required=True)

    # remove default in aggregate spec, to handle common arguments
    remove_default_spec(aggregate_spec)

    argument_spec = dict(
        aggregate=dict(type="list", elements="dict", options=aggregate_spec)
    )

    argument_spec.update(element_spec)
    argument_spec.update(junos_argument_spec)

    required_one_of = [["name", "aggregate"]]
    mutually_exclusive = [["name", "aggregate"]]

    module = AnsibleModule(
        argument_spec=argument_spec,
        supports_check_mode=True,
        mutually_exclusive=mutually_exclusive,
        required_one_of=required_one_of,
    )

    warnings = list()
    result = {"changed": False}

    if warnings:
        result["warnings"] = warnings

    top = "interfaces/interface"

    param_to_xpath_map = collections.OrderedDict()
    param_to_xpath_map.update(
        [
            (
                "name",
                {"xpath": "name", "parent_attrib": False, "is_key": True},
            ),
            (
                "unit",
                {
                    "xpath": "name",
                    "top": "unit",
                    "parent_attrib": False,
                    "is_key": True,
                },
            ),
            (
                "ipv4",
                {
                    "xpath": "inet/address/name",
                    "top": "unit/family",
                    "is_key": True,
                },
            ),
            (
                "ipv6",
                {
                    "xpath": "inet6/address/name",
                    "top": "unit/family",
                    "is_key": True,
                },
            ),
            (
                "filter_input",
                {"xpath": "inet/filter/input", "top": "unit/family"},
            ),
            (
                "filter_output",
                {"xpath": "inet/filter/output", "top": "unit/family"},
            ),
            (
                "filter6_input",
                {"xpath": "inet6/filter/input", "top": "unit/family"},
            ),
            (
                "filter6_output",
                {"xpath": "inet6/filter/output", "top": "unit/family"},
            ),
        ]
    )

    params = to_param_list(module)

    requests = list()
    for param in params:
        # if key doesn't exist in the item, get it from module.params
        for key in param:
            if param.get(key) is None:
                param[key] = module.params[key]

        item = param.copy()
        if not item["ipv4"] and not item["ipv6"]:
            module.fail_json(msg="one of the following is required: ipv4,ipv6")

        want = map_params_to_obj(module, param_to_xpath_map, param=item)
        requests.append(map_obj_to_ele(module, want, top, param=item))

    diff = None
    with locked_config(module):
        for req in requests:
            diff = load_config(module, tostring(req), warnings, action="merge")

        commit = not module.check_mode
        if diff:
            if commit:
                commit_configuration(module)
            else:
                discard_changes(module)
            result["changed"] = True

            if module._diff:
                result["diff"] = {"prepared": diff}

    module.exit_json(**result)
コード例 #12
0
def main():
    """ main entry point for module execution
    """
    element_spec = dict(
        name=dict(),
        mode=dict(default='on', choices=['on', 'off', 'active', 'passive']),
        members=dict(type='list'),
        min_links=dict(type='int'),
        device_count=dict(type='int'),
        description=dict(),
        state=dict(default='present', choices=['present', 'absent', 'up', 'down']),
        active=dict(default=True, type='bool')
    )

    aggregate_spec = deepcopy(element_spec)
    aggregate_spec['name'] = dict(required=True)

    # remove default in aggregate spec, to handle common arguments
    remove_default_spec(aggregate_spec)

    argument_spec = dict(
        aggregate=dict(type='list', elements='dict', options=aggregate_spec),
    )

    argument_spec.update(element_spec)
    argument_spec.update(junos_argument_spec)

    required_one_of = [['name', 'aggregate']]
    mutually_exclusive = [['name', 'aggregate']]

    module = AnsibleModule(argument_spec=argument_spec,
                           supports_check_mode=True,
                           required_one_of=required_one_of,
                           mutually_exclusive=mutually_exclusive)

    warnings = list()
    result = {'changed': False}

    if warnings:
        result['warnings'] = warnings

    params = to_param_list(module)
    requests = list()
    for param in params:
        # if key doesn't exist in the item, get it from module.params
        for key in param:
            if param.get(key) is None:
                param[key] = module.params[key]

        item = param.copy()
        state = item.get('state')
        item['disable'] = True if state == 'down' else False

        if state in ('present', 'up', 'down'):
            item['state'] = 'present'

        else:
            item['disable'] = True

        mode = item.get('mode')
        if mode == 'off':
            item['mode'] = ''
        elif mode == 'on':
            item['mode'] = 'passive'

        configure_lag_params(module, requests, item)
        configure_member_params(module, requests, item)

    diff = None
    with locked_config(module):
        for req in requests:
            diff = load_config(module, tostring(req), warnings, action='merge')

        commit = not module.check_mode
        if diff:
            if commit:
                commit_configuration(module)
            else:
                discard_changes(module)
            result['changed'] = True

            if module._diff:
                result['diff'] = {'prepared': diff}

    module.exit_json(**result)
コード例 #13
0
def main():
    """ main entry point for module execution
    """
    element_spec = dict(address=dict(aliases=['prefix']),
                        next_hop=dict(),
                        preference=dict(type='int',
                                        aliases=['admin_distance']),
                        qualified_next_hop=dict(type='str'),
                        qualified_preference=dict(type='int'),
                        state=dict(default='present',
                                   choices=['present', 'absent']),
                        active=dict(default=True, type='bool'))

    aggregate_spec = deepcopy(element_spec)
    aggregate_spec['address'] = dict(required=True)

    # remove default in aggregate spec, to handle common arguments
    remove_default_spec(aggregate_spec)

    argument_spec = dict(aggregate=dict(type='list',
                                        elements='dict',
                                        options=aggregate_spec),
                         purge=dict(default=False, type='bool'))

    argument_spec.update(element_spec)
    argument_spec.update(junos_argument_spec)

    required_one_of = [['aggregate', 'address']]
    mutually_exclusive = [['aggregate', 'address']]

    module = AnsibleModule(argument_spec=argument_spec,
                           required_one_of=required_one_of,
                           mutually_exclusive=mutually_exclusive,
                           supports_check_mode=True)

    warnings = list()
    result = {'changed': False}

    if warnings:
        result['warnings'] = warnings

    top = 'routing-options/static/route'

    param_to_xpath_map = collections.OrderedDict()
    param_to_xpath_map.update([('address', {
        'xpath': 'name',
        'is_key': True
    }), ('next_hop', 'next-hop'), ('preference', 'preference/metric-value'),
                               ('qualified_next_hop', {
                                   'xpath': 'name',
                                   'top': 'qualified-next-hop'
                               }),
                               ('qualified_preference', {
                                   'xpath': 'preference',
                                   'top': 'qualified-next-hop'
                               })])

    params = to_param_list(module)
    requests = list()

    for param in params:
        # if key doesn't exist in the item, get it from module.params
        for key in param:
            if param.get(key) is None:
                param[key] = module.params[key]

        item = param.copy()
        if item['state'] == 'present':
            if not item['address'] and item['next_hop']:
                module.fail_json(
                    msg=
                    "parameters are required together: ['address', 'next_hop']"
                )

        want = map_params_to_obj(module, param_to_xpath_map, param=item)
        requests.append(map_obj_to_ele(module, want, top, param=item))

    with locked_config(module):
        for req in requests:
            diff = load_config(module, tostring(req), warnings, action='merge')

        commit = not module.check_mode
        if diff:
            if commit:
                commit_configuration(module)
            else:
                discard_changes(module)
            result['changed'] = True

            if module._diff:
                result['diff'] = {'prepared': diff}

    module.exit_json(**result)
def main():
    """ main entry point for module execution
    """
    element_spec = dict(
        name=dict(),
        mode=dict(choices=["access", "trunk"]),
        access_vlan=dict(),
        native_vlan=dict(type="int"),
        trunk_vlans=dict(type="list"),
        unit=dict(default=0, type="int"),
        filter_input=dict(),
        filter_output=dict(),
        description=dict(),
        enhanced_layer=dict(default=True, type="bool"),
        state=dict(default="present", choices=["present", "absent"]),
        active=dict(default=True, type="bool"),
    )

    aggregate_spec = deepcopy(element_spec)
    aggregate_spec["name"] = dict(required=True)

    # remove default in aggregate spec, to handle common arguments
    remove_default_spec(aggregate_spec)

    required_one_of = [["name", "aggregate"]]
    mutually_exclusive = [
        ["name", "aggregate"],
        ["access_vlan", "trunk_vlans"],
        ["access_vlan", "native_vlan"],
    ]

    required_if = [
        ("mode", "access", ("access_vlan", )),
        ("mode", "trunk", ("trunk_vlans", )),
    ]

    argument_spec = dict(aggregate=dict(
        type="list",
        elements="dict",
        options=aggregate_spec,
        mutually_exclusive=mutually_exclusive,
        required_if=required_if,
    ))

    argument_spec.update(element_spec)
    argument_spec.update(junos_argument_spec)

    module = AnsibleModule(
        argument_spec=argument_spec,
        supports_check_mode=True,
        mutually_exclusive=mutually_exclusive,
        required_one_of=required_one_of,
        required_if=required_if,
    )

    warnings = list()
    result = {"changed": False}

    if warnings:
        result["warnings"] = warnings

    top = "interfaces/interface"

    param_to_xpath_map = collections.OrderedDict()
    param_to_xpath_map.update([
        ("name", {
            "xpath": "name",
            "is_key": True
        }),
        ("unit", {
            "xpath": "name",
            "top": "unit",
            "is_key": True
        }),
        (
            "mode",
            {
                "xpath": "interface-mode",
                "top": "unit/family/ethernet-switching",
            },
        ),
        (
            "access_vlan",
            {
                "xpath": "members",
                "top": "unit/family/ethernet-switching/vlan",
            },
        ),
        (
            "trunk_vlans",
            {
                "xpath": "members",
                "top": "unit/family/ethernet-switching/vlan",
            },
        ),
        (
            "filter_input",
            {
                "xpath": "input",
                "top": "unit/family/ethernet-switching/filter",
            },
        ),
        (
            "filter_output",
            {
                "xpath": "output",
                "top": "unit/family/ethernet-switching/filter",
            },
        ),
        ("native_vlan", {
            "xpath": "native-vlan-id"
        }),
        ("description", "description"),
    ])

    params = to_param_list(module)

    requests = list()
    for param in params:
        # if key doesn't exist in the item, get it from module.params
        for key in param:
            if param.get(key) is None:
                param[key] = module.params[key]

        item = param.copy()

        validate_param_values(module, param_to_xpath_map, param=item)

        param_to_xpath_map["mode"]["xpath"] = (
            "interface-mode" if param["enhanced_layer"] else "port-mode")

        want = map_params_to_obj(module, param_to_xpath_map, param=item)
        requests.append(map_obj_to_ele(module, want, top, param=item))

    diff = None
    with locked_config(module):
        for req in requests:
            diff = load_config(module,
                               tostring(req),
                               warnings,
                               action="replace")

        commit = not module.check_mode
        if diff:
            if commit:
                commit_configuration(module)
            else:
                discard_changes(module)
            result["changed"] = True

            if module._diff:
                result["diff"] = {"prepared": diff}

    module.exit_json(**result)
コード例 #15
0
def main():
    """ main entry point for module execution
    """
    element_spec = dict(
        address=dict(aliases=["prefix"]),
        next_hop=dict(),
        preference=dict(type="int", aliases=["admin_distance"]),
        qualified_next_hop=dict(type="str"),
        qualified_preference=dict(type="int"),
        state=dict(default="present", choices=["present", "absent"]),
        active=dict(default=True, type="bool"),
    )

    aggregate_spec = deepcopy(element_spec)
    aggregate_spec["address"] = dict(required=True)

    # remove default in aggregate spec, to handle common arguments
    remove_default_spec(aggregate_spec)

    argument_spec = dict(
        aggregate=dict(type="list", elements="dict", options=aggregate_spec),
        purge=dict(default=False, type="bool"),
    )

    argument_spec.update(element_spec)
    argument_spec.update(junos_argument_spec)

    required_one_of = [["aggregate", "address"]]
    mutually_exclusive = [["aggregate", "address"]]

    module = AnsibleModule(
        argument_spec=argument_spec,
        required_one_of=required_one_of,
        mutually_exclusive=mutually_exclusive,
        supports_check_mode=True,
    )

    warnings = list()
    result = {"changed": False}

    if warnings:
        result["warnings"] = warnings

    top = "routing-options/static/route"

    param_to_xpath_map = collections.OrderedDict()
    param_to_xpath_map.update([
        ("address", {
            "xpath": "name",
            "is_key": True
        }),
        ("next_hop", "next-hop"),
        ("preference", "preference/metric-value"),
        (
            "qualified_next_hop",
            {
                "xpath": "name",
                "top": "qualified-next-hop"
            },
        ),
        (
            "qualified_preference",
            {
                "xpath": "preference",
                "top": "qualified-next-hop"
            },
        ),
    ])

    params = to_param_list(module)
    requests = list()

    for param in params:
        # if key doesn't exist in the item, get it from module.params
        for key in param:
            if param.get(key) is None:
                param[key] = module.params[key]

        item = param.copy()
        if item["state"] == "present":
            if not item["address"] and item["next_hop"]:
                module.fail_json(
                    msg=
                    "parameters are required together: ['address', 'next_hop']"
                )

        want = map_params_to_obj(module, param_to_xpath_map, param=item)
        requests.append(map_obj_to_ele(module, want, top, param=item))

    with locked_config(module):
        for req in requests:
            diff = load_config(module, tostring(req), warnings, action="merge")

        commit = not module.check_mode
        if diff:
            if commit:
                commit_configuration(module)
            else:
                discard_changes(module)
            result["changed"] = True

            if module._diff:
                result["diff"] = {"prepared": diff}

    module.exit_json(**result)
コード例 #16
0
def main():
    """ main entry point for module execution
    """
    backup_spec = dict(filename=dict(), dir_path=dict(type='path'))
    argument_spec = dict(
        lines=dict(aliases=['commands'], type='list'),
        src=dict(type='path'),
        src_format=dict(choices=['xml', 'text', 'set', 'json']),

        # update operations
        update=dict(default='merge',
                    choices=['merge', 'override', 'replace', 'update']),

        # deprecated replace in Ansible 2.3
        replace=dict(type='bool'),
        confirm=dict(default=0, type='int'),
        comment=dict(default=DEFAULT_COMMENT),
        confirm_commit=dict(type='bool', default=False),
        check_commit=dict(type='bool', default=False),

        # config operations
        backup=dict(type='bool', default=False),
        backup_options=dict(type='dict', options=backup_spec),
        rollback=dict(type='int'),
        zeroize=dict(default=False, type='bool'),
    )

    argument_spec.update(junos_argument_spec)

    mutually_exclusive = [('lines', 'src', 'rollback', 'zeroize')]

    module = AnsibleModule(argument_spec=argument_spec,
                           mutually_exclusive=mutually_exclusive,
                           supports_check_mode=True)

    warnings = list()
    check_args(module, warnings)

    candidate = module.params['lines'] or module.params['src']
    commit = not module.check_mode

    result = {'changed': False, 'warnings': warnings}

    if module.params['backup']:
        for conf_format in ['set', 'text']:
            reply = get_configuration(module, format=conf_format)
            match = reply.find('.//configuration-%s' % conf_format)
            if match is not None:
                break
        else:
            module.fail_json(msg='unable to retrieve device configuration')

        result['__backup__'] = match.text.strip()

    rollback_id = module.params['rollback']
    if rollback_id:
        diff = rollback(module, rollback_id)
        if commit:
            kwargs = {'comment': module.params['comment']}
            with locked_config(module):
                load_configuration(module, rollback=rollback_id)
                commit_configuration(module, **kwargs)
            if module._diff:
                result['diff'] = {'prepared': diff}
        result['changed'] = True

    elif module.params['zeroize']:
        if commit:
            zeroize(module)
        result['changed'] = True

    else:
        if candidate:
            with locked_config(module):
                diff = configure_device(module, warnings, candidate)
                if diff:
                    if commit:
                        kwargs = {
                            'comment': module.params['comment'],
                            'check': module.params['check_commit']
                        }

                        confirm = module.params['confirm']
                        if confirm > 0:
                            kwargs.update({
                                'confirm':
                                True,
                                'confirm_timeout':
                                to_text(confirm,
                                        errors='surrogate_then_replace')
                            })
                        commit_configuration(module, **kwargs)
                    else:
                        discard_changes(module)
                    result['changed'] = True

                    if module._diff:
                        result['diff'] = {'prepared': diff}

        elif module.params['check_commit']:
            commit_configuration(module, check=True)

        elif module.params['confirm_commit']:
            with locked_config(module):
                # confirm a previous commit
                commit_configuration(module)

            result['changed'] = True

    module.exit_json(**result)
コード例 #17
0
def main():
    """ main entry point for module execution
    """
    neighbors_spec = dict(host=dict(), port=dict())

    element_spec = dict(
        name=dict(),
        description=dict(),
        enabled=dict(default=True, type="bool"),
        speed=dict(),
        mtu=dict(type="int"),
        duplex=dict(choices=["full", "half", "auto"]),
        tx_rate=dict(),
        rx_rate=dict(),
        neighbors=dict(type="list", elements="dict", options=neighbors_spec),
        delay=dict(default=10, type="int"),
        state=dict(
            default="present", choices=["present", "absent", "up", "down"]
        ),
        active=dict(default=True, type="bool"),
    )

    aggregate_spec = deepcopy(element_spec)
    aggregate_spec["name"] = dict(required=True)

    # remove default in aggregate spec, to handle common arguments
    remove_default_spec(aggregate_spec)

    argument_spec = dict(
        aggregate=dict(type="list", elements="dict", options=aggregate_spec)
    )

    argument_spec.update(element_spec)
    argument_spec.update(junos_argument_spec)

    required_one_of = [["name", "aggregate"]]
    mutually_exclusive = [["name", "aggregate"]]

    module = AnsibleModule(
        argument_spec=argument_spec,
        required_one_of=required_one_of,
        mutually_exclusive=mutually_exclusive,
        supports_check_mode=True,
    )

    warnings = list()
    result = {"changed": False}

    if warnings:
        result["warnings"] = warnings

    top = "interfaces/interface"

    param_to_xpath_map = collections.OrderedDict()
    param_to_xpath_map.update(
        [
            ("name", {"xpath": "name", "is_key": True}),
            ("description", "description"),
            ("speed", "speed"),
            ("mtu", "mtu"),
            ("duplex", "link-mode"),
            ("disable", {"xpath": "disable", "tag_only": True}),
        ]
    )

    choice_to_value_map = {
        "link-mode": {
            "full": "full-duplex",
            "half": "half-duplex",
            "auto": "automatic",
        }
    }

    params = to_param_list(module)

    requests = list()
    for param in params:
        # if key doesn't exist in the item, get it from module.params
        for key in param:
            if param.get(key) is None:
                param[key] = module.params[key]

        item = param.copy()
        state = item.get("state")
        item["disable"] = True if not item.get("enabled") else False

        if state in ("present", "up", "down"):
            item["state"] = "present"

        validate_param_values(module, param_to_xpath_map, param=item)
        want = map_params_to_obj(module, param_to_xpath_map, param=item)
        requests.append(
            map_obj_to_ele(
                module, want, top, value_map=choice_to_value_map, param=item
            )
        )

    diff = None
    with locked_config(module):
        for req in requests:
            diff = load_config(module, tostring(req), warnings, action="merge")

        # issue commit after last configuration change is done
        commit = not module.check_mode
        if diff:
            if commit:
                commit_configuration(module)
            else:
                discard_changes(module)
            result["changed"] = True

            if module._diff:
                result["diff"] = {"prepared": diff}

    failed_conditions = []
    neighbors = None
    for item in params:
        state = item.get("state")
        tx_rate = item.get("tx_rate")
        rx_rate = item.get("rx_rate")
        want_neighbors = item.get("neighbors")

        if (
            state not in ("up", "down")
            and tx_rate is None
            and rx_rate is None
            and want_neighbors is None
        ):
            continue

        element = Element("get-interface-information")
        intf_name = SubElement(element, "interface-name")
        intf_name.text = item.get("name")

        if result["changed"]:
            sleep(item.get("delay"))

        reply = exec_rpc(module, tostring(element), ignore_warning=False)
        if state in ("up", "down"):
            admin_status = reply.xpath(
                "interface-information/physical-interface/admin-status"
            )
            if not admin_status or not conditional(
                state, admin_status[0].text.strip()
            ):
                failed_conditions.append("state " + "eq(%s)" % state)

        if tx_rate:
            output_bps = reply.xpath(
                "interface-information/physical-interface/traffic-statistics/output-bps"
            )
            if not output_bps or not conditional(
                tx_rate, output_bps[0].text.strip(), cast=int
            ):
                failed_conditions.append("tx_rate " + tx_rate)

        if rx_rate:
            input_bps = reply.xpath(
                "interface-information/physical-interface/traffic-statistics/input-bps"
            )
            if not input_bps or not conditional(
                rx_rate, input_bps[0].text.strip(), cast=int
            ):
                failed_conditions.append("rx_rate " + rx_rate)

        if want_neighbors:
            if neighbors is None:
                element = Element("get-lldp-interface-neighbors")
                intf_name = SubElement(element, "interface-device")
                intf_name.text = item.get("name")

                reply = exec_rpc(
                    module, tostring(element), ignore_warning=False
                )
                have_host = [
                    item.text
                    for item in reply.xpath(
                        "lldp-neighbors-information/lldp-neighbor-information/lldp-remote-system-name"
                    )
                ]
                have_port = [
                    item.text
                    for item in reply.xpath(
                        "lldp-neighbors-information/lldp-neighbor-information/lldp-remote-port-id"
                    )
                ]

            for neighbor in want_neighbors:
                host = neighbor.get("host")
                port = neighbor.get("port")
                if host and host not in have_host:
                    failed_conditions.append("host " + host)
                if port and port not in have_port:
                    failed_conditions.append("port " + port)
    if failed_conditions:
        msg = "One or more conditional statements have not been satisfied"
        module.fail_json(msg=msg, failed_conditions=failed_conditions)

    module.exit_json(**result)
コード例 #18
0
def main():
    """ main entry point for module execution
    """
    neighbors_spec = dict(host=dict(), port=dict())

    element_spec = dict(name=dict(),
                        description=dict(),
                        enabled=dict(default=True, type='bool'),
                        speed=dict(),
                        mtu=dict(type='int'),
                        duplex=dict(choices=['full', 'half', 'auto']),
                        tx_rate=dict(),
                        rx_rate=dict(),
                        neighbors=dict(type='list',
                                       elements='dict',
                                       options=neighbors_spec),
                        delay=dict(default=10, type='int'),
                        state=dict(default='present',
                                   choices=['present', 'absent', 'up',
                                            'down']),
                        active=dict(default=True, type='bool'))

    aggregate_spec = deepcopy(element_spec)
    aggregate_spec['name'] = dict(required=True)

    # remove default in aggregate spec, to handle common arguments
    remove_default_spec(aggregate_spec)

    argument_spec = dict(aggregate=dict(type='list',
                                        elements='dict',
                                        options=aggregate_spec), )

    argument_spec.update(element_spec)
    argument_spec.update(junos_argument_spec)

    required_one_of = [['name', 'aggregate']]
    mutually_exclusive = [['name', 'aggregate']]

    module = AnsibleModule(argument_spec=argument_spec,
                           required_one_of=required_one_of,
                           mutually_exclusive=mutually_exclusive,
                           supports_check_mode=True)

    warnings = list()
    result = {'changed': False}

    if warnings:
        result['warnings'] = warnings

    top = 'interfaces/interface'

    param_to_xpath_map = collections.OrderedDict()
    param_to_xpath_map.update([('name', {
        'xpath': 'name',
        'is_key': True
    }), ('description', 'description'), ('speed', 'speed'), ('mtu', 'mtu'),
                               ('duplex', 'link-mode'),
                               ('disable', {
                                   'xpath': 'disable',
                                   'tag_only': True
                               })])

    choice_to_value_map = {
        'link-mode': {
            'full': 'full-duplex',
            'half': 'half-duplex',
            'auto': 'automatic'
        }
    }

    params = to_param_list(module)

    requests = list()
    for param in params:
        # if key doesn't exist in the item, get it from module.params
        for key in param:
            if param.get(key) is None:
                param[key] = module.params[key]

        item = param.copy()
        state = item.get('state')
        item['disable'] = True if not item.get('enabled') else False

        if state in ('present', 'up', 'down'):
            item['state'] = 'present'

        validate_param_values(module, param_to_xpath_map, param=item)
        want = map_params_to_obj(module, param_to_xpath_map, param=item)
        requests.append(
            map_obj_to_ele(module,
                           want,
                           top,
                           value_map=choice_to_value_map,
                           param=item))

    diff = None
    with locked_config(module):
        for req in requests:
            diff = load_config(module, tostring(req), warnings, action='merge')

        # issue commit after last configuration change is done
        commit = not module.check_mode
        if diff:
            if commit:
                commit_configuration(module)
            else:
                discard_changes(module)
            result['changed'] = True

            if module._diff:
                result['diff'] = {'prepared': diff}

    failed_conditions = []
    neighbors = None
    for item in params:
        state = item.get('state')
        tx_rate = item.get('tx_rate')
        rx_rate = item.get('rx_rate')
        want_neighbors = item.get('neighbors')

        if state not in (
                'up', 'down'
        ) and tx_rate is None and rx_rate is None and want_neighbors is None:
            continue

        element = Element('get-interface-information')
        intf_name = SubElement(element, 'interface-name')
        intf_name.text = item.get('name')

        if result['changed']:
            sleep(item.get('delay'))

        reply = exec_rpc(module, tostring(element), ignore_warning=False)
        if state in ('up', 'down'):
            admin_status = reply.xpath(
                'interface-information/physical-interface/admin-status')
            if not admin_status or not conditional(
                    state, admin_status[0].text.strip()):
                failed_conditions.append('state ' + 'eq(%s)' % state)

        if tx_rate:
            output_bps = reply.xpath(
                'interface-information/physical-interface/traffic-statistics/output-bps'
            )
            if not output_bps or not conditional(
                    tx_rate, output_bps[0].text.strip(), cast=int):
                failed_conditions.append('tx_rate ' + tx_rate)

        if rx_rate:
            input_bps = reply.xpath(
                'interface-information/physical-interface/traffic-statistics/input-bps'
            )
            if not input_bps or not conditional(
                    rx_rate, input_bps[0].text.strip(), cast=int):
                failed_conditions.append('rx_rate ' + rx_rate)

        if want_neighbors:
            if neighbors is None:
                element = Element('get-lldp-interface-neighbors')
                intf_name = SubElement(element, 'interface-device')
                intf_name.text = item.get('name')

                reply = exec_rpc(module,
                                 tostring(element),
                                 ignore_warning=False)
                have_host = [
                    item.text for item in reply.xpath(
                        'lldp-neighbors-information/lldp-neighbor-information/lldp-remote-system-name'
                    )
                ]
                have_port = [
                    item.text for item in reply.xpath(
                        'lldp-neighbors-information/lldp-neighbor-information/lldp-remote-port-id'
                    )
                ]

            for neighbor in want_neighbors:
                host = neighbor.get('host')
                port = neighbor.get('port')
                if host and host not in have_host:
                    failed_conditions.append('host ' + host)
                if port and port not in have_port:
                    failed_conditions.append('port ' + port)
    if failed_conditions:
        msg = 'One or more conditional statements have not been satisfied'
        module.fail_json(msg=msg, failed_conditions=failed_conditions)

    module.exit_json(**result)
コード例 #19
0
def main():
    """ main entry point for module execution
    """
    argument_spec = dict(
        name=dict(),
        state=dict(
            default="present",
            choices=["present", "absent", "enabled", "disabled"],
        ),
        active=dict(default=True, type="bool"),
    )

    argument_spec.update(junos_argument_spec)

    module = AnsibleModule(argument_spec=argument_spec,
                           supports_check_mode=True)

    warnings = list()
    result = {"changed": False}

    if warnings:
        result["warnings"] = warnings

    top = "protocols/lldp/interface"

    param_to_xpath_map = collections.OrderedDict()
    param_to_xpath_map.update([
        ("name", {
            "xpath": "name",
            "is_key": True
        }),
        ("disable", {
            "xpath": "disable",
            "tag_only": True
        }),
    ])

    item = module.params.copy()
    state = item.get("state")
    item["disable"] = True if state in ("disabled", "absent") else False

    if state in ("enabled", "disabled"):
        item["state"] = "present"

    want = map_params_to_obj(module, param_to_xpath_map, param=item)
    ele = map_obj_to_ele(module, want, top, param=item)

    with locked_config(module):
        diff = load_config(module, tostring(ele), warnings, action="merge")

        commit = not module.check_mode
        if diff:
            if commit:
                commit_configuration(module)
            else:
                discard_changes(module)
            result["changed"] = True

            if module._diff:
                result["diff"] = {"prepared": diff}

    module.exit_json(**result)
コード例 #20
0
def main():
    """ main entry point for module execution
    """
    element_spec = dict(dest=dict(choices=['console', 'host', 'file', 'user']),
                        name=dict(),
                        facility=dict(),
                        level=dict(),
                        rotate_frequency=dict(type='int'),
                        size=dict(type='int'),
                        files=dict(type='int'),
                        src_addr=dict(),
                        state=dict(default='present',
                                   choices=['present', 'absent']),
                        active=dict(default=True, type='bool'))

    aggregate_spec = deepcopy(element_spec)

    # remove default in aggregate spec, to handle common arguments
    remove_default_spec(aggregate_spec)

    argument_spec = dict(aggregate=dict(type='list',
                                        elements='dict',
                                        options=aggregate_spec), )

    argument_spec.update(element_spec)
    argument_spec.update(junos_argument_spec)

    required_if = [('dest', 'host', ['name', 'facility', 'level']),
                   ('dest', 'file', ['name', 'facility', 'level']),
                   ('dest', 'user', ['name', 'facility', 'level']),
                   ('dest', 'console', ['facility', 'level'])]

    module = AnsibleModule(argument_spec=argument_spec,
                           required_if=required_if,
                           supports_check_mode=True)

    warnings = list()
    result = {'changed': False}

    if warnings:
        result['warnings'] = warnings

    params = to_param_list(module)

    requests = list()
    for param in params:
        # if key doesn't exist in the item, get it from module.params
        for key in param:
            if param.get(key) is None:
                param[key] = module.params[key]

        module._check_required_if(required_if, param)

        item = param.copy()
        dest = item.get('dest')
        if dest == 'console' and item.get('name'):
            module.fail_json(msg="%s and %s are mutually exclusive" %
                             ('console', 'name'))

        top = 'system/syslog'
        is_facility_key = False
        field_top = None
        if dest:
            if dest == 'console':
                field_top = dest
                is_facility_key = True
            else:
                field_top = dest + '/contents'
                is_facility_key = False

        param_to_xpath_map = collections.OrderedDict()
        param_to_xpath_map.update([
            ('name', {
                'xpath': 'name',
                'is_key': True,
                'top': dest
            }),
            ('facility', {
                'xpath': 'name',
                'is_key': is_facility_key,
                'top': field_top
            }),
            ('size', {
                'xpath': 'size',
                'leaf_only': True,
                'is_key': True,
                'top': 'archive'
            }),
            ('files', {
                'xpath': 'files',
                'leaf_only': True,
                'is_key': True,
                'top': 'archive'
            }),
            ('rotate_frequency', {
                'xpath': 'log-rotate-frequency',
                'leaf_only': True
            }),
        ])

        if item.get('level'):
            param_to_xpath_map['level'] = {
                'xpath': item.get('level'),
                'tag_only': True,
                'top': field_top
            }

        validate_param_values(module, param_to_xpath_map, param=item)

        want = map_params_to_obj(module, param_to_xpath_map, param=item)
        requests.append(map_obj_to_ele(module, want, top, param=item))

    diff = None
    with locked_config(module):
        for req in requests:
            diff = load_config(module, tostring(req), warnings, action='merge')

        commit = not module.check_mode
        if diff:
            if commit:
                commit_configuration(module)
            else:
                discard_changes(module)
            result['changed'] = True

            if module._diff:
                result['diff'] = {'prepared': diff}

    module.exit_json(**result)
コード例 #21
0
def main():
    """ main entry point for module execution
    """
    element_spec = dict(
        dest=dict(choices=["console", "host", "file", "user"]),
        name=dict(),
        facility=dict(),
        level=dict(),
        rotate_frequency=dict(type="int"),
        size=dict(type="int"),
        files=dict(type="int"),
        src_addr=dict(),
        state=dict(default="present", choices=["present", "absent"]),
        active=dict(default=True, type="bool"),
    )

    aggregate_spec = deepcopy(element_spec)

    # remove default in aggregate spec, to handle common arguments
    remove_default_spec(aggregate_spec)

    argument_spec = dict(
        aggregate=dict(type="list", elements="dict", options=aggregate_spec)
    )

    argument_spec.update(element_spec)
    argument_spec.update(junos_argument_spec)

    required_if = [
        ("dest", "host", ["name", "facility", "level"]),
        ("dest", "file", ["name", "facility", "level"]),
        ("dest", "user", ["name", "facility", "level"]),
        ("dest", "console", ["facility", "level"]),
    ]

    module = AnsibleModule(
        argument_spec=argument_spec,
        required_if=required_if,
        supports_check_mode=True,
    )

    warnings = list()
    result = {"changed": False}

    if warnings:
        result["warnings"] = warnings

    params = to_param_list(module)

    requests = list()
    for param in params:
        # if key doesn't exist in the item, get it from module.params
        for key in param:
            if param.get(key) is None:
                param[key] = module.params[key]

        module._check_required_if(required_if, param)

        item = param.copy()
        dest = item.get("dest")
        if dest == "console" and item.get("name"):
            module.fail_json(
                msg="%s and %s are mutually exclusive" % ("console", "name")
            )

        top = "system/syslog"
        is_facility_key = False
        field_top = None
        if dest:
            if dest == "console":
                field_top = dest
                is_facility_key = True
            else:
                field_top = dest + "/contents"
                is_facility_key = False

        param_to_xpath_map = collections.OrderedDict()
        param_to_xpath_map.update(
            [
                ("name", {"xpath": "name", "is_key": True, "top": dest}),
                (
                    "facility",
                    {
                        "xpath": "name",
                        "is_key": is_facility_key,
                        "top": field_top,
                    },
                ),
                (
                    "size",
                    {
                        "xpath": "size",
                        "leaf_only": True,
                        "is_key": True,
                        "top": "archive",
                    },
                ),
                (
                    "files",
                    {
                        "xpath": "files",
                        "leaf_only": True,
                        "is_key": True,
                        "top": "archive",
                    },
                ),
                (
                    "rotate_frequency",
                    {"xpath": "log-rotate-frequency", "leaf_only": True},
                ),
            ]
        )

        if item.get("level"):
            param_to_xpath_map["level"] = {
                "xpath": item.get("level"),
                "tag_only": True,
                "top": field_top,
            }

        validate_param_values(module, param_to_xpath_map, param=item)

        want = map_params_to_obj(module, param_to_xpath_map, param=item)
        requests.append(map_obj_to_ele(module, want, top, param=item))

    diff = None
    with locked_config(module):
        for req in requests:
            diff = load_config(module, tostring(req), warnings, action="merge")

        commit = not module.check_mode
        if diff:
            if commit:
                commit_configuration(module)
            else:
                discard_changes(module)
            result["changed"] = True

            if module._diff:
                result["diff"] = {"prepared": diff}

    module.exit_json(**result)
コード例 #22
0
def main():
    """ main entry point for module execution
    """
    element_spec = dict(
        name=dict(),
        mode=dict(default="on", choices=["on", "off", "active", "passive"]),
        members=dict(type="list"),
        min_links=dict(type="int"),
        device_count=dict(type="int"),
        description=dict(),
        state=dict(default="present",
                   choices=["present", "absent", "up", "down"]),
        active=dict(default=True, type="bool"),
    )

    aggregate_spec = deepcopy(element_spec)
    aggregate_spec["name"] = dict(required=True)

    # remove default in aggregate spec, to handle common arguments
    remove_default_spec(aggregate_spec)

    argument_spec = dict(
        aggregate=dict(type="list", elements="dict", options=aggregate_spec))

    argument_spec.update(element_spec)
    argument_spec.update(junos_argument_spec)

    required_one_of = [["name", "aggregate"]]
    mutually_exclusive = [["name", "aggregate"]]

    module = AnsibleModule(
        argument_spec=argument_spec,
        supports_check_mode=True,
        required_one_of=required_one_of,
        mutually_exclusive=mutually_exclusive,
    )

    warnings = list()
    result = {"changed": False}

    if warnings:
        result["warnings"] = warnings

    params = to_param_list(module)
    requests = list()
    for param in params:
        # if key doesn't exist in the item, get it from module.params
        for key in param:
            if param.get(key) is None:
                param[key] = module.params[key]

        item = param.copy()
        state = item.get("state")
        item["disable"] = True if state == "down" else False

        if state in ("present", "up", "down"):
            item["state"] = "present"

        else:
            item["disable"] = True

        mode = item.get("mode")
        if mode == "off":
            item["mode"] = ""
        elif mode == "on":
            item["mode"] = "passive"

        configure_lag_params(module, requests, item)
        configure_member_params(module, requests, item)

    diff = None
    with locked_config(module):
        for req in requests:
            diff = load_config(module, tostring(req), warnings, action="merge")

        commit = not module.check_mode
        if diff:
            if commit:
                commit_configuration(module)
            else:
                discard_changes(module)
            result["changed"] = True

            if module._diff:
                result["diff"] = {"prepared": diff}

    module.exit_json(**result)
コード例 #23
0
def main():
    """ main entry point for module execution
    """
    argument_spec = dict(
        hostname=dict(),
        domain_name=dict(),
        domain_search=dict(type="list"),
        name_servers=dict(type="list"),
        state=dict(choices=["present", "absent"], default="present"),
        active=dict(default=True, type="bool"),
    )

    argument_spec.update(junos_argument_spec)

    params = ["hostname", "domain_name", "domain_search", "name_servers"]
    required_if = [
        ("state", "present", params, True),
        ("state", "absent", params, True),
        ("state", "active", params, True),
        ("state", "suspend", params, True),
    ]

    module = AnsibleModule(
        argument_spec=argument_spec,
        required_if=required_if,
        supports_check_mode=True,
    )

    warnings = list()
    result = {"changed": False}

    if warnings:
        result["warnings"] = warnings

    top = "system"

    param_to_xpath_map = collections.OrderedDict()
    param_to_xpath_map.update([
        ("hostname", {
            "xpath": "host-name",
            "leaf_only": True
        }),
        ("domain_name", {
            "xpath": "domain-name",
            "leaf_only": True
        }),
        (
            "domain_search",
            {
                "xpath": "domain-search",
                "leaf_only": True,
                "value_req": True,
            },
        ),
        ("name_servers", {
            "xpath": "name-server/name",
            "is_key": True
        }),
    ])

    validate_param_values(module, param_to_xpath_map)

    want = map_params_to_obj(module, param_to_xpath_map)
    ele = map_obj_to_ele(module, want, top)

    with locked_config(module):
        diff = load_config(module, tostring(ele), warnings, action="merge")

        commit = not module.check_mode
        if diff:
            if commit:
                commit_configuration(module)
            else:
                discard_changes(module)
            result["changed"] = True

            if module._diff:
                result["diff"] = {"prepared": diff}

    module.exit_json(**result)
コード例 #24
0
def main():
    """ main entry point for module execution
    """
    element_spec = dict(name=dict(),
                        description=dict(),
                        rd=dict(type='list'),
                        interfaces=dict(type='list'),
                        target=dict(type='list'),
                        state=dict(default='present',
                                   choices=['present', 'absent']),
                        active=dict(default=True, type='bool'),
                        table_label=dict(default=True, type='bool'))

    aggregate_spec = deepcopy(element_spec)
    aggregate_spec['name'] = dict(required=True)

    # remove default in aggregate spec, to handle common arguments
    remove_default_spec(aggregate_spec)

    argument_spec = dict(aggregate=dict(type='list',
                                        elements='dict',
                                        options=aggregate_spec), )

    argument_spec.update(element_spec)
    argument_spec.update(junos_argument_spec)

    required_one_of = [['aggregate', 'name']]
    mutually_exclusive = [['aggregate', 'name']]

    module = AnsibleModule(argument_spec=argument_spec,
                           supports_check_mode=True,
                           required_one_of=required_one_of,
                           mutually_exclusive=mutually_exclusive)

    warnings = list()
    result = {'changed': False}

    if warnings:
        result['warnings'] = warnings

    top = 'routing-instances/instance'

    param_to_xpath_map = collections.OrderedDict()
    param_to_xpath_map.update([
        ('name', {
            'xpath': 'name',
            'is_key': True
        }),
        ('description', 'description'),
        ('type', 'instance-type'),
        ('rd', 'route-distinguisher/rd-type'),
        ('interfaces', 'interface/name'),
        ('target', 'vrf-target/community'),
        ('table_label', {
            'xpath': 'vrf-table-label',
            'tag_only': True
        }),
    ])

    params = to_param_list(module)
    requests = list()

    for param in params:
        # if key doesn't exist in the item, get it from module.params
        for key in param:
            if param.get(key) is None:
                param[key] = module.params[key]

        item = param.copy()
        item['type'] = 'vrf'

        want = map_params_to_obj(module, param_to_xpath_map, param=item)
        requests.append(map_obj_to_ele(module, want, top, param=item))

    with locked_config(module):
        for req in requests:
            diff = load_config(module, tostring(req), warnings, action='merge')

        commit = not module.check_mode
        if diff:
            if commit:
                commit_configuration(module)
            else:
                discard_changes(module)
            result['changed'] = True

            if module._diff:
                result['diff'] = {'prepared': diff}

    module.exit_json(**result)
コード例 #25
0
def main():
    """ main entry point for module execution
    """
    backup_spec = dict(filename=dict(), dir_path=dict(type="path"))
    argument_spec = dict(
        lines=dict(type="list"),
        src=dict(type="path"),
        src_format=dict(choices=["xml", "text", "set", "json"]),
        # update operations
        update=dict(
            default="merge", choices=["merge", "override", "replace", "update"]
        ),
        # deprecated replace in Ansible 2.3
        replace=dict(type="bool"),
        confirm=dict(default=0, type="int"),
        comment=dict(default=DEFAULT_COMMENT),
        confirm_commit=dict(type="bool", default=False),
        check_commit=dict(type="bool", default=False),
        # config operations
        backup=dict(type="bool", default=False),
        backup_options=dict(type="dict", options=backup_spec),
        rollback=dict(type="int"),
        zeroize=dict(default=False, type="bool"),
    )

    argument_spec.update(junos_argument_spec)

    mutually_exclusive = [("lines", "src", "rollback", "zeroize")]

    module = AnsibleModule(
        argument_spec=argument_spec,
        mutually_exclusive=mutually_exclusive,
        supports_check_mode=True,
    )

    warnings = list()
    check_args(module, warnings)

    candidate = module.params["lines"] or module.params["src"]
    commit = not module.check_mode

    result = {"changed": False, "warnings": warnings}

    if module.params["backup"]:
        for conf_format in ["set", "text"]:
            reply = get_configuration(module, format=conf_format)
            match = reply.find(".//configuration-%s" % conf_format)
            if match is not None:
                break
        else:
            module.fail_json(msg="unable to retrieve device configuration")

        result["__backup__"] = match.text.strip()

    rollback_id = module.params["rollback"]
    if rollback_id:
        diff = rollback(module, rollback_id)
        if commit:
            kwargs = {"comment": module.params["comment"]}
            with locked_config(module):
                load_configuration(module, rollback=rollback_id)
                commit_configuration(module, **kwargs)
            if module._diff:
                result["diff"] = {"prepared": diff}
        result["changed"] = True

    elif module.params["zeroize"]:
        if commit:
            zeroize(module)
        result["changed"] = True

    else:
        if candidate:
            with locked_config(module):
                diff = configure_device(module, warnings, candidate)
                if diff:
                    if commit:
                        kwargs = {"comment": module.params["comment"]}

                        confirm = module.params["confirm"]
                        if confirm > 0:
                            kwargs.update(
                                {
                                    "confirm": True,
                                    "confirm_timeout": to_text(
                                        confirm,
                                        errors="surrogate_then_replace",
                                    ),
                                }
                            )
                        commit_configuration(module, **kwargs)
                    else:
                        discard_changes(module)
                    result["changed"] = True

                    if module._diff:
                        result["diff"] = {"prepared": diff}

        elif module.params["check_commit"]:
            commit_configuration(module, check=True)

        elif module.params["confirm_commit"]:
            with locked_config(module):
                # confirm a previous commit
                commit_configuration(module)

            result["changed"] = True

    module.exit_json(**result)