def _handle_absent_interface(self, name, config):
full_interface_state = get_interface_state(self.interfaces, name)
if full_interface_state:
interface_state = {
"name": name,
"type": full_interface_state["type"],
"ipv4": full_interface_state.get("ipv4", {}),
"ipv6": full_interface_state.get("ipv6", {}),
}
for family in ("ipv4", "ipv6"):
ipconfig = interface_state.setdefault(family, {})
addresses = config.get(family)
if addresses:
ipconfig.update(remove_addresses(ipconfig, addresses))
# handle state:absent, ipv4:None, ipv6:None
elif not (config.get("ipv4") or config.get("ipv6")):
ipconfig.update(set_addresses(ipconfig, []))
# if no ip addresses remain, disable the family
if not ipconfig.get("address"):
# FIXME: Disabling ipv6 is not supported in nmstate
if family != "ipv6":
ipconfig["enabled"] = False
return interface_state
def _handle_present_interface(self, name, config):
full_interface_state = get_interface_state(self.interfaces, name)
if not full_interface_state:
self.module.fail_json(msg='Interface "%s" not found' % (name, ),
**self.result)
interface_state = {
"name": name,
"type": full_interface_state["type"],
"ipv4": full_interface_state.get("ipv4", {}),
"ipv6": full_interface_state.get("ipv6", {}),
"state": "up",
}
for family in ("ipv4", "ipv6"):
ipconfig = interface_state[family]
addresses = config.get(family, [])
if self.params["purge"]:
updated_ipconfig = set_addresses(ipconfig, addresses)
interface_state[family] = updated_ipconfig
elif addresses:
updated_ipconfig = add_addresses(ipconfig, addresses)
interface_state[family] = updated_ipconfig
return interface_state
def run(self):
name = self.params["name"]
full_interface_state = get_interface_state(self.interfaces, name)
interface_state = {"name": name, "type": full_interface_state["type"]}
state = self.params["state"]
# "present" does not need to be mentioned in the state sent to nmstate
if state != "present":
interface_state["state"] = state
if self.params["mtu"]:
interface_state["mtu"] = int(self.params["mtu"])
ethernet_state = {}
if self.params["duplex"]:
ethernet_state["auto-negotiation"] = self.params["duplex"] == "auto"
if self.params["duplex"] and self.params["duplex"] != "auto":
ethernet_state["duplex"] = self.params["duplex"]
if self.params["speed"]:
ethernet_state["speed"] = int(self.params["speed"])
if ethernet_state:
interface_state["ethernet"] = ethernet_state
if self.params["description"] is not None:
interface_state["description"] = self.params["description"]
self.apply_partial_interface_state(interface_state)
def get_members(self):
members = self.params["members"]
if not isinstance(members, list):
members = [members]
# Fail when member state is missing
if self.params["state"] in ["up", "present"]:
missing = []
for member in members:
member_state = get_interface_state(
self.previous_state["interfaces"], member)
if not member_state:
missing.append(member)
if missing:
self.module.fail_json(
msg="Did not find specified members in network state: " +
", ".join(missing),
**self.result)
return members
def run_module():
element_spec = dict(
members=dict(type='list'),
min_links=dict(type='int'),
# net_linkagg only knows on, active and passive
# on and active is 802.3ad on Linux, passive is not supported
mode=dict(choices=[
'on', 'active', 'passive', 'balance-rr', 'active-backup',
'balance-xor', 'broadcast', '802.3ad', 'balance-tlb', 'balance-alb'
],
default='on'),
name=dict(),
state=dict(default='present',
choices=['present', 'absent', 'up', 'down']))
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),
purge=dict(default=False, type='bool'),
# not in net_* specification
debug=dict(default=False, type='bool'),
)
argument_spec.update(element_spec)
required_one_of = [['name', 'aggregate']]
mutually_exclusive = [['name', 'aggregate']]
result = dict(changed=False, )
module = AnsibleModule(argument_spec=argument_spec,
required_one_of=required_one_of,
mutually_exclusive=mutually_exclusive,
supports_check_mode=True)
if module.params['aggregate']:
module.fail_json(msg='Aggregate not yet supported', **result)
previous_state = netinfo.show()
members = module.params['members']
if not isinstance(members, list):
members = [members]
# Fail when member state is missing
if module.params['state'] in ['up', 'present']:
missing = []
for member in members:
member_state = get_interface_state(previous_state['interfaces'],
member)
if not member_state:
missing.append(member)
if missing:
module.fail_json(msg='Did not find specified members in network '
'state: ' + ', '.join(missing),
**result)
mode = module.params['mode']
if mode in ['on', 'active']:
mode = '802.3ad'
elif mode in ['passive']:
# passive mode is not supported on Linux:
# noqa:
# https://access.redhat.com/documentation/en-us/red_hat_enterprise_linux/7/html/networking_guide/sec-comparison_of_network_teaming_to_bonding
module.fail_json(msg='passive mode is not supported on Linux',
**result)
link_aggregation = {
'mode': mode,
'options': {}, # FIXME: add support for options?
'slaves': members,
}
interface_state = {
'name': module.params['name'],
'state': module.params['state'],
'type': 'bond',
'link-aggregation': link_aggregation,
}
interfaces = []
interfaces.append(interface_state)
new_partial_state = {'interfaces': interfaces}
if module.params.get('debug'):
result['previous_state'] = previous_state
result['new_partial_state'] = new_partial_state
result['debugfile'] = write_debug_state(MODULE_NAME, new_partial_state)
if module.check_mode:
new_full_state = deepcopy(previous_state)
new_full_state.update(new_partial_state)
result['state'] = new_full_state
# TODO: maybe compare only the state of the defined interfaces
if previous_state != new_full_state:
result['changed'] = True
module.exit_json(**result)
else:
netapplier.apply(new_partial_state)
current_state = netinfo.show()
if current_state != previous_state:
result['changed'] = True
result['state'] = current_state
module.exit_json(**result)
def run_module():
element_spec = dict(name=dict(),
ipv4=dict(),
ipv6=dict(),
state=dict(default='present',
choices=['present', 'absent']))
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),
purge=dict(default=False, type='bool'),
# not in net_* specification
debug=dict(default=False, type='bool'),
)
argument_spec.update(element_spec)
required_one_of = [['name', 'aggregate']]
mutually_exclusive = [['name', 'aggregate']]
result = dict(changed=False)
module = AnsibleModule(argument_spec=argument_spec,
required_one_of=required_one_of,
mutually_exclusive=mutually_exclusive,
supports_check_mode=True)
if module.params['aggregate']:
# FIXME impelement aggregate
module.fail_json(msg='Aggregate not yet supported', **result)
previous_state = netinfo.show()
interfaces = deepcopy(previous_state['interfaces'])
name = module.params['name']
interface_state = get_interface_state(interfaces, name)
if module.params['state'] == 'present':
if not interface_state:
module.fail_json(msg='Interface "%s" not found' % (name, ),
**result)
interface_state = set_ipv4_addresses(interface_state,
module.params['ipv4'],
purge=module.params['purge'])
elif module.params['state'] == 'absent':
if interface_state:
if module.params['ipv4']:
interface_state = remove_ipv4_address(interface_state,
module.params['ipv4'])
else:
ipconfig = interface_state.setdefault('ipv4', {})
ipconfig['enabled'] = False
# assume success when interface to configure is not present
interfaces = [interface_state]
new_partial_state = {'interfaces': interfaces}
if module.params.get('debug'):
result['previous_state'] = previous_state
result['new_partial_state'] = new_partial_state
result['debugfile'] = write_debug_state(MODULE_NAME, new_partial_state)
if module.check_mode:
new_full_state = deepcopy(previous_state)
new_full_state.update(new_partial_state)
result['state'] = new_full_state
# TODO: maybe compare only the state of the defined interfaces
if previous_state != new_full_state:
result['changed'] = True
module.exit_json(**result)
else:
netapplier.apply(new_partial_state)
current_state = netinfo.show()
if current_state != previous_state:
result['changed'] = True
result['state'] = current_state
module.exit_json(**result)