def main():
module = AnsibleModule(
argument_spec=dict(
file=dict(required=True),
local_path=dict(),
hostname=dict(required=True),
username=dict(required=True),
password=dict(required=True),
port=dict(type='int', default=830)
),
supports_check_mode=False
)
if not HAS_PYHP:
safe_fail(module, msg='There was a problem loading from the pyhpecw7 '
+ 'module.', error=str(ie))
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, timeout=600)
src = module.params.get('file')
dst = module.params.get('local_path')
proto = "sftp"
changed = False
try:
device.open()
except ConnectionError as e:
safe_fail(module, device, msg=str(e),
descr='Error opening connection to device.')
try:
file_download = FileDownload(device, proto, src, dst)
file_download.transfer_file()
changed = True
except PYHPError as fe:
safe_fail(module, device, msg=str(fe),
descr='Error transferring file.')
results = {}
results['source_file'] = file_download.src
results['destination_file'] = file_download.dst
results['changed'] = changed
safe_exit(module, device, **results)
def main():
module = AnsibleModule(argument_spec=dict(
neigh_type=dict(default='lldp', choices=['cdp', 'lldp']),
port=dict(default=830, type='int'),
hostname=dict(required=True),
username=dict(required=True),
password=dict(required=True),
),
supports_check_mode=False)
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)
neigh_type = module.params['neigh_type']
try:
device.open()
except ConnectionError as e:
safe_fail(module,
device,
msg=str(e),
descr='error opening conn to device')
try:
neighbors = Neighbors(device)
except PYHPError as e:
safe_fail(module,
device,
msg=str(e),
descr='error getting neighbor info')
response = getattr(neighbors, neigh_type)
results = dict(neighbors=response)
safe_exit(module, device, **results)
def main():
module = AnsibleModule(
argument_spec=dict(
host=dict(required=True, type='str'),
vrf=dict(required=False, type='str'),
v6=dict(default=False, choices=BOOLEANS, type='bool'),
port=dict(default=830, type='int'),
hostname=dict(required=True),
username=dict(required=True),
password=dict(required=True),
),
supports_check_mode=False
)
if not HAS_PYHP:
safe_fail(module, 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)
host = module.params['host']
vrf = module.params['vrf']
v6 = module.params['v6']
try:
device.open()
except ConnectionError as e:
safe_fail(module, device, msg=str(e),
descr='error connecting to device')
try:
ping = Ping(device, host, vrf=vrf, v6=v6)
except InvalidIPAddress as iie:
safe_fail(module, device, msg=str(iie))
except PYHPError as e:
safe_fail(module, device, msg=str(e))
response = ping.response
results = dict(response=response)
safe_exit(module, device, **results)
def main():
module = AnsibleModule(
argument_spec=dict(
port=dict(default=830, type='int'),
hostname=dict(required=True),
username=dict(required=True),
password=dict(required=True),
),
supports_check_mode=False
)
if not HAS_PYHP:
safe_fail(module, 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)
try:
device.open()
except ConnectionError as e:
safe_fail(module, device, msg=str(e),
descr='error opening connection to device')
try:
facts = Facts(device)
except PYHPError as e:
safe_fail(module, device, msg=str(e),
descr='error collecting facts')
hpfacts = facts.facts
safe_exit(module, device, ansible_facts=hpfacts)
#encoding=utf-8
from pyhpecw7.features import mac
from pyhpecw7.comware import HPCOM7
username = '******'
password = '******'
port = 830
hostname = '16.1.151.251'
device_args = dict(host=hostname, username=username,password=password, port=port)
device = HPCOM7(**device_args)
device.open()
macTable = mac.MacUnicastTable(device)
macTableList = macTable.getMacList()
for mac in macTableList:
print(mac)
def main():
module = AnsibleModule(
argument_spec=dict(
member_id=dict(type='str',
required=True),
irf_p1=dict(required=True),
irf_p2=dict(required=True),
filename=dict(default='startup.cfg'),
activate=dict(type='bool',
choices=BOOLEANS,
default='true'),
removal_override=dict(type='bool',
choices=BOOLEANS,
default='false'),
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:
module.fail_json(
msg='There was a problem loading from the pyhpecw7comware module')
filtered_keys = ('hostname', 'username', 'password',
'port', 'CHECKMODE', 'member_id')
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)
member_id = module.params.get('member_id')
changed = False
try:
device.open()
except ConnectionError as e:
safe_fail(module, device, msg=str(e),
descr='Error opening connection to device.')
try:
irf_mem = IrfMember(device)
irf_mem.get_config(member_id)
except PYHPError as e:
module.fail_json(msg=str(e))
try:
irf_ports = IrfPort(device)
existing_full = irf_ports.get_config()
except PYHPError as e:
safe_fail(module, device, msg=str(e),
descr='Error getting current configuration.')
existing = existing_full.get(member_id, {})
proposed = dict((k, v) for k, v in module.params.items()
if v is not None and k not in filtered_keys)
irf_p1 = proposed.get('irf_p1')
if isinstance(irf_p1, str):
irf_p1 = [irf_p1]
if not irf_p1:
irf_p1 = []
irf_p2 = proposed.get('irf_p2')
if isinstance(irf_p2, str):
irf_p2 = [irf_p2]
if not irf_p2:
irf_p2 = []
try:
irf_p1 = convert_iface_list(device, irf_p1)
irf_p2 = convert_iface_list(device, irf_p2)
except PYHPError as ie:
safe_fail(module, device, msg=str(ie),
descr='Error recognizing physical interface.')
old_p1 = existing.get('irf_p1', [])
old_p2 = existing.get('irf_p2', [])
filename = proposed.pop('filename')
activate = proposed.pop('activate')
delta = False
if set(irf_p1) != set(old_p1):
delta = True
if set(irf_p2) != set(old_p2):
delta = True
removal_list = []
for item in old_p1:
if item not in irf_p1:
removal_list.append(item)
for item in old_p2:
if item not in irf_p2:
removal_list.append(item)
removal_override = proposed.get('removal_override')
if removal_list and not removal_override:
safe_fail(module, device, msg='You are trying to remove interfaces ' +
'{0}\n'.format(removal_list) +
'Removal may have adverse effects.\n' +
'Set removal_override=true to override.')
if delta:
try:
irf_ports.build(member_id,
old_p1=old_p1,
old_p2=old_p2,
irf_p1=irf_p1,
irf_p2=irf_p2,
filename=filename,
activate=activate)
except PYHPError as e:
safe_fail(module, device, msg=str(e),
descr='Error preparing IRF port config.')
commands = None
end_state = existing
results = {}
results['proposed'] = proposed
results['existing'] = existing
results['commands'] = commands
results['changed'] = changed
results['end_state'] = end_state
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 = irf_ports.get_config()
changed = True
results['changed'] = changed
results['end_state'] = end_state
except PYHPError as e:
if isinstance(e, NCTimeoutError)\
or isinstance(e, ConnectionClosedError):
changed = True
results['changed'] = changed
module.exit_json(**results)
else:
safe_fail(module, device, msg=str(e),
descr='Error executing commands.'
+ 'Please make sure member id is correct.')
safe_exit(module, device, **results)
from pyhpecw7.comware import HPCOM7
from pyhpecw7.features.vlan import Vlan
from pyhpecw7.features.interface import Interface
from getpass import getpass
ip = raw_input("Enter IP address")
device = HPCOM7(host=ip, username='******', password=getpass())
print device.open()
vlan = Vlan(device, '1')
print vlan.get_config()
print vlan.get_vlan_list()
interface = Interface(device, 'FortyGigE1/0/50')
print interface.get_config()
#vlan = Vlan(device, '20') # Add a new vlan
#vlan.build() # Stage the Vlan
#device.execute() # Execute the chagne
#vlan.build(name='NEWV20', descr='DESCR_20')
#device.execute() # Execute the chagne
#vlan.remove()
#device.execute()
#interface.default()
#response = device.execute()
#interface.build(admin='down', description='TEST_DESCR')
#rsp = device.execute()
# cleanerase - Factory default
# config - manage comware configs
def main():
module = AnsibleModule(argument_spec=dict(
vsi=dict(required=True, type='str'),
interface=dict(required=True, type='str'),
instance=dict(required=True, type='str'),
encap=dict(
required=False,
choices=['default', 'tagged', 'untagged', 'only-tagged', 's-vid'],
default='default'),
vlanid=dict(required=False, type='str'),
access_mode=dict(required=False,
choices=['ethernet', 'vlan'],
default='vlan'),
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)
vsi = module.params['vsi']
interface = module.params['interface']
instance = module.params['instance']
encap = module.params['encap']
vlanid = module.params['vlanid']
access_mode = module.params['access_mode']
state = module.params['state']
if encap in ['only-tagged', 's-vid']:
if not vlanid:
safe_fail(module,
device,
msg='vlanid must be set when using only-tagged' +
'and s-vid as the encap')
changed = False
args = dict(encap=encap, vlanid=vlanid, access_mode=access_mode)
proposed = dict((k, v) for k, v in args.items() if v is not None)
try:
device.open()
except ConnectionError as e:
safe_fail(module,
device,
msg=str(e),
descr='error opening device conn')
try:
l2vpn = L2VPN(device)
is_l2vpn_enabled = l2vpn.get_config()
except PYHPError as e:
safe_fail(module,
device,
msg=str(e),
descr='L2VPN config check failed')
if is_l2vpn_enabled == 'disabled':
safe_fail(module, device, msg='l2vpn needs to be enabled.')
try:
intf = Interface(device, interface)
except PYHPError as e:
safe_fail(module,
device,
msg=str(e),
descr='could not instantiate interface')
if intf.is_routed:
safe_fail(module, device, msg='interface needs to be an L2 interface')
try:
eth = L2EthService(device, interface, instance, vsi)
except PYHPError as e:
safe_fail(module, device, msg=str(e), descr='L2EthService failure')
if not eth.vsi_exist():
safe_fail(module,
device,
msg='VSI needs to be created before using' + ' this module')
try:
existing = eth.get_config()
except PYHPError as e:
safe_fail(module,
device,
msg=str(e),
descr='error getting L2EthService config')
# existing = {} when service instance doesn't exist on interface
# keys: interface, instance, and index exist when an instance is
# configured. pretty much means, there won't be a delta at that point
# keys: encap and optionally svid/cvid are added based when encap
# command is issued on box
# keys: vsi added when xconnect command exists on interface for
# this instance
delta = dict(set(proposed.items()) - set(existing.items()))
if state == 'present':
if existing:
checks(existing, proposed, module)
if delta or not existing:
eth.build(stage=True, **delta)
elif state == 'absent':
if existing:
eth.remove(stage=True)
commands = None
end_state = existing
if device.staged:
commands = device.staged_to_string()
if module.check_mode:
device.close()
safe_exit(module, device, changed=True, commands=commands)
else:
try:
device.execute_staged()
end_state = eth.get_config()
except PYHPError as e:
safe_fail(module,
device,
msg=str(e),
descr='error during 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 main():
module = AnsibleModule(argument_spec=dict(
type=dict(required=True, choices=['display', 'show', 'config']),
command=dict(required=True, type='list'),
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:
safe_fail(module,
msg='There was a problem loading from the pyhpecw7 ' +
'module.',
error=str(ie),
path=str(sys.path))
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)
ctype = module.params['type']
command = module.params['command']
changed = False
proposed = dict(type=ctype, command=command)
try:
device.open()
except ConnectionError as e:
safe_fail(module, device, msg=str(e), descr='error during device open')
response = None
if isinstance(command, list):
config_string = ';'.join(command)
else:
config_string = command
if module.check_mode:
safe_exit(module, device, changed=True, config_string=config_string)
try:
if ctype in ['show', 'display']:
response = device.cli_display(command)
elif ctype in ['config']:
response = device.cli_config(command)
except PYHPError as e:
safe_fail(module, device, msg=str(e), descr='error during execution')
changed = True
results = {}
results['proposed'] = proposed
results['config_string'] = config_string
results['changed'] = changed
results['end_state'] = 'N/A for this module.'
results['response'] = response
safe_exit(module, device, **results)
def main():
module = AnsibleModule(argument_spec=dict(
vlanid=dict(required=True, type='str'),
name=dict(required=False),
descr=dict(required=False),
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)
vlanid = module.params['vlanid']
name = module.params['name']
descr = module.params['descr']
state = module.params['state']
changed = False
args = dict(vlanid=vlanid, name=name, descr=descr)
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))
try:
vlan = Vlan(device, vlanid)
vlan.param_check(**proposed)
except LengthOfStringError as lose:
safe_fail(module, device, msg=str(lose))
except VlanIDError as vie:
safe_fail(module, device, msg=str(vie))
except PYHPError as e:
safe_fail(module, device, msg=str(e))
try:
existing = vlan.get_config()
except PYHPError as e:
safe_fail(module,
device,
msg=str(e),
descr='error getting vlan config')
if state == 'present':
delta = dict(
set(proposed.iteritems()).difference(existing.iteritems()))
if delta:
vlan.build(stage=True, **delta)
elif state == 'absent':
if existing:
vlan.remove(stage=True)
commands = None
end_state = existing
if device.staged:
commands = device.staged_to_string()
if module.check_mode:
device.close()
safe_exit(module, device, changed=True, commands=commands)
else:
try:
device.execute_staged()
end_state = vlan.get_config()
except PYHPError as e:
safe_fail(module,
device,
msg=str(e),
descr='error during 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 main():
module = AnsibleModule(
argument_spec=dict(
mode=dict(required=True, choices=['load-balance', 'standard']),
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)
mode = module.params['mode']
changed = False
delta = False
try:
device.open()
except ConnectionError as e:
safe_fail(module, device, msg=str(e),
descr='error opening connection' )
try:
existing = get_existing(device)
except PYHPError as e:
safe_fail(module, device, msg=str(e),
descr='error getting existing config')
end_state = existing
if existing != mode:
delta = True
if delta:
if mode == 'load-balance':
command = 'vrrp mode {0}'.format(mode)
elif mode == 'standard':
command = 'undo vrrp mode'
device.stage_config(command, "cli_config")
commands = None
response = None
if device.staged:
commands = device.staged_to_string()
if module.check_mode:
device.close()
safe_exit(module, device, changed=True,
commands=commands)
else:
try:
response = device.execute_staged()
end_state = get_existing(device)
except PYHPError as e:
safe_fail(module, device, msg=str(e),
descr='error during execution')
changed = True
results = {}
results['proposed'] = mode
results['existing'] = existing
results['commands'] = commands
results['changed'] = changed
results['end_state'] = end_state
results['response'] = response
safe_exit(module, device, **results)
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 main():
module = AnsibleModule(
argument_spec=dict(
member_id=dict(type='str',
required=True),
new_member_id=dict(type='str'),
auto_update=dict(choices=['enable', 'disable']),
domain_id=dict(type='str'),
mad_exclude=dict(),
priority=dict(type='str'),
descr=dict(),
reboot=dict(type='bool',
choices=BOOLEANS,
required=True),
state=dict(choices=['present', 'absent'],
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:
module.fail_json(
msg='There was a problem loading from the pyhpecw7comware module')
filtered_keys = ('hostname', 'username', 'password',
'port', 'CHECKMODE')
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)
member_id = module.params.pop('member_id')
reboot = module.params.pop('reboot')
state = module.params.get('state')
changed = False
try:
device.open()
except ConnectionError as e:
safe_fail(module, device, msg=str(e))
try:
irfm = IrfMember(device)
existing = irfm.get_config(member_id)
except PYHPError as e:
if isinstance(e, IRFMemberDoesntExistError):
new_member_id = module.params.get('new_member_id')
try:
if new_member_id:
member_id = new_member_id
irfm = IrfMember(device)
existing = irfm.get_config(member_id)
else:
safe_fail(module, device, msg=str(e))
except PYHPError as e:
safe_fail(module, device, msg=str(e))
else:
safe_fail(module, device, msg=str(e))
proposed = dict((k, v) for k, v in module.params.items()
if v is not None and k not in filtered_keys)
mad_exclude = proposed.pop('mad_exclude', [])
if isinstance(mad_exclude, str):
mad_exclude = [mad_exclude]
if mad_exclude:
try:
mad_exclude = convert_iface_list(device, mad_exclude)
except InterfaceError as ie:
module.fail_json(msg=str(ie))
existing_mad_exclude = existing.pop('mad_exclude', [])
mad_delta = list(set(mad_exclude).difference(
existing_mad_exclude))
delta = dict(set(proposed.items()) - set(existing.items()))
proposed['mad_exclude'] = mad_exclude
existing['mad_exclude'] = existing_mad_exclude
if state == 'present':
if delta or mad_delta:
try:
irfm.build(
member_id=member_id, mad_exclude=mad_delta, **delta)
except PYHPError as e:
safe_fail(module, device, msg=str(e),
descr='There was an error preparing the'
+ ' IRF membership configuration.')
elif state == 'absent':
remove_mad = list(set(mad_exclude).intersection(
existing_mad_exclude))
irfm.remove_mad_exclude(remove_mad)
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 = irfm.get_config(member_id)
except PYHPError as e:
safe_fail(module, device, msg=str(e))
changed = True
results = {}
results['proposed'] = proposed
results['existing'] = existing
results['commands'] = commands
results['changed'] = changed
results['end_state'] = end_state
results['state'] = state
new_member_id = proposed.get('new_member_id')
mem_id_changed = False
if new_member_id:
mem_id_changed = proposed.get('new_member_id') != member_id
if reboot and mem_id_changed:
try:
my_reboot = Reboot(device)
my_reboot.build(reboot=True)
changed = True
device.execute_staged()
except PYHPError as e:
if isinstance(e, NCTimeoutError)\
or isinstance(e, ConnectionClosedError):
module.exit_json(**results)
else:
safe_fail(module, device, msg=str(e))
safe_exit(module, device, **results)
def main():
module = AnsibleModule(argument_spec=dict(
reboot=dict(required=True, choices=BOOLEANS, type='bool'),
delay=dict(required=False, type='str'),
date=dict(required=False, type='str'),
time=dict(required=False, type='str'),
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)
reboot = module.params['reboot']
delay = module.params['delay']
date = module.params['date']
time = module.params['time']
if date:
if not time:
module.fail_json(msg='time is also required when specifying date')
proposed = dict(reboot=reboot, delay=delay, time=time, date=date)
changed = False
try:
device.open()
except ConnectionError as e:
safe_fail(module,
device,
msg=str(e),
descr='error opening connection to device')
try:
reboot_me = Reboot(device)
reboot_me.param_check(**proposed)
except RebootDateError as rde:
safe_fail(module, device, msg=str(rde))
except RebootTimeError as rte:
safe_fail(module, device, msg=str(rte))
except PYHPError as e:
safe_fail(module,
device,
msg=str(e),
descr='error using Reboot object')
reboot_me.build(stage=True, **proposed)
commands = None
response = None
changed = False
results = {}
if device.staged:
commands = device.staged_to_string()
if module.check_mode:
safe_exit(module, device, changed=True, commands=commands)
else:
try:
response = device.execute_staged()
changed = True
except PYHPError as e:
if isinstance(e, NCTimeoutError):
results['changed'] = True
results['rebooted'] = True
results['commands'] = commands
module.exit_json(**results)
else:
safe_fail(module,
device,
msg=str(e),
descr='error during execution')
results['proposed'] = proposed
results['commands'] = commands
results['changed'] = changed
results['end_state'] = 'N/A for this module'
results['response'] = response
safe_exit(module, device, **results)
def main():
module = AnsibleModule(
argument_spec=dict(
state=dict(choices=['enabled', 'disabled'], required=True),
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)
state = module.params['state']
changed = False
try:
device.open()
except ConnectionError as e:
safe_fail(module, device, msg=str(e),
descr='error opening connection to device')
try:
l2vpn = L2VPN(device)
existing = l2vpn.get_config()
except PYHPError as e:
safe_fail(module, device, msg=str(e),
descr='error getting existing config')
if existing != state:
if state == 'enabled':
l2vpn.enable(stage=True)
elif state == 'disabled':
l2vpn.disable(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 = l2vpn.get_config()
except PYHPError as e:
safe_fail(module, device, msg=str(e),
descr='error during execution')
changed = True
results = {}
results['proposed'] = state
results['existing'] = existing
results['commands'] = commands
results['changed'] = changed
results['end_state'] = end_state
safe_exit(module, device, **results)
#!/usr/bin/env python3
from pyhpecw7.utils.xml.lib import *
from pyhpecw7.comware import HPCOM7
from pyhpecw7.features.vlan import Vlan
from pyhpecw7.features.interface import Interface
from pyhpecw7.features.switchport import Switchport
'''
*** args removed for privacy ***
'''
device = HPCOM7(**args)
device.open()
if not device.connected:
print("Unable to connect to target switch, exiting ... ")
quit(1)
E = data_element_maker()
top = E.top(E.Ifmgr(E.Interfaces(E.Interface())))
nc_get_reply = device.get(('subtree', top))
# Gets an array of interface names from XML
reply_data_names = findall_in_data('Name', nc_get_reply.data_ele)
# Constructs interfaces list for reply using only interfaces names
for ifname in reply_data_names:
interface = Interface(device, ifname.text)
def main():
module = AnsibleModule(
argument_spec=dict(
filename=dict(required=False, default='startup.cfg'),
port=dict(default=830, type='int'),
hostname=dict(required=True),
username=dict(default='hp'),
password=dict(default='hp123'),
),
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)
filename = module.params['filename']
if "/" in filename:
module.fail_json(msg="specify only filename. it'll be saved in flash")
if filename[-4:] != '.cfg':
module.fail_json(msg='filename should end with .cfg')
changed = False
try:
device.open()
except ConnectionError as e:
safe_fail(module, device, msg=str(e),
descr='error opening connection to device')
device.stage_config('{0}'.format(filename), "save")
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()
except PYHPError as e:
safe_fail(module, device, msg=str(e),
descr='error during execution')
changed = True
results = {}
results['commands'] = commands
results['changed'] = changed
safe_exit(module, device, **results)
def main():
module = AnsibleModule(argument_spec=dict(
config_file=dict(required=True, type='str'),
diff_file=dict(required=False, type='str'),
commit_changes=dict(required=True, choices=BOOLEANS, type='bool'),
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:
safe_fail(module,
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(timeout=60, **device_args)
config_file = module.params['config_file']
diff_file = module.params['diff_file']
commit_changes = module.params['commit_changes']
changed = False
if os.path.isfile(config_file):
file_exists = True
else:
safe_fail(
module,
msg='Cannot find/access config_file:\n{0}'.format(config_file))
try:
device.open()
except ConnectionError as e:
safe_fail(module,
device,
msg=str(e),
descr='error opening connection to device')
if file_exists:
basename = os.path.basename(config_file)
try:
copy = FileCopy(device,
src=config_file,
dst='flash:/{0}'.format(basename))
copy.transfer_file()
cfg = Config(device, config_file)
except PYHPError as fe:
safe_fail(module, device, msg=str(fe), descr='file transfer error')
if diff_file:
diffs, full_diffs = cfg.compare_config()
write_diffs(diff_file, diffs, full_diffs)
else:
diffs = 'None. diff_file param not set in playbook'
cfg.build(stage=True)
active_files = {}
if device.staged:
active_files = dict(backup='flash:/safety_file.cfg',
startup='flash:/startup.cfg',
config_applied='flash:/' + basename)
if module.check_mode:
safe_exit(module,
device,
changed=True,
active_files=active_files,
diffs=diffs,
diff_file=diff_file,
config_file=config_file)
else:
if commit_changes:
try:
switch_response = device.execute_staged()
# TODO: check of "ok" or errors?
except NCError as err:
if err.tag == 'operation-failed':
safe_fail(module,
device,
msg='Config replace operation' +
' failed.\nValidate the config' +
' file being applied.')
except PYHPError as e:
safe_fail(module,
device,
msg=str(e),
descr='error during execution')
changed = True
results = {}
results['changed'] = changed
results['active_files'] = active_files
results['commit_changes'] = commit_changes
results['diff_file'] = diff_file
results['config_file'] = config_file
safe_exit(module, device, **results)
def main():
module = AnsibleModule(
argument_spec=dict(
name=dict(required=True),
addr=dict(required=True),
mask=dict(required=True, type='str'),
version=dict(choices=['v4', 'v6'],
default='v4'),
state=dict(choices=['present', 'absent'],
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:
module.fail_json(
msg='There was a problem loading from the pyhpecw7 module')
filtered_keys = ('state', 'hostname', 'username', 'password',
'port', 'CHECKMODE', 'name', 'version')
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']
version = module.params['version']
addr = module.params['addr']
mask = module.params['mask']
changed = False
if not valid_ip_network(ip_stringify(**module.params)):
module.fail_json(msg='Not a valid IP address or mask.')
try:
device.open()
except ConnectionError as e:
safe_fail(module, device,
descr='There was an error opening'
+ ' the connection to the device.',
msg=str(e))
try:
ip_int = IpInterface(device, name, version)
except PYHPError as e:
safe_fail(module, device,
descr='There was an error initializing'
+ ' the IpInterface class.',
msg=str(e))
if not ip_int.interface.iface_exists:
safe_fail(module, device, msg='Please use the interface module ' +
'to create the {0} interface.'.format(ip_int.interface_name))
# Make sure interface is routed
if not ip_int.is_routed:
safe_fail(module, device, msg='Please use the interface module ' +
'to make {0} a routed interface.'.format(ip_int.interface_name))
try:
existing = get_existing(ip_int, addr, mask)
except PYHPError as e:
safe_fail(module,
device,
descr='Error getting the existing configuration.',
msg=str(e))
proposed = dict((k, v) for k, v in module.params.items()
if v is not None and k not in filtered_keys)
if existing:
ips_are_same = compare_ips(
ip_stringify(**existing), ip_stringify(**proposed))
else:
ips_are_same = False
if state == 'present':
if not ips_are_same:
ip_int.build(stage=True, **proposed)
elif state == 'absent':
if ips_are_same:
ip_int.remove(stage=True, **existing)
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 = get_existing(ip_int, addr, mask)
except PYHPError as e:
safe_fail(module,
device,
descr='Error during command execution.',
msg=str(e))
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):
self.device = HPCOM7(host='host', username='******', password='******')
self.device.connection = mock.MagicMock()
self.device.connection.connected = True
def main():
module = AnsibleModule(argument_spec=dict(
ipe_package=dict(),
boot=dict(),
system=dict(),
remote_dir=dict(default='flash:/'),
delete_ipe=dict(choices=BOOLEANS, type='bool', default=False),
reboot=dict(required=True, choices=BOOLEANS, type='bool'),
delay=dict(type='str'),
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.',
error=str(ie))
ipe_package = module.params.get('ipe_package')
boot = module.params.get('boot')
system = module.params.get('system')
if ipe_package:
if boot or system:
module.fail_json(
msg=
'ipe_package and boot/system parameters are mutually exclusive'
)
else:
if not (boot and system):
module.fail_json(
msg=
'boot and system parameters must be provided if ipe_package is not'
)
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,
timeout=150)
changed = False
reboot = module.params.get('reboot')
delay = module.params.get('delay')
already_set = False
transfered = False
try:
device.open()
except ConnectionError as e:
safe_fail(module,
device,
msg=str(e),
descr='Error opening connection to device.')
try:
ios = InstallOs(device)
existing = ios.get_config()
except PYHPError:
safe_fail(module,
device,
msg=str(e),
descr='Error getting current config.')
existing_boot = existing['startup-primary']['boot']
existing_system = existing['startup-primary']['system']
remote_dir = module.params['remote_dir']
current_boot_file = remote_dir + existing_boot
current_sys_file = remote_dir + existing_system
if ipe_package:
ipe_basename = os.path.basename(ipe_package)
ipe_boot_sys = re.split('-|\.', ipe_basename)[-3:-1]
if ipe_boot_sys:
if ipe_boot_sys[0].lower() in existing_boot.lower()\
and ipe_boot_sys[0].lower() in existing_system.lower()\
and ipe_boot_sys[1].lower() in existing_boot.lower()\
and ipe_boot_sys[1].lower() in existing_system.lower():
already_set = True
ipe_dst = remote_dir + ipe_basename
try:
# preps transfer and checks if source file exists
ipe_file_copy = FileCopy(device, ipe_package, ipe_dst)
except PYHPError as fe:
safe_fail(module,
device,
msg=str(fe),
descr='Error preparing IPE file transfer.')
if not ipe_file_copy.file_already_exists():
try:
ipe_file_copy.transfer_file()
transfered = True
except PYHPError as fe:
safe_fail(module,
device,
msg=str(fe),
descr='Error transfering IPE file.')
if not already_set:
delete_ipe = module.params.get('delete_ipe')
ios.build('ipe',
ipe=ipe_file_copy.dst,
delete_ipe=delete_ipe,
stage=True)
# set current boot/sys files as backup startup images
ios.build('bootsys',
boot=current_boot_file,
system=current_sys_file,
startup_type='2',
stage=True)
elif boot:
boot_basename = os.path.basename(boot)
system_basename = os.path.basename(system)
if boot_basename in existing_boot\
and system_basename in existing_system:
already_set = True
boot_dst = remote_dir + boot_basename
try:
# preps transfer and checks if source file exists
boot_file_copy = FileCopy(device, boot, boot_dst)
except PYHPError as fe:
safe_fail(module,
device,
msg=str(fe),
descr='Error preparing boot file transfer.')
system_dst = remote_dir + system_basename
try:
# preps transfer and checks if source file exists
system_file_copy = FileCopy(device, system, system_dst)
except PYHPError as fe:
safe_fail(module,
device,
msg=str(fe),
descr='Error preparing system file transfer.')
if not boot_file_copy.file_already_exists():
try:
boot_file_copy.transfer_file()
transfered = True
except PYHPError as fe:
safe_fail(module,
device,
msg=str(fe),
descr='Error transfering boot file.')
if not system_file_copy.file_already_exists():
try:
system_file_copy.transfer_file()
transfered = True
except PYHPError as fe:
safe_fail(module,
device,
msg=str(fe),
descr='Error transfering system file.')
if not already_set:
ios.build('bootsys',
boot=boot_file_copy.dst,
system=system_file_copy.dst,
stage=True)
# set current boot/sys files as backup startup images
ios.build('bootsys',
boot=current_boot_file,
system=current_sys_file,
startup_type='2',
stage=True)
commands = None
end_state = existing
reboot_attempt = 'no'
if device.staged or transfered:
if reboot and delay:
reboot_attempt = 'yes'
os_reboot = Reboot(device)
os_reboot.build(stage=True, reboot=True, delay=delay)
commands = device.staged_to_string()
if module.check_mode:
safe_exit(module,
device,
changed=True,
commands=commands,
transfered=transfered,
end_state=end_state)
else:
try:
device.execute_staged()
end_state = ios.get_config()
except PYHPError as e:
safe_fail(module,
device,
msg=str(e),
descr='Error executing commands.')
changed = True
results = {}
results['commands'] = commands
results['transfered'] = transfered
results['changed'] = changed
results['end_state'] = end_state
if reboot and not delay:
reboot_attempt = 'yes'
try:
device.reboot()
changed = True
# for some reason,
# this is needed to activate the reboot
try:
device.close()
except PYHPError:
pass
except PYHPError as e:
safe_fail(module,
device,
msg=str(e),
descr='Error rebooting the device.')
results['reboot_attempt'] = reboot_attempt
safe_exit(module, device, **results)
def main():
module = AnsibleModule(argument_spec=dict(
type=dict(required=True, choices=['display', 'show', 'config']),
config_file=dict(required=True, type='str'),
previous_config_file=dict(required=False, type='str'),
previous_config_content=dict(required=False, type='str'),
port=dict(default=830, type='int'),
hostname=dict(required=True),
username=dict(required=True),
password=dict(required=True),
is_delete=dict(required=True),
timeout=dict(required=False)),
supports_check_mode=True)
if not HAS_PYHP:
safe_fail(module,
msg='There was a problem loading from the pyhpecw7 ' +
'module.',
error=str(ie),
path=str(sys.path))
username = module.params['username']
password = module.params['password']
port = module.params['port']
hostname = socket.gethostbyname(module.params['hostname'])
timeout = module.params['timeout'] if module.params['timeout'] else 60
device_args = dict(host=hostname,
username=username,
password=password,
port=port)
device = HPCOM7(timeout=timeout, **device_args)
ctype = module.params['type']
config_file = module.params['config_file']
previous_config_file = module.params['previous_config_file']
previous_config_content = module.params['previous_config_content']
is_delete = module.params['is_delete']
changed = False
config_file_exists = False
if os.path.isfile(config_file):
config_file_exists = True
else:
safe_fail(
module,
msg='Cannot find/access config_file:\n{0}'.format(config_file))
try:
device.open()
except ConnectionError as e:
safe_fail(module, device, msg=str(e), descr='error during device open')
commands = []
list_diff = []
# This part is used to update virtual interface, vsi and ip vpn-instance
if str(is_delete).lower() == 'false':
previous_config = ''
if previous_config_content:
previous_config = previous_config_content.split('\n')
elif os.path.isfile(previous_config_file):
with open(previous_config_file, 'r') as pf:
previous_config = pf.read().splitlines()
with open(config_file, 'r') as cf:
current_config = cf.read().splitlines()
list_diff, changed_commands = process_diff(previous_config,
current_config)
commands += changed_commands
if config_file_exists:
if str(is_delete).lower() == 'true':
with open(config_file) as fp:
for line in fp:
commands.append(line.rstrip())
elif str(is_delete).lower() == 'false' and len(list_diff) > 0:
with open(config_file) as fp:
for line in fp:
commands.append(line.rstrip())
else:
# When there are no changes, we don't need to add configuration
commands.append("# There are no changes")
response = None
proposed = dict(type=ctype, command=commands)
if isinstance(commands, list):
config_string = ';'.join(commands)
else:
config_string = commands
if module.check_mode:
safe_exit(module, device, changed=True, config_string=config_string)
try:
if ctype in ['show', 'display']:
response = device.cli_display(commands)
elif ctype in ['config']:
response = device.cli_config(commands)
except PYHPError as e:
safe_fail(module, device, msg=str(e), descr='error during execution')
changed = True
results = {}
results['proposed'] = proposed
results['config_string'] = config_string
results['changed'] = changed
results['end_state'] = 'N/A for this module.'
results['response'] = response
results['commands'] = commands
results['list_diff'] = list_diff
safe_exit(module, device, **results)
def main():
module = AnsibleModule(argument_spec=dict(
vrid=dict(required=True, type='str'),
interface=dict(required=True),
vip=dict(required=False),
priority=dict(required=False, type='str'),
auth_mode=dict(required=False, choices=['simple', 'md5']),
key_type=dict(required=False, choices=['cipher', 'plain']),
key=dict(required=False, type='str'),
preempt=dict(required=False, choices=['yes', 'no']),
state=dict(choices=['present', 'absent', 'shutdown', 'undoshutdown'],
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)
vrid = module.params['vrid']
interface = module.params['interface'].lower()
vip = module.params['vip']
priority = module.params['priority']
preempt = module.params['preempt']
auth_mode = module.params['auth_mode']
key_type = module.params['key_type']
key = module.params['key']
if auth_mode:
if not key_type or not key:
module.fail_json(msg='params key_type and key are required')
if key_type or key:
if not auth_mode:
module.fail_json(msg='auth_mode is required when setting auth')
state = module.params['state']
changed = False
args = dict(vrid=vrid,
priority=priority,
preempt=preempt,
vip=vip,
interface=interface,
auth_mode=auth_mode,
key_type=key_type,
key=key)
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 opening device conn')
try:
vrrp = VRRP(device, interface, vrid)
vrrp_interface = Interface(device, interface)
except PYHPError as e:
safe_fail(module, device, msg=str(e))
if not vrrp_interface.iface_exists:
safe_fail(module, device, msg='interface does not exist.')
is_eth, is_rtd = vrrp_interface._is_ethernet_is_routed()
if not is_rtd:
safe_fail(module,
device,
msg='interface needs to be a layer 3 interface')
try:
existing = vrrp.get_config()
except PYHPError as e:
safe_fail(module,
device,
msg=str(e),
descr='could not get existing config')
if state == 'present':
delta = dict(
set(proposed.iteritems()).difference(existing.iteritems()))
if delta or auth_mode or \
existing.get('admin') == 'down':
delta['vrid'] = vrid
if delta.get('key'):
delta['auth_mode'] = auth_mode
delta['key_type'] = key_type
vrrp.build(stage=True, state=state, **delta)
elif state == 'absent':
if existing:
vrrp.remove(stage=True)
elif state == 'shutdown':
if existing.get('admin') == 'Up':
vrrp.shutdown(stage=True)
elif state == 'undoshutdown':
if existing.get('admin') == 'Down':
vrrp.undoshutdown(stage=True)
commands = None
end_state = existing
response = None
if device.staged:
commands = device.staged_to_string()
if module.check_mode:
device.close()
safe_exit(module, device, changed=True, commands=commands)
else:
try:
response = device.execute_staged()
end_state = vrrp.get_config()
except PYHPError as e:
safe_fail(module,
device,
msg=str(e),
descr='error during execution')
changed = True
results = {}
results['proposed'] = proposed
results['existing'] = existing
results['state'] = state
results['commands'] = commands
results['changed'] = changed
results['end_state'] = end_state
results['response'] = response
safe_exit(module, device, **results)
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)
def main():
module = AnsibleModule(
argument_spec=dict(name=dict(required=True),
admin=dict(choices=['up', 'down']),
description=dict(),
type=dict(choices=['bridged', 'routed']),
duplex=dict(choices=['auto', 'full']),
speed=dict(type='str'),
state=dict(choices=['present', 'absent', '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.',
error=str(ie))
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('type'):
if module.params.get('admin') or module.params.get('description')\
or module.params.get('duplex') or module.params.get('speed'):
module.fail_json(msg='The type parameter is incompatible with:'
'\nadmin, description, duplex, speed.'
'\nPlease configure type first by itself,'
'\nthen run again.')
proposed = dict((k, v) for k, v in module.params.iteritems()
if v is not None and k not in filtered_keys)
try:
device.open()
except ConnectionError as e:
safe_fail(module,
device,
msg=str(e),
descr='Error opening connection to device.')
try:
interface = Interface(device, name)
except PYHPError as e:
safe_fail(module,
device,
descr='There was problem recognizing that interface.',
msg=str(e))
try:
interface.param_check(**proposed)
except PYHPError as e:
safe_fail(module,
device,
descr='There was problem with the supplied parameters.',
msg=str(e))
try:
existing = interface.get_config()
except PYHPError as e:
safe_fail(module,
device,
msg=str(e),
descr='Error getting existing config.')
if state == 'present':
delta = dict(
set(proposed.iteritems()).difference(existing.iteritems()))
if delta or not existing:
original = existing
if not interface.iface_exists:
try:
interface.create_logical()
interface.update()
changed = True
existing = interface.get_config()
except PYHPError as e:
safe_fail(module,
device,
msg='Exception message ' + str(e),
descr='There was a problem creating' +
' the logical interface.')
delta = dict(
set(proposed.iteritems()).difference(existing.iteritems()))
if delta:
interface.build(stage=True, **delta)
elif state == 'default':
defaults = interface.get_default_config()
delta = dict(
set(existing.iteritems()).difference(defaults.iteritems()))
if delta:
interface.default(stage=True)
elif state == 'absent':
if interface.iface_exists:
if interface.is_ethernet:
defaults = interface.get_default_config()
delta = dict(
set(existing.iteritems()).difference(defaults.iteritems()))
if delta:
try:
interface.default(stage=True)
except InterfaceError as e:
safe_fail(module,
device,
msg=str(e),
descr='Error getting default configuration.')
else:
try:
interface.remove_logical(stage=True)
except InterfaceError as e:
safe_fail(module,
device,
msg=str(e),
descr='Error removing logical interface.')
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 = interface.get_config()
except PYHPError as e:
safe_fail(module,
device,
msg=str(e),
descr='Error on device 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 main():
module = AnsibleModule(argument_spec=dict(
factory_default=dict(default=False, choices=BOOLEANS, type='bool'),
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:
safe_fail(module,
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)
factory_default = module.params['factory_default']
try:
device.open()
except ConnectionError as e:
safe_fail(module,
device,
msg=str(e),
descr='error opening connection to device')
try:
cleanerase = CleanErase(device)
except PYHPError as e:
safe_fail(module,
device,
msg=str(e),
descr='error initializing CleanErase')
if factory_default:
cleanerase.build(stage=True, factory_default=factory_default)
results = {}
results['changed'] = False
results['rebooted'] = False
results['commands'] = None
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()
changed = True
except PYHPError as e:
if isinstance(e, NCTimeoutError):
results['changed'] = True
results['rebooted'] = True
results['commands'] = commands
module.exit_json(**results)
else:
safe_fail(module,
device,
msg=str(e),
descr='error during execution')
safe_exit(module, device, **results)
def main():
module = AnsibleModule(argument_spec=dict(
vxlan=dict(required=True, type='str'),
vsi=dict(required=True, type='str'),
tunnels=dict(required=False, type='list'),
descr=dict(required=False),
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)
vxlan = module.params['vxlan']
vsi = module.params['vsi']
descr = module.params['descr']
tunnels = normalize_to_list(module.params['tunnels'])
state = module.params['state']
changed = False
args = dict(vxlan=vxlan, vsi=vsi, descr=descr)
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 opening device conn')
try:
l2vpn = L2VPN(device)
is_l2vpn_enabled = l2vpn.get_config()
except PYHPError as e:
safe_fail(module, device, msg=str(e), descr='L2VPN check failed')
if is_l2vpn_enabled == 'disabled':
safe_fail(module, device, msg='l2vpn needs to be enabled.')
try:
VXLAN = Vxlan(device, vxlan, vsi)
existing = VXLAN.get_config()
except PYHPError as e:
safe_fail(module,
device,
msg=str(e),
descr='could not obtain existing')
if state == 'present':
checks(existing, proposed, module)
if 'tunnels' in existing.keys():
existing_tunnels = existing.pop('tunnels')
else:
existing_tunnels = []
delta = dict(set(proposed.iteritems()).difference(existing.iteritems()))
tunnels_to_add = list(set(tunnels).difference(existing_tunnels))
tunnels_to_remove = list(set(existing_tunnels).difference(tunnels))
if tunnels_to_add:
delta['tunnels_to_add'] = tunnels_to_add
for each in tunnels_to_add:
tun = Tunnel(device, each)
exists = tun.get_config()
if not exists:
safe_fail(module,
device,
msg='tunnel needs to exist first' +
' before \nbefore adding it to a vxlan',
tunnel=each)
if tunnels_to_remove:
delta['tunnels_to_remove'] = tunnels_to_remove
if state == 'present':
if not existing.get('vxlan'):
VXLAN.create(stage=True)
if delta:
VXLAN.build(stage=True, **delta)
elif state == 'absent':
if existing:
# existing is based off the VXLAN ID
# if it's not mapped to any VSI, it's not considered
# existing although the VSI may exist
if existing.get('vsi') != vsi:
safe_fail(module,
device,
msg='vsi/vxlan mapping must exist' +
' on switch to remove it',
current_vsi=existing.get('vsi'))
else:
VXLAN.remove_vsi(stage=True)
commands = None
end_state = existing
if device.staged:
commands = device.staged_to_string()
if module.check_mode:
device.close()
safe_exit(module, device, changed=True, commands=commands)
else:
try:
device.execute_staged()
end_state = VXLAN.get_config()
except PYHPError as e:
safe_fail(module,
device,
msg=str(e),
descr='failed during execution')
changed = True
if tunnels:
proposed.update(tunnels=tunnels)
if existing_tunnels:
existing.update(tunnels=existing_tunnels)
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 main():
module = AnsibleModule(argument_spec=dict(
tunnel=dict(required=True, type='str'),
src=dict(required=False, type='str'),
dest=dict(required=False, type='str'),
global_src=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)
tunnel = module.params['tunnel']
src = module.params['src']
dest = module.params['dest']
global_src = module.params['global_src']
state = module.params['state']
changed = False
args = dict(src=src, dest=dest)
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 opening device conn')
try:
l2vpn = L2VPN(device)
is_l2vpn_enabled = l2vpn.get_config()
except PYHPError as e:
safe_fail(module, device, msg=str(e), descr='L2VPN check failed')
if is_l2vpn_enabled == 'disabled':
safe_fail(module, device, msg='l2vpn needs to be enabled.')
try:
tun = Tunnel(device, tunnel)
existing = tun.get_config()
except PYHPError as e:
safe_fail(module,
device,
msg=str(e),
descr='could not get tunnel config')
if state == 'present':
if existing.get('mode') and existing.get('mode') != 'vxlan':
safe_fail(module,
device,
msg='tunnel interface exists but is not a ' +
'vxlan \ntunnel interface. remove and re-add.')
delta = dict(set(proposed.iteritems()).difference(existing.iteritems()))
try:
existing_gsrc = tun.get_global_source()
except PYHPError as e:
safe_fail(module,
device,
msg=str(e),
descr='could not get existing global src')
if global_src:
if existing_gsrc != global_src:
delta['global_src'] = global_src
if state == 'present':
if delta or not existing:
tun.build(stage=True, **delta)
elif state == 'absent':
if existing:
tun.remove(stage=True)
commands = None
end_state = existing
if device.staged:
commands = device.staged_to_string()
if module.check_mode:
device.close()
safe_exit(module, device, changed=True, commands=commands)
else:
try:
device.execute_staged()
end_state = tun.get_config()
except PYHPError as e:
safe_fail(module,
device,
msg=str(e),
descr='error during execution')
end_state['global_src'] = tun.get_global_source()
changed = True
proposed['global_src'] = global_src
existing['global_src'] = existing_gsrc
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)
