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