def connect(host,username,password,port): args = dict(host=host, username=username, password=password, port=port) print("Connecting " + host) # CREATE CONNECTION device = HPCOM7(**args) device.open() return device
def main(): module = AnsibleModule(argument_spec=dict(file=dict(required=True), remote_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('remote_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_upload = FileUpload(device, proto, src, dst) if not file_upload.remote_dir_exists: file_upload.create_remote_dir() file_upload.transfer_file() changed = True except PYHPError as fe: safe_fail(module, device, msg=str(fe), descr='Error transferring file.') results = {} results['source_file'] = file_upload.src results['destination_file'] = file_upload.dst results['changed'] = changed 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( 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( 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)
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)
#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( 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( 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)
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)
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 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( 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( 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( 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( 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( 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( 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( 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( 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)
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( 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( 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)
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)
#!/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( 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( 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)