def test_ethernets(self): ssh = MockSSH([ ("/sbin/ip addr show | /bin/grep 'link/ether'", """\ link/ether c8:2a:14:05:3d:53 brd ff:ff:ff:ff:ff:ff link/ether e0:f8:47:24:c9:e6 brd ff:ff:ff:ff:ff:ff """), ]) ethernets = ssh_linux.get_ethernets(ssh) self.assertEquals(ethernets, [ Eth('', 'c8:2a:14:05:3d:53', 0), Eth('', 'e0:f8:47:24:c9:e6', 0), ])
def _snmp_modular(ip, community, parent): oid = (1, 3, 6, 1, 4, 1, 343, 2, 19, 1, 2, 10, 12, 0) # Max blades message = snmp_command(ip, community, oid, attempts=1, timeout=0.5) max_blades = int(message[0][1]) blades_macs = {} for blade_no in range(1, max_blades + 1): oid = (1, 3, 6, 1, 4, 1, 343, 2, 19, 1, 2, 10, 202, 3, 1, 1, blade_no) blades_macs[blade_no] = set(snmp_macs(ip, community, oid, attempts=1, timeout=0.5)) for i, macs in blades_macs.iteritems(): unique_macs = macs for j, other_macs in blades_macs.iteritems(): if i == j: continue unique_macs -= other_macs ethernets = [Eth('Intel Modular MAC', mac, speed=None) for mac in unique_macs] if ethernets: dev = Device.create( name='Intel Modular Blade', model_name='Intel Modular Blade', model_type=DeviceType.blade_server, ethernets=ethernets, management=parent.management, chassis_position=i, position = str(i), parent=parent, ) dev.save(update_last_seen=True)
def run_ssh_xen(ipaddr, parent): ssh = _connect_ssh(ipaddr.address) try: vms = get_running_vms(ssh) macs = get_macs(ssh) finally: ssh.close() for dev in parent.child_set.exclude( sn__in=[vm_uuid for (vm_name, vm_uuid) in vms]): dev.deleted = True dev.save() for vm_name, vm_uuid in vms: ethernets = [ Eth('vif %d' % i, mac, 0) for i, mac in enumerate(macs.get(vm_name, [])) ] dev = Device.create(ethernets=ethernets, parent=parent, sn=vm_uuid, model_type=DeviceType.virtual_server, model_name='XEN Virtual Server', priority=SAVE_PRIORITY) dev.name = vm_name dev.save(priority=SAVE_PRIORITY) return ', '.join(vm_name for (vm_name, vm_uuid) in vms)
def make_device(ilo, ip): if ilo.model.startswith('HP ProLiant BL'): t = DeviceType.blade_server else: t = DeviceType.rack_server ethernets = [Eth(label, mac, speed=None) for label, mac in ilo.ethernets] dev = Device.create( ethernets=ethernets, model_name=ilo.model, model_type=t, sn=ilo.sn, name=ilo.name, mgmt_firmware=ilo.firmware, ) dev.save(update_last_seen=True, priority=SAVE_PRIORITY) ipaddr, created = IPAddress.concurrent_get_or_create(address=ip) ipaddr.device = dev ipaddr.is_management = True ipaddr.save() if dev.parent and dev.parent.management: dev.management = dev.parent.management else: dev.management = ipaddr dev.save(priority=SAVE_PRIORITY) return dev
def setUp(self): # create data centers self.dc_temp1 = DataCenter.objects.create(name='temp1', ) self.dc_temp2 = DataCenter.objects.create(name='temp2', ) self.env_temp1 = Environment.objects.create( name='temp1', hosts_naming_template='h<100,199>.temp1|h<300,399>.temp1', data_center=self.dc_temp1, ) self.env_temp2 = Environment.objects.create( name='temp2', hosts_naming_template='h<200,299>.temp2', data_center=self.dc_temp2, ) # create domains self.domain_temp1 = Domain.objects.create(name='temp1') self.domain_temp2 = Domain.objects.create(name='temp2') # create temp deployment dev = Device.create(ethernets=[ Eth('SomeEthLabel', 'aa11cc2266bb', EthernetSpeed.unknown) ], model_type=DeviceType.unknown, model_name='Unknown') IPAddress.objects.create(address='127.0.1.4', device=dev) Deployment.objects.create(device=dev, mac='aa11cc2266bb', ip='127.0.1.2', hostname='h202.temp2') # create temp networks terminator = NetworkTerminator.objects.create(name='T100') net1 = Network.objects.create( name='net1', address='127.0.1.0/24', data_center=self.dc_temp1, reserved=1, gateway='127.0.0.254', environment=self.env_temp1, ) net1.terminators.add(terminator) net1.save() net2 = Network.objects.create( name='net2', address='127.0.0.0/24', data_center=self.dc_temp1, gateway='127.0.0.254', environment=self.env_temp1, ) net2.terminators.add(terminator) net2.save() net3 = Network.objects.create( name='net3', address='192.168.0.1/28', data_center=self.dc_temp1, gateway='127.0.0.254', environment=self.env_temp1, ) net3.terminators.add(terminator) net3.reserved = 1 net3.reserved_top_margin = 15 net3.save()
def _run_ssh_catalyst(ip): ssh = _connect_ssh(ip) try: mac = '\n'.join(ssh.cisco_command( "show version | include Base ethernet MAC Address" )) raw = '\n'.join(ssh.cisco_command("show inventory")) finally: ssh.close() mac = mac.strip() if mac.startswith("Base ethernet MAC Address") and ':' in mac: ethernets = [ Eth( "Base ethernet MAC Address", mac.split(':', 1)[1].strip(), None, ), ] else: ethernets = None inventory = list(cisco_inventory(raw)) serials = [inv['sn'] for inv in inventory] dev_inv = inventory[0] try: dev = Device.objects.get(sn__in=serials) except MultipleObjectsReturned: raise Error( "Stacked devices with serials %r should be merged.", serials, ) except Device.DoesNotExist: sn = dev_inv['sn'] model_name='Cisco %s' % dev_inv['pid'] else: # This is a stacked device, use the base device for it sn = dev.sn model_name = dev.model.name dev = Device.create( ethernets=ethernets, sn=sn, model_name=model_name, model_type=DeviceType.switch, name=dev_inv['descr'][:255], ) dev.save(update_last_seen=True) for inv in inventory: cisco_component(dev, inv) ip_address, created = IPAddress.concurrent_get_or_create(address=str(ip)) if created: ip_address.hostname = network.hostname(ip_address.address) ip_address.device = dev ip_address.is_management = True ip_address.save(update_last_seen=True) return dev.name
def _create_device(data): ethernets = [ Eth('DEPLOYMENT MAC', MACAddressField.normalize(data['mac']), EthernetSpeed.unknown) ] dev = Device.create( ethernets=ethernets, model_type=DeviceType.unknown, model_name='Unknown', verified=True, ) dev.name = data['hostname'] try: dev.parent = Device.objects.get(sn=data['rack_sn']) except Device.DoesNotExist: pass dev.save() IPAddress.objects.create( address=data['ip'], device=dev, hostname=data['hostname'], ) if management_ip_unique(data['management_ip']): IPAddress.objects.create(address=data['management_ip'], device=dev, is_management=True) return dev
def run_http_ibm_system_x(ip): session_id = get_session_id(ip) management_url = "http://%s/wsman" % ip model_name = get_model_name(management_url, session_id) sn = get_sn(management_url, session_id) macs = get_mac_addresses(management_url, session_id) ethernets = [Eth(label=label, mac=mac, speed=0) for (label, mac) in macs] ipaddr, ip_created = IPAddress.concurrent_get_or_create(address=ip) ipaddr.is_management = True ipaddr.save() dev = Device.create( ethernets=ethernets, model_name=model_name, sn=sn, model_type=DeviceType.rack_server, ) dev.management = ipaddr dev.save(priority=SAVE_PRIORITY) ipaddr.device = dev ipaddr.save() detected_memory = get_memory(management_url, session_id) detected_memory_indexes = [x.get('index') for x in detected_memory] for m in dev.memory_set.exclude(index__in=detected_memory_indexes): m.delete() for m in detected_memory: index = m['index'] mem, _ = Memory.concurrent_get_or_create(index=index, device=dev) mem.label = m['label'] mem.size = m['size'] mem.save(priority=SAVE_PRIORITY) mem.model, c = ComponentModel.concurrent_get_or_create( name='RAM %s %dMiB' % (mem.label, mem.size), size=mem.size, type=ComponentType.memory.id, family=mem.label, cores=0 ) mem.save(priority=SAVE_PRIORITY) detected_processors = get_processors(management_url, session_id) detected_processors_keys = [x.get('index') for x in detected_processors] for cpu in dev.processor_set.exclude(index__in=detected_processors_keys): cpu.delete() # add new for p in detected_processors: processor_model, _ = ComponentModel.concurrent_get_or_create( name=p.get('label'), speed=p.get('speed'), type=ComponentType.processor.id, family=p.get('family'), cores=p.get('cores') ) processor, _ = Processor.concurrent_get_or_create( device=dev, index=p.get('index'), ) processor.label = p.get('label') processor.model = processor_model processor.speed = p.get('speed') processor.save() return model_name
def _validate_mac(mac, parsed_macs, row_number): if not is_mac_valid(Eth("", mac, "")): raise forms.ValidationError("Row %s: Invalid MAC address." % row_number) if mac in parsed_macs: raise forms.ValidationError("Row %s: Duplicated MAC address. " "Please check previous rows..." % row_number)
def save_device_data(data, remote_ip): device = data['device'] ethernets = [ Eth(e.get('label'), MACAddressField.normalize(e.get('mac')), str_to_ethspeed(e.get('speed'))) for e in data['ethernets'] if MACAddressField.normalize(e.get('mac')) not in MAC_PREFIX_BLACKLIST ] sn = device.get('sn') vendor = device.get('vendor', '') if not ethernets and not sn: raise NoRequiredDataError('No MAC addresses and no device SN.') ip_addresses = [ e['ipaddress'] for e in data['ethernets'] if e.get('ipaddress') ] if not ip_addresses: raise NoRequiredIPAddressError( "Couldn't find any IP address for this device.") try: dev = Device.create(sn=sn, ethernets=ethernets, model_name='%s %s %s' % ( device.get('caption'), vendor, device.get('version'), ), model_type=DeviceType.unknown, priority=SAVE_PRIORITY) except ValueError as e: DiscoveryWarning( message="Failed to create device: " + str(e), plugin=__name__, ip=str(remote_ip), ).save() return None dev.save(priority=SAVE_PRIORITY) os = data['operating_system'] o = OperatingSystem.create(dev, os_name=os.get('label'), family='Windows', priority=SAVE_PRIORITY) o.memory = int(os['memory']) o.storage = int(os['storage']) o.cores_count = int(os['corescount']) o.save(priority=SAVE_PRIORITY) for ip in ip_addresses: ip_address, _ = IPAddress.concurrent_get_or_create(address=str(ip)) ip_address.device = dev ip_address.is_management = False ip_address.save() vendor = vendor.lower() is_virtual = any(virtual in vendor for virtual in CPU_VIRTUAL_LIST) save_processors(data['processors'], dev, is_virtual) save_memory(data['memory'], dev) save_storage(data['storage'], dev) save_shares(data['shares'], dev, ip_address) save_fibre_channel(data['fcs'], dev) save_software(data.get('software', []), dev) return dev
def get_ethernets(ssh): """Get the MAC addresses""" stdin, stdout, stderr = ssh.exec_command( "/sbin/ip addr show | /bin/grep 'link/ether'") ethernets = [ Eth(label='', mac=line.split(None, 3)[1], speed=0) for line in stdout ] return ethernets
def _dev(model_type, pairs, parent, raw): if 'Mach type/model' in pairs: model_name = '%s (%s)' % (pairs['Mach type/model'], pairs['Part no.']) elif 'Part no.' in pairs: model_name = pairs['Part no.'] else: raise DeviceError('No model/part no.') if not model_name.startswith('IBM'): model_name = 'IBM ' + model_name sn = pairs.get('Mach serial number') if sn in SERIAL_BLACKLIST: sn = None if not sn: sn = pairs['FRU serial no.'] if sn in SERIAL_BLACKLIST: sn = None mac = pairs.get('MAC Address 1', None) if mac: ethernets = [Eth('MAC Address 1', mac, None)] else: ethernets = [] name = pairs.get('Name') or pairs.get('Product Name') or model_name dev = Device.create(ethernets=ethernets, model_name=model_name, model_type=model_type, sn=sn, raw=raw, name=name, parent=parent, priority=SAVE_PRIORITY) firmware = (pairs.get('AMM firmware') or pairs.get('FW/BIOS') or pairs.get('Main Application 2')) if firmware: dev.hard_firmware = '%s %s rev %s' % ( firmware['Build ID'], firmware['Rel date'], firmware['Rev']) else: firmware = pairs.get('Power Module Cooling Device firmware rev.') if firmware: dev.hard_firmware = 'rev %s' % firmware firmware = (pairs.get('Boot ROM') or pairs.get('Main Application 1') or pairs.get('Blade Sys Mgmt Processor')) if firmware: dev.boot_firmware = '%s %s rev %s' % ( firmware['Build ID'], firmware['Rel date'], firmware['Rev']) firmware = (pairs.get('Blade Sys Mgmt Processor')) if firmware: dev.mgmt_firmware = '%s %s rev %s' % ( firmware['Build ID'], firmware['Rel date'], firmware['Rev']) firmware = (pairs.get('Diagnostics')) if firmware: dev.diag_firmware = '%s %s rev %s' % ( firmware['Build ID'], firmware['Rel date'], firmware['Rev']) dev.save(update_last_seen=True, priority=SAVE_PRIORITY) return dev
def snmp_vmware(parent, ipaddr, **kwargs): ip = str(kwargs['ip']) community = str(kwargs['community']) oid = (1,3,6,1,4,1,6876,2,4,1,7) snmp_version = 1 for mac in snmp_macs(ip, community, oid, attempts=2, timeout=3, snmp_version=snmp_version): dev = Device.create(parent=parent, management=ipaddr, ethernets=[Eth(mac=mac, label='Virtual MAC', speed=0)], model_name='VMware ESX virtual server', model_type=DeviceType.virtual_server)
def _get_mac_addresses(ssh): """Get the MAC addresses""" stdin, stdout, stderr = ssh.exec_command( "/sbin/ip addr show | /bin/grep 'link/ether'", ) mac_addresses = set() for line in stdout: mac_address = line.split(None, 3)[1] if is_mac_valid(Eth(label='', mac=mac_address, speed=0)): mac_addresses.add(mac_address) return list(mac_addresses)
def _save_device(ip, name, model_name, sn, macs): ethernets = [Eth(mac=mac, label='MAC', speed=0) for mac in macs] dev = Device.create(sn=sn, model_name=model_name, ethernets=ethernets, model_type=DeviceType.storage, name=name) ipaddr, ip_created = IPAddress.concurrent_get_or_create(address=ip) ipaddr.device = dev ipaddr.is_management = True ipaddr.save() dev.management = ipaddr dev.save() return dev
def run_ssh_asa(ip): ssh = _connect_ssh(ip) try: lines = ssh.asa_command( "show version | grep (^Hardware|Boot microcode|^Serial|address is)" ) raw_inventory = '\n'.join(ssh.asa_command("show inventory")) finally: ssh.close() pairs = parse.pairs(lines=[line.strip() for line in lines]) sn = pairs.get('Serial Number', None) model, ram, cpu = pairs['Hardware'].split(',') boot_firmware = pairs['Boot microcode'] ethernets = [] for i in xrange(99): try: junk, label, mac = pairs['%d' % i].split(':') except KeyError: break mac = mac.split(',', 1)[0] mac = mac.replace('address is', '') mac = mac.replace('.', '').upper().strip() label = label.strip() ethernets.append(Eth(label, mac, speed=None)) dev = Device.create(ethernets=ethernets, sn=sn, model_name=model, model_type=DeviceType.firewall, boot_firmware=boot_firmware) dev.save(update_last_seen=True) inventory = list(cisco_inventory(raw_inventory)) for inv in inventory: cisco_component(dev, inv) ipaddr, created = IPAddress.concurrent_get_or_create(address=ip) ipaddr.device = dev ipaddr.is_management = True ipaddr.save() for label, mac, speed in ethernets: eth, created = Ethernet.concurrent_get_or_create( mac=mac, defaults={'device': dev}, ) eth.label = label eth.device = dev eth.save() return model
def _get_ethernets(data): for mezz in data['PORTMAP']['MEZZ']: name = mezz['DEVICE']['NAME'] ports = mezz['DEVICE']['PORT'] if isinstance(ports, dict): ports = [ports] for port in ports: if port['TYPE'] == 'INTERCONNECT_TYPE_ETH': try: mac = MACAddressField.normalize(port['WWPN']) except ValueError: continue yield Eth(name, mac, speed=None)
def run_http(ip): macs = _get_macs(ip) ethernets = [ Eth(label=label, mac=mac, speed=0) for (label, mac) in macs.iteritems() ] ipaddr = IPAddress.objects.get(address=ip) dev = Device.create(ethernets=ethernets, model_name='Unknown Supermicro', model_type=DeviceType.unknown) ipaddr.device = dev ipaddr.save() return ', '.join(macs.values())
def _add_cluster_member(ssh, ip): stdin, stdout, stderr = ssh.exec_command("ifconfig eth0 | head -n 1") mac = stdout.readline().split()[-1] dev = Device.create(ethernets=[Eth(label='eth0', mac=mac, speed=0)], model_name='Proxmox', model_type=DeviceType.unknown) Software.create(dev, 'proxmox', 'Proxmox', family='Virtualization').save() ipaddr, ip_created = IPAddress.concurrent_get_or_create(address=ip) ipaddr.is_management = False ipaddr.device = dev ipaddr.save() return dev
def _run_ipmi(ip): try: ipmi = IPMI(ip) fru = ipmi.get_fru() except AuthError: try: ipmi = IPMI(ip, 'ADMIN') fru = ipmi.get_fru() except AuthError: ipmi = IPMI(ip, 'ADMIN', 'ADMIN') fru = ipmi.get_fru() mc = ipmi.get_mc() top = fru['/SYS'] if not top: top = fru['Builtin FRU Device'] if not top: raise AnswerError('Incompatible answer.') name, name_clean = _clean(top['Product Name']) sn, sn_clean = _clean(top['Product Serial']) if sn in SERIAL_BLACKLIST: sn = None model_type = DeviceType.rack_server if name.lower().startswith('ipmi'): model_type = DeviceType.unknown mac = ipmi.get_mac() if mac: ethernets = [Eth(label='IPMI MAC', mac=mac, speed=0)] else: ethernets = [] ethernets.extend(_get_ipmi_ethernets(fru)) dev = Device.create(ethernets=ethernets, priority=SAVE_PRIORITY, sn=sn, model_name=name.title(), model_type=model_type) firmware = mc.get('Firmware Revision') if firmware: dev.mgmt_firmware = 'rev %s' % firmware _add_ipmi_lan(dev, mac) _add_ipmi_components(dev, fru) dev.save(update_last_seen=True, priority=SAVE_PRIORITY) ip_address, created = IPAddress.concurrent_get_or_create(address=str(ip)) ip_address.device = dev ip_address.is_management = True if created: ip_address.hostname = network.hostname(ip_address.address) ip_address.snmp_name = name ip_address.save(update_last_seen=True) # no priorities for IP addresses return name
def handle_facts_ethernets(facts): ethernets = [] ip_addresses = [] for interface in facts['interfaces'].split(','): try: ip = network.validate_ip(facts['ipaddress_{}'.format(interface)]) ip_addresses.append(ip) except (ValueError, KeyError): pass mac = facts.get('macaddress_{}'.format(interface)) if not mac: continue label = 'Ethernet {}'.format(interface) ethernets.append(Eth(label, mac, speed=None)) return ip_addresses, ethernets
def _get_ipmi_ethernets(data): # Ethernet index = 0 while True: ethernet = data['MB/NET{}'.format(index)] if not ethernet: return mac = ethernet['Product Serial'] label = " ".join((ethernet['Product Manufacturer'], ethernet['Product Name'])).title() if 'GIGABIT' in ethernet['Product Name']: speed = EthernetSpeed.s1gbit.id else: speed = 0 yield Eth(label=label, mac=mac, speed=speed) index += 1
def clean_macs(self): sn = self.cleaned_data['sn'] macs_text = self.cleaned_data['macs'] macs = [] for mac in macs_text.split(' \r\n\t,;'): if not mac: continue try: eth = Eth('', MACAddressField.normalize(mac), 0) if is_mac_valid(eth): macs.append(eth.mac) except ValueError as e: raise forms.ValidationError(e) if not (macs or sn): raise forms.ValidationError( "Either MACs or serial number required.") return ' '.join(macs)
def post(self, request, *args, **kwargs): from ralph.urls import LATEST_API actor = User.objects.get( username=ApiKeyAuthentication().get_identifier(request)) if not actor.has_perm('create_devices'): raise HttpResponse(_('You cannot create new devices'), status=401) data = Serializer().deserialize(request.body, format=request.META.get( 'CONTENT_TYPE', 'application/json')) mac = MACAddressField.normalize(data['mac']) parent = self.get_parent_device(data) ip_addr = get_first_free_ip(data['network']) hostname = self.get_hostname(parent) venture = get_object_or_404(Venture, symbol=data['venture']) role = get_object_or_404(VentureRole, venture=venture, name=data['venture-role']) ethernets = [Eth( 'DEPLOYMENT MAC', mac, EthernetSpeed.unknown, )] device = Device.create( ethernets=ethernets, model_type=DeviceType.unknown, model_name='Unknown', verified=True, ) device.name = hostname device.parent = parent device.venture = venture device.venture_role = role device.save() IPAddress.objects.create( address=ip_addr, device=device, hostname=hostname, ) reset_dns(hostname, ip_addr) reset_dhcp(ip_addr, data['mac']) resp = HttpResponse('', status=201) resp['Location'] = LATEST_API.canonical_resource_for( 'dev').get_resource_uri(device) return resp
def _run_ipmi(ip): try: ipmi = IPMI(ip) fru = ipmi.get_fru() except AuthError: try: ipmi = IPMI(ip, 'ADMIN') fru = ipmi.get_fru() except AuthError: ipmi = IPMI(ip, 'ADMIN', 'ADMIN') fru = ipmi.get_fru() mc = ipmi.get_mc() top = fru['/SYS'] if not top: top = fru['Builtin FRU Device'] if not top: raise AnswerError('Incompatible answer.') name, sn, model_type = _get_base_device_info(top) mac = ipmi.get_mac() if mac: ethernets = [Eth(label='IPMI MAC', mac=mac, speed=0)] else: ethernets = [] ethernets.extend(_get_ipmi_ethernets(fru)) dev = Device.create(ethernets=ethernets, priority=SAVE_PRIORITY, sn=sn, model_name=name.title(), model_type=model_type) firmware = mc.get('Firmware Revision') if firmware: dev.mgmt_firmware = 'rev %s' % firmware _add_ipmi_lan(dev, mac) _add_ipmi_components(dev, fru) dev.save(update_last_seen=True, priority=SAVE_PRIORITY) ip_address, created = IPAddress.concurrent_get_or_create(address=str(ip)) ip_address.device = dev ip_address.is_management = True if created: ip_address.hostname = network.hostname(ip_address.address) ip_address.snmp_name = name ip_address.save(update_last_seen=True) return name
def run_ssh_ganeti(ip): ssh = _connect_ssh(ip) master_hostname = get_master_hostname(ssh) try: master_ip = IPAddress.objects.get( Q(hostname=master_hostname) | Q(address=master_hostname) ) except IPAddress.DoesNotExist: raise Error('unknown master hostname %r' % master_hostname) if master_ip.address != ip: raise Error('not a cluster master.') existing_macs = set() for hostname, primary_node, address, mac in get_instances(ssh): parent = get_device(primary_node) existing_macs.add(mac) dev = Device.create( ethernets=[Eth(label='eth0', mac=mac, speed=0)], parent=parent, management=master_ip, model_name='Ganeti', model_type=DeviceType.virtual_server, family='Virtualization', priority=SAVE_PRIORITY, ) dev.name = hostname dev.save(priority=SAVE_PRIORITY) if address: ip_address, created = IPAddress.concurrent_get_or_create( address=address, ) ip_address.device = dev ip_address.save() for dev in Device.objects.filter( management=master_ip, model__name='Ganeti', ).exclude( ethernet__mac__in=existing_macs, ): dev.deleted = True dev.save(priority=SAVE_PRIORITY) return master_hostname
def handle_lshw_ethernets(lshw): ethernets = sorted((e for e in jpath.get_all('..network', lshw) if e), key=get_logical_name) for i, ethernet in enumerate(untangle(ethernets)): try: mac = MACAddressField.normalize(ethernet['serial']) except (ValueError, KeyError): continue if not mac: continue full_name = ethernet['product'] if ethernet['vendor'] not in full_name: full_name = "{} {}".format(ethernet['vendor'], full_name) label = "{}: {}".format(get_logical_name(ethernet), full_name) caps = set(ethernet['capabilities'].keys()) if '1000bt-fd' in caps or '1000bt' in caps: speed = EthernetSpeed.s1gbit.id elif '100bt-fd' in caps or '100bt' in caps: speed = EthernetSpeed.s100mbit.id else: speed = None yield Eth(label, mac, speed)
def run_ssh_ssg(ip): ssh = _connect_ssh(ip) lines = ssh.ssg_command('get system') pairs = parse.pairs(lines=lines[:10]) name = pairs['Product Name'] version = pairs['Hardware Version'].split(',', 1)[0] model = '%s %s' % (name, version) mac = pairs['Base Mac'].replace('.', '').upper() sn = pairs['Serial Number'].split(',', 1)[0] dev = Device.create(ethernets=[Eth(label='Base MAC', mac=mac, speed=0)], model_name=model, model_type=DeviceType.firewall, sn=sn, name=name, raw='\n'.join(lines)) dev.boot_firmware = pairs['Software Version'].split(',', 1)[0] dev.save(update_last_seen=True) ipaddr, created = IPAddress.concurrent_get_or_create(address=ip) ipaddr.device = dev ipaddr.is_management = True ipaddr.save() return dev.name
def create(cls, ethernets=None, sn=None, model=None, model_name=None, model_type=None, device=None, allow_stub=False, priority=0, **kwargs): if 'parent' in kwargs and kwargs['parent'] is None: del kwargs['parent'] if not model and (not model_name or not model_type): raise ValueError( 'Either provide model or model_type and model_name.') dev = device ethernets = [ Eth(*e) for e in (ethernets or []) if is_mac_valid(Eth(*e)) ] if ethernets: macs = set( [MACAddressField.normalize(eth.mac) for eth in ethernets]) devs = Device.admin_objects.filter( ethernet__mac__in=macs).distinct() if len(devs) > 1: raise ValueError('Multiple devices match MACs: %r' % macs) elif len(devs) == 1: if dev and devs[0].id != dev.id: raise ValueError('Conflict of devices %r and %r!' % (dev, devs[0])) else: dev = devs[0] if sn: sn = sn.strip() if sn in SERIAL_BLACKLIST: sn = None if not any((sn, ethernets, allow_stub)): raise ValueError( "Neither `sn` nor `ethernets` given. Use `allow_stub` " "to override.") if sn: try: sndev = Device.admin_objects.get(sn=sn) except Device.DoesNotExist: pass else: if dev is None: dev = sndev elif sndev.id != dev.id: # both devices are properly placed in the tree if any(( sndev.parent and dev.parent, # the device found using ethernets (or explicitly # given as `device`) has different sn than `sn` dev.sn and dev.sn != sn, # the device found using `sn` already has other # ethernets sndev.ethernet_set.exists())): raise ValueError('Conflict of devices %r and %r!' % (dev, sndev)) sndev.delete() if model is None: model, model_created = DeviceModel.concurrent_get_or_create( name=model_name, defaults={ 'type': model_type.id, }, ) if dev is None: dev, created = Device.concurrent_get_or_create( sn=sn, defaults={ 'model': model, }, ) elif dev.deleted: # Ignore the priority and undelete even if it was manually deleted priorities = dev.get_save_priorities() priorities['deleted'] = 0 dev.update_save_priorities(priorities) dev.deleted = False if model and model.type != DeviceType.unknown.id: dev.model = model if not dev.sn and sn: dev.sn = sn for k, v in kwargs.iteritems(): if k in ('name', 'last_seen'): continue setattr(dev, k, v) try: user = kwargs.get('user') except KeyError: user = None dev.save(user=user, update_last_seen=True, priority=priority) for eth in ethernets: ethernet, eth_created = Ethernet.concurrent_get_or_create( mac=eth.mac, defaults={ 'device': dev, }, ) ethernet.device = dev ethernet.label = eth.label or 'Autocreated' if eth.speed: ethernet.speed = eth.speed ethernet.save(priority=priority) return dev
def do_snmp_mac(snmp_name, community, snmp_version, ip, kwargs): oid = (1, 3, 6, 1, 2, 1, 2, 2, 1, 6) sn = None is_management = False if snmp_name.lower().startswith('sunos'): model_name = 'SunOs' model_type = DeviceType.unknown elif snmp_name.lower().startswith('hardware:') and 'Windows' in snmp_name: model_name = 'Windows' model_type = DeviceType.unknown elif snmp_name.lower().startswith('vmware esx'): model_name = 'VMware ESX' model_type = DeviceType.unknown oid = (1, 3, 6, 1, 2, 1, 2, 2, 1, 6) snmp_version = 1 elif snmp_name.startswith('IronPort'): parts = snmp_name.split(',') model_name = parts[0].strip() model_type = DeviceType.smtp_gateway is_management = True elif snmp_name.startswith('Intel Modular'): model_type = DeviceType.blade_system model_name = 'Intel Modular Blade System' is_management = True elif snmp_name.startswith('IBM PowerPC CHRP Computer'): model_type = DeviceType.unknown model_name = 'IBM pSeries' elif 'Software:UCOS' in snmp_name: model_name = 'Cisco UCOS' model_type = DeviceType.appliance is_management = True elif snmp_name.startswith('Codian'): model_name = snmp_name model_type = DeviceType.appliance is_management = True elif snmp_name.startswith('APC'): m = re.search(r'\sMN:\s*(\S+)', snmp_name) model_name = m.group(1) if m else 'APC' m = re.search(r'\sSN:\s*(\S+)', snmp_name) sn = m.group(1) if m else None is_management = True model_type = DeviceType.power_distribution_unit elif 'fibre channel switch' in snmp_name.lower() or 'san switch module' in snmp_name.lower(): model_name = snmp_name model_type = DeviceType.fibre_channel_switch is_management = True elif 'ethernet switch module' in snmp_name.lower() or snmp_name.startswith('ProCurve'): model_name= snmp_name if ',' in model_name: model_name, trash = model_name.split(',', 1) model_type = DeviceType.switch is_management = True elif '.f5app' in snmp_name: model_name, sn = snmp_f5(**kwargs) model_type = DeviceType.load_balancer elif 'StorageWorks' in snmp_name: model_name = snmp_name model_type = DeviceType.storage elif 'linux' in snmp_name.lower(): model_name = 'Linux' model_type = DeviceType.unknown else: model_name = 'Unknown' model_type = DeviceType.unknown raise Error('no match.') ethernets = [] for mac in snmp_macs(ip, community, oid, attempts=2, timeout=3, snmp_version=snmp_version): # Skip virtual devices if mac[0:6] in MAC_PREFIX_BLACKLIST: continue if snmp_name.startswith('Brocade') and not mac.startswith('00051E'): # Only use the first right mac of the Brocade switches, the rest is trash. continue if model_name == 'Windows' and mac.startswith('000C29'): # Skip VMWare interfaces on Windows continue if mac.startswith('0001D7') and model_type != DeviceType.load_balancer: # This is an F5 model_name, sn = snmp_f5(**kwargs) model_type = DeviceType.load_balancer ethernets.append(Eth('SNMP MAC', mac, speed=None)) if model_type == DeviceType.load_balancer: # For F5, macs that start with 02 are the maqueraded macs ethernets = [e for e in ethernets if not e.mac.startswith('02')] if not ethernets and not sn: raise Error('no MAC.') name = snmp_name dev = Device.create(ethernets=ethernets, model_name=model_name, model_type=model_type, name=name, sn=sn) ip_address = IPAddress.objects.get(address=str(ip)) ip_address.device = dev ip_address.is_management = is_management if is_management: dev.management = ip_address if model_name == 'VMware ESX': snmp_vmware(dev, ip_address, **kwargs) ip_address.save() if model_name.startswith('IronPort'): pairs = dict((k.strip(), v.strip()) for (k, v) in (part.split(':') for part in parts if ':' in part)) dev.boot_firmware = 'AsyncOS %s %s' % ( pairs.get('AsyncOS Version'), pairs.get('Build Date')) dev.sn = pairs.get('Serial #') dev.save(update_last_seen=True) elif model_name == 'Intel Modular Blade System': _snmp_modular(ip, community, dev) if not dev.operatingsystem_set.exists(): if model_name == 'Linux': OperatingSystem.create(dev, os_name=snmp_name, family='Linux').save() elif model_name == 'SunOs': OperatingSystem.create(dev, os_name=snmp_name, family='Sun').save() return ethernets