def _prepare_data_for_device_tests(self):
     self.sample_device = Device.create(
         sn='sn_123456789_1',
         model_name='sampleDevice',
         model_type=DeviceType.unknown,
     )
     self.other_sample_device = Device.create(
         sn='sn_123456789_2',
         model_name='otherSampleDevice',
         model_type=DeviceType.unknown,
     )
     created = datetime.datetime.now() - datetime.timedelta(days=31)
     change = CIChange(
         type=CI_CHANGE_TYPES.DEVICE,
         content_type=ContentType.objects.get_for_model(
             self.sample_device,
         ),
         object_id=self.sample_device.id,
         created=created,
         priority=CI_CHANGE_PRIORITY_TYPES.ERROR,
     )
     change.save()
     self.cichange_device_id = change.id
     change = CIChange(
         type=CI_CHANGE_TYPES.DEVICE,
         content_type=ContentType.objects.get_for_model(
             self.other_sample_device,
         ),
         object_id=self.other_sample_device.id,
         created=created + datetime.timedelta(days=2),
         priority=CI_CHANGE_PRIORITY_TYPES.ERROR,
     )
     change.save()
     self.not_touched_cichange_device_id = change.id

    def setUp(self):
        self.top_venture = Venture(name="top_venture")
        self.top_venture.save()

        self.child_venture = Venture(name="child_venture", parent=self.top_venture)
        self.child_venture.save()

        self.role = VentureRole(name="role", venture=self.child_venture)
        self.role.save()
        self.child_role = VentureRole(name="child_role", venture=self.child_venture, parent=self.role)
        self.child_role.save()
        dm = self.add_model("DC model sample", DeviceType.data_center.id)
        self.dc = Device.create(sn="sn1", model=dm)
        self.dc.name = "dc"
        self.dc.save()
        dm = self.add_model("Rack model sample", DeviceType.rack_server.id)
        self.rack = Device.create(venture=self.child_venture, sn="sn2", model=dm)
        self.rack.parent = self.dc
        self.rack.name = "rack"
        self.rack.save()
        dm = self.add_model("Blade model sample", DeviceType.blade_server.id)
        self.blade = Device.create(venture=self.child_venture, venturerole=self.child_role, sn="sn3", model=dm)
        self.blade.name = "blade"
        self.blade.parent = self.rack
        self.blade.save()

    def test_blade_server(self):
        encl = Device.create(sn='devicex', model_type=DeviceType.blade_system,
                             model_name='device encl')
        dev = Device.create(sn='device', model_type=DeviceType.blade_server,
                            model_name='device', parent=encl)

        encl_dmg = DeviceModelGroup(name='DeviceModelGroup encl')
        encl_dmg.slots = 4
        encl_dmg.price = 65535
        encl_dmg.save()
        encl.model.group = encl_dmg
        encl.model.save()

        dmg = DeviceModelGroup(name='DeviceModelGroup')
        dmg.price = 1337
        dmg.slots = 1
        dmg.save()
        dev.model.group = dmg
        dev.model.save()

        pricing.device_update_cached(encl)
        pricing.device_update_cached(dev)
        dev = Device.objects.get(id=dev.id)
        encl = Device.objects.get(id=encl.id)

        self.assertEquals(dev.cached_price, 17720.75)
        self.assertEquals(encl.cached_price, 49151.25)
        self.assertEquals(dev.cached_price + encl.cached_price, 65535 + 1337)

    def setUp(self):
        self.top_venture = Venture(name='top_venture')
        self.top_venture.save()

        self.child_venture = Venture(name='child_venture', parent=self.top_venture)
        self.child_venture.save()

        self.role = VentureRole(name='role', venture=self.child_venture)
        self.role.save()
        self.child_role = VentureRole(name='child_role',
                venture=self.child_venture,
                parent=self.role,
        )
        self.child_role.save()
        dm = self.add_model('DC model sample', DeviceType.data_center.id)
        self.dc = Device.create(sn='sn1', name='Rack 1', model=dm)
        dm = self.add_model('Rack model sample', DeviceType.rack_server.id)
        self.rack = Device.create(venture=self.child_venture, sn='sn2', name='DC', model=dm)
        self.rack.parent=self.dc
        self.rack.save()
        dm = self.add_model('Blade model sample', DeviceType.blade_server.id)
        self.blade = Device.create(
                venture=self.child_venture,
                venturerole=self.child_role,
                sn='sn3',
                name='blade1',
                model=dm
        )
        self.blade.parent=self.rack
        self.blade.save()

 def test_validate_deploy_children(self):
     _validate_deploy_children('deadbeefcafe', 0)
     parent = Device.create(
         ethernets=[('', 'deadbeefcafe', 0)],
         model_name='splat',
         model_type=DeviceType.unknown,
     )
     _validate_deploy_children('deadbeefcafe', 0)
     device = Device.create(
         ethernets=[('', 'cafedeadbeef', 0)],
         model_name='splat',
         model_type=DeviceType.unknown,
         parent=parent,
     )
     with self.assertRaises(forms.ValidationError):
         _validate_deploy_children('deadbeefcafe', 0)
     device.parent = None
     device.save()
     _validate_deploy_children('deadbeefcafe', 0)
     _validate_deploy_children('cafedeadbeef', 0)
     share = DiskShare(wwn='a' * 33, device=parent)
     share.save()
     mount = DiskShareMount(share=share, device=device, server=device)
     mount.save()
     with self.assertRaises(forms.ValidationError):
         _validate_deploy_children('deadbeefcafe', 0)
     with self.assertRaises(forms.ValidationError):
         _validate_deploy_children('cafedeadbeef', 0)

 def test_validate_hostname(self):
     _validate_hostname('whoosh', '11:22:33:aa:bb:cc', [], 0)
     with self.assertRaises(forms.ValidationError):
         _validate_hostname('whoosh', '22:33:11:aa:bb:dd', ['whoosh'], 0)
     device = Device.create(
         ethernets=[('', 'deadbeefcafe', 0)],
         model_name='splat',
         model_type=DeviceType.unknown,
     )
     deployment = Deployment(
         hostname='whoosh',
         ip='127.0.0.1',
         mac='deadbeefcafe',
         device=device,
         preboot=None,
         venture=None,
         venture_role=None,
     )
     deployment.save()
     with self.assertRaises(forms.ValidationError):
         _validate_hostname('whoosh', 'aa:bb:cc:11:22:33', [], 0)
     device = Device.create(
         ethernets=[('', 'aaccbb113322', 0)],
         model_name='unknown',
         model_type=DeviceType.unknown
     )
     device.name = 'some_name_1'
     device.save()
     _validate_hostname('some_name_1', 'aaccbb113322', [], 0)
     domain = Domain.objects.create(name='domain1')
     record_A = Record.objects.create(
         domain=domain,
         name='some_name_1',
         content='127.0.0.1',
         type='A'
     )
     with self.assertRaises(forms.ValidationError):
         _validate_hostname('some_name_1', 'aaccbb113322', [], 0)
     with self.assertRaises(forms.ValidationError):
         _validate_hostname('some_name_1', 'aaccbb113344', [], 0)
     device.ipaddress_set.create(address='127.0.0.1')
     _validate_hostname('some_name_1', 'aaccbb113322', [], 0)
     device.ipaddress_set.all().delete()
     record_A.delete()
     Record.objects.create(
         domain=domain,
         name='1.0.0.127.in-addr.arpa',
         content='some_name_1',
         type='PTR'
     )
     with self.assertRaises(forms.ValidationError):
         _validate_hostname('some_name_1', 'aaccbb113322', [], 0)
     device.ipaddress_set.create(address='127.0.0.1')
     _validate_hostname('some_name_1', 'aaccbb113322', [], 0)
     deployment.hostname = 'some_name_1'
     deployment.save()
     with self.assertRaises(forms.ValidationError):
         _validate_hostname('some_name_1', 'aaccbb113322', [], 0)

 def setUp(self):
     self.dev = Device.create(
         sn='device', model_type=DeviceType.virtual_server,
         model_name='device'
     )
     self.dev.save()
     self.dev2 = Device.create(
         sn='device2', model_type=DeviceType.virtual_server,
         model_name='device2'
     )

    def setUp(self):
        engine = settings.ISSUETRACKERS['default']['ENGINE']
        if engine != '':
            raise ImproperlyConfigured('''Expected ISSUETRACKERS['default']['ENGINE']='' got: %s''' % engine)
        # usual stuff
        self.top_venture = Venture(name='top_venture')
        self.top_venture.save()
        self.child_venture = Venture(name='child_venture', parent=self.top_venture)
        self.child_venture.save()
        self.role = VentureRole(name='role', venture=self.child_venture)
        self.role.save()
        self.child_role = VentureRole(name='child_role',
                venture=self.child_venture,
                parent=self.role,
        )
        self.child_role.save()
        to = VentureOwner(name='Bufallo Kudłaczek', venture=self.child_venture, type=OwnerType.technical.id)
        to.save()
        bo = VentureOwner(name='Bill Bąbelek', venture=self.child_venture, type=OwnerType.business.id)
        bo.save()

        dm = self.add_model('DC model sample', DeviceType.data_center.id)
        self.dc = Device.create(
                sn='sn1',
                model=dm
        )
        self.dc.name = 'dc'
        self.dc.save()
        dm = self.add_model('Rack model sample', DeviceType.rack_server.id)
        self.rack = Device.create(
                venture=self.child_venture,
                sn='sn2',
                model=dm
        )
        self.rack.parent=self.dc
        self.rack.name = 'rack'
        self.rack.save()
        dm = self.add_model('Blade model sample', DeviceType.blade_server.id)
        self.blade = Device.create(
                venture=self.child_venture,
                venturerole=self.child_role,
                sn='sn3',
                model=dm
        )
        self.blade.name = 'blade'
        self.blade.parent=self.rack
        self.blade.save()

        self.deployment = Deployment()
        self.deployment.hostname = 'test_host2'
        self.deployment.device=self.blade
        self.deployment.mac = '10:9a:df:6f:af:01'
        self.deployment.ip='192.168.1.1'
        self.deployment.hostname='test'
        self.deployment.save()

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):
        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 setUp(self):
     self.top_venture = Venture(name='top_venture')
     self.top_venture.save()
     self.child_venture = Venture(
         name='child_venture',
         parent=self.top_venture,
     )
     self.child_venture.save()
     self.role = VentureRole(
         name='role',
         venture=self.child_venture,
     )
     self.role.save()
     self.child_role = VentureRole(
         name='child_role',
         venture=self.child_venture,
         parent=self.role,
     )
     self.child_role.save()
     dm = self.add_model('DC model sample', DeviceType.data_center.id)
     self.dc = Device.create(sn='sn1', model=dm)
     self.dc.name = 'dc'
     self.dc.save()
     dm = self.add_model('Rack model sample', DeviceType.rack_server.id)
     self.rack = Device.create(
         venture=self.child_venture,
         sn='sn2',
         model=dm,
     )
     self.rack.parent = self.dc
     self.rack.name = 'rack'
     self.rack.save()
     dm = self.add_model('Blade model sample', DeviceType.blade_server.id)
     self.blade = Device.create(
         venture=self.child_venture,
         venturerole=self.child_role,
         sn='sn3',
         model=dm,
     )
     self.blade.name = 'blade'
     self.blade.parent = self.rack
     self.blade.save()
     self.deployment = Deployment()
     self.deployment.hostname = 'test_host2'
     self.deployment.device = self.blade
     self.deployment.mac = '10:9a:df:6f:af:01'
     self.deployment.ip = '192.168.1.1'
     self.deployment.hostname = 'test'
     self.deployment.save()

 def setUp(self):
     device = Device.create(
         ethernets=[('', 'deadbeefcafe', 0)],
         model_name='HAL 9000',
         model_type=DeviceType.unknown,
         remarks="I'm sorry, Dave.",
     )
     self.deployment = Deployment(
         hostname='discovery.one',
         ip='127.0.0.1',
         mac='deadbeefcafe',
         device=device,
         preboot=None,
         venture=None,
         venture_role=None,
     )
     self.deployment.save()
     self.ip = IPAddress(address='127.0.0.1', device=device)
     self.ip.save()
     IPAddress(address='127.0.0.2', device=device).save()
     share_model = ComponentModel(type=ComponentType.share, name="share")
     share_model.save()
     share = DiskShare(wwn='x'*33, device=device, model=share_model)
     share.save()
     DiskShareMount(share=share, device=device).save()
     OperatingSystem.create(os_name='GladOS', dev=device, family='',
                            priority=0)
     Software.create(dev=device, model_name='soft', path='/', family='',
                     priority=0)

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 handle_lshw(data, is_virtual=False, sn=None, priority=0):
    lshw = parse_lshw(as_string=data)
    prod_name = lshw['product']
    manufacturer = lshw['vendor'].replace(', Inc.', '')
    if prod_name.endswith(' ()'):
        prod_name = prod_name[:-3]
    if manufacturer and manufacturer in prod_name:
        model_name = prod_name
    else:
        model_name = "{} {}".format(manufacturer, prod_name)
    if is_virtual:
        model_type = DeviceType.virtual_server
    elif DeviceType.blade_server.matches(model_name):
        model_type = DeviceType.blade_server
    else:
        model_type = DeviceType.rack_server
    ethernets = list(handle_lshw_ethernets(lshw))
    if not ethernets:
        raise EthernetsError("Machine has no MAC addresses.")
    dev = Device.create(sn=sn, model_name=model_name, model_type=model_type,
        ethernets=ethernets, priority=priority)
    handle_lshw_memory(dev, lshw['bus']['memory'], is_virtual=is_virtual)
    handle_lshw_processors(dev, lshw['bus']['processor'], is_virtual=is_virtual)
    handle_lshw_storage(dev, lshw, is_virtual=is_virtual)
    handle_lshw_fibre_cards(dev, lshw, is_virtual=is_virtual)
    return dev

