def main():
module = AnsibleModule(
argument_spec=dict(
name=dict(required=True),
link_type=dict(required=True,
choices=['access', 'trunk']),
pvid=dict(type='str'),
permitted_vlans=dict(type='str'),
state=dict(choices=['present', 'default'],
default='present'),
hostname=dict(required=True),
username=dict(required=True),
password=dict(required=True),
port=dict(type='int', default=830)
),
supports_check_mode=True
)
if not HAS_PYHP:
safe_fail(module,
msg='There was a problem loading from the pyhpecw7 module')
filtered_keys = ('state', 'hostname', 'username', 'password',
'port', 'CHECKMODE', 'name')
hostname = socket.gethostbyname(module.params['hostname'])
username = module.params['username']
password = module.params['password']
port = module.params['port']
device = HPCOM7(host=hostname, username=username,
password=password, port=port)
name = module.params['name']
state = module.params['state']
changed = False
if state == 'present':
if module.params.get('link_type') == 'access':
if module.params.get('permitted_vlans'):
safe_fail(module,
msg='Access interfaces don\'t take'
+ ' permitted vlan lists.')
try:
device.open()
except ConnectionError as e:
safe_fail(module, device, msg=str(e),
descr='Error opening connection to device.')
# Make sure vlan exists
pvid = module.params.get('pvid')
if pvid and state != 'default':
try:
vlan = Vlan(device, pvid)
if not vlan.get_config():
safe_fail(module, device,
msg='Vlan {0} does not exist,'.format(pvid)
+ ' Use vlan module to create it.')
except PYHPError as e:
module.fail_json(msg=str(e),
descr='Error initializing Vlan object'
+ ' or getting current vlan config.')
# Make sure port is not part of port channel
try:
portchannel = Portchannel(device, '99', 'bridged')
pc_list = portchannel.get_all_members()
except PYHPError as e:
module.fail_json(msg=str(e),
descr='Error getting port channel information.')
if name in pc_list:
safe_fail(module, device,
msg='{0} is currently part of a port channel.'.format(name)
+ ' Changes should be made to the port channel interface.')
try:
switchport = Switchport(device, name)
except PYHPError as e:
safe_fail(module, device, msg=str(e),
descr='Error initialzing Switchport object.')
# Make sure interface exists and is ethernet
if not switchport.interface.iface_exists:
safe_fail(module, device,
msg='{0} doesn\'t exist on the device.'.format(name))
# Make sure interface is in bridged mode
try:
if_info = switchport.interface.get_config()
except PYHPError as e:
safe_fail(module, device, msg=str(e),
descr='Error getting current interface config.')
if if_info.get('type') != 'bridged':
safe_fail(module, device, msg='{0} is not in bridged mode.'.format(name)
+ ' Please use the interface module to change that.')
try:
existing = switchport.get_config()
except PYHPError as e:
safe_fail(module, device, msg=str(e),
descr='Error getting switchpot config.')
proposed = dict((k, v) for k, v in module.params.items()
if v is not None and k not in filtered_keys)
if state == 'present':
delta = dict(set(proposed.items()) - set(existing.items()))
if delta:
delta['link_type'] = proposed.get('link_type')
pvid = proposed.get('pvid')
if pvid:
delta['pvid'] = pvid
switchport.build(stage=True, **delta)
elif state == 'default':
defaults = switchport.get_default()
delta = dict(set(existing.items()) - set(defaults.items()))
if delta:
switchport.default(stage=True)
commands = None
end_state = existing
if device.staged:
commands = device.staged_to_string()
if module.check_mode:
safe_exit(module, device, changed=True,
commands=commands)
else:
try:
device.execute_staged()
end_state = switchport.get_config()
except PYHPError as e:
safe_fail(module, device, msg=str(e),
descr='Error during command execution.')
changed = True
results = {}
results['proposed'] = proposed
results['existing'] = existing
results['state'] = state
results['commands'] = commands
results['changed'] = changed
results['end_state'] = end_state
safe_exit(module, device, **results)
def setUp(self, mock_device):
self.device = mock_device
self.rpc = Portchannel(self.device, R_GROUP_ID, 'routed')
self.bpc = Portchannel(self.device, B_GROUP_ID, 'bridged')
def main():
module = AnsibleModule(argument_spec=dict(
group=dict(required=True, type='str'),
members=dict(required=False, type='list'),
mode=dict(required=False, choices=['static', 'dynamic']),
type=dict(required=True, choices=['bridged', 'routed']),
lacp_mode=dict(required=False, choices=['active', 'passive']),
lacp_edge=dict(required=False, choices=['enabled', 'disabled']),
min_ports=dict(required=False, type='str'),
max_ports=dict(required=False, type='str'),
state=dict(choices=['present', 'absent'], default='present'),
port=dict(default=830, type='int'),
hostname=dict(required=True),
username=dict(required=True),
password=dict(required=True),
),
supports_check_mode=True)
if not HAS_PYHP:
module.fail_json(msg='There was a problem loading from the pyhpecw7 ' +
'module.',
error=str(ie))
username = module.params['username']
password = module.params['password']
port = module.params['port']
hostname = socket.gethostbyname(module.params['hostname'])
device_args = dict(host=hostname,
username=username,
password=password,
port=port)
device = HPCOM7(**device_args)
groupid = module.params['group']
members = module.params['members']
lacp_mode = module.params['lacp_mode']
mode = module.params['mode']
lacp_edge = module.params['lacp_edge']
min_ports = module.params['min_ports']
max_ports = module.params['max_ports']
pc_type = module.params['type']
state = module.params['state']
if members:
if not isinstance(members, list):
module.fail_json(
msg='members param must be a list. YAML format ' +
'\nmust be used within the playbook')
if state == 'present' and not members:
module.fail_json(msg='members param required when state=present')
if mode == 'static' and lacp_mode:
lacp_mode = None
lacp_edge = None
changed = False
args = dict(groupid=groupid,
lacp_edge=lacp_edge,
mode=mode,
min_ports=min_ports,
max_ports=max_ports,
lacp_mode=lacp_mode)
proposed = dict((k, v) for k, v in args.iteritems() if v is not None)
try:
device.open()
except ConnectionError as e:
safe_fail(module,
device,
msg=str(e),
descr='error connecting to device')
try:
portchannel = Portchannel(device, groupid, pc_type)
portchannel.param_check(members=members, **proposed)
existing = portchannel.get_config()
except InvalidPortType as ipte:
safe_fail(module, device, msg=str(ipte))
except AggregationGroupError as age:
safe_fail(module, device, msg=str(age))
except PYHPError as e:
safe_fail(module, device, msg=str(e))
if 'members' in existing.keys():
existing_members = existing.pop('members')
else:
existing_members = []
if state == 'present':
delta = get_delta(existing, proposed, existing_members, members,
lacp_mode, portchannel)
if delta:
# delta['groupid'] = groupid
portchannel.build(stage=True, **delta)
elif state == 'absent':
if existing:
portchannel.remove(stage=True)
commands = None
end_state = existing
if device.staged:
commands = device.staged_to_string()
if module.check_mode:
safe_exit(module, device, changed=True, commands=commands)
else:
try:
device.execute_staged()
end_state = portchannel.get_config()
except PYHPError as e:
safe_fail(module,
device,
msg=str(e),
descr='error during execution')
changed = True
proposed['members'] = members
proposed['type'] = pc_type
results = {}
results['proposed'] = proposed
results['existing'] = existing
results['state'] = state
results['commands'] = commands
results['changed'] = changed
results['end_state'] = end_state
safe_exit(module, device, **results)