def run_idrac(ip):
    idrac = IDRAC(ip)
    base_info = idrac.get_base_info()
    model_name = "{} {}".format(
        base_info['manufacturer'].replace(" Inc.", ""),
        base_info['model']
    )
    ethernets = _save_ethernets(idrac.get_ethernets())
    ip_address, _ = IPAddress.concurrent_get_or_create(address=ip)
    ip_address.is_management = True
    ip_address.save()
    dev = Device.create(
        ethernets=ethernets,
        model_name=model_name,
        sn=base_info['sn'],
        model_type=DeviceType.rack_server,
    )
    dev.management = ip_address
    dev.save(priority=SAVE_PRIORITY)
    ip_address.device = dev
    ip_address.save()
    _save_cpu(dev, idrac.get_cpu())
    _save_memory(dev, idrac.get_memory())
    _save_storage(dev, idrac.get_storage())
    _save_fc_cards(dev, idrac.get_fc_cards())
    return model_name

def _cisco_snmp_model(model_oid, sn_oid, **kwargs):
    ip = str(kwargs['ip'])
    version = kwargs.get('snmp_version')
    if version == '3':
        community = SNMP_V3_AUTH
    else:
        community = str(kwargs['community'])
    model = snmp_command(
        ip,
        community,
        model_oid,
        attempts=2,
        timeout=3,
        snmp_version=version,
    )
    sn = snmp_command(
        ip,
        community,
        sn_oid,
        attempts=2,
        timeout=3,
        snmp_version=version,
    )
    if not (model and sn):
        return False, "silent.", kwargs
    sn = unicode(sn[0][1])
    model = 'Cisco %s' % unicode(model[0][1])
    dev = Device.create(sn=sn, model_name=model, model_type=DeviceType.switch)
    ip_address = IPAddress.objects.get(address=str(ip))
    ip_address.device = dev
    ip_address.is_management = True
    ip_address.save()
    return True, sn, kwargs

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 _run_ssh_catalyst(ip):
    ssh = _connect_ssh(ip)
    try:
        raw = "\n".join(ssh.cisco_command("show inventory"))
    finally:
        ssh.close()

    inventory = list(cisco_inventory(raw))

    serials = [inv["sn"] for inv in inventory]

    try:
        dev = Device.objects.get(sn__in=serials)
    except Device.DoesNotExist:
        dev_inv = inventory[0]
        dev = Device.create(
            sn=dev_inv["sn"],
            model_name="Cisco %s" % dev_inv["pid"],
            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 _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, priority=SAVE_PRIORITY)

def run_ssh_xen(ipaddr, parent):
    ssh = _connect_ssh(ipaddr.address)
    try:
        command = ("""ovsdb-tool query /etc/openvswitch/conf.db """
            """'["Open_vSwitch", {"""
            """ "op": "select","""
            """ "table": "Interface","""
            """ "where": [],"""
            """ "columns": ["external_ids"]"""
            """}]'""")
        # ovsdb-tool query /etc/openvswitch/conf.db '["Open_vSwitch", { "op": "select",  "table": "Interface", "where": [], "columns": ["external_ids"]}]'
        stdin, stdout, stderr = ssh.exec_command(command)
        data = json.loads(stdout.read())
        vms = {}
        for row in data[0]['rows']:
            try:
                ids = dict(row['external_ids'][1])
                vm_id = ids['xs-vm-uuid']
                mac = ids['attached-mac']
            except KeyError:
                continue
            vms[vm_id] = Eth(label='Virtual MAC', mac=mac, speed=0)
    finally:
        ssh.close()

    names = []
    for vm_id, ethernet in vms.iteritems():
        dev = Device.create(ethernets=[ethernet], parent=parent,
                model_type=DeviceType.virtual_server,
                model_name='XEN Virtual Server')
        names.append(dev.name or ethernet.mac)

    return ', '.join(names)