Python Device.save方法代码示例

# 需要导入模块: from ralph.discovery.models import Device [as 别名]
# 或者: from ralph.discovery.models.Device import save [as 别名]
 def test_deployment_entry(self):
     dc = DataCenter(name="dc1", next_server="ziew")
     dc.save()
     net = Network(name="net", address="127.0.0.0/24", data_center=dc)
     net.save()
     entry = DHCPEntry(ip="127.0.0.1", mac="deadbeefcafe")
     entry.save()
     device = Device(sn="ziew")
     device.save()
     deployment = Deployment(ip="127.0.0.1", mac="deadbeefcafe", device=device)
     deployment.save()
     config = generate_dhcp_config(dc=dc)
     # remove first line with the date and last line
     config = "\n".join(config.splitlines()[1:-1])
     self.assertEqual(
         config,
         "host 127.0.0.1 { fixed-address 127.0.0.1; " "hardware ethernet DE:AD:BE:EF:CA:FE; next-server ziew; }",
     )

# 需要导入模块: from ralph.discovery.models import Device [as 别名]
# 或者: from ralph.discovery.models.Device import save [as 别名]
    def test_correct_request(self):
        # prepare sample device
        dev = Device(
            name='sample.dc',
            sn='sn123123123_1'
        )
        dev.dc = 'DC'
        dev.save(priority=215)

        # test it
        response = self.client.post(
            '/ui/unlock-field/',
            {
                'device': dev.pk,
                'field': 'dc'
            },
            follow=True
        )
        self.assertEqual(response.status_code, 200)
        dev = Device.objects.get(pk=dev.pk)
        priorities = dev.get_save_priorities()
        self.assertEqual(priorities['dc'], 0)

# 需要导入模块: from ralph.discovery.models import Device [as 别名]
# 或者: from ralph.discovery.models.Device import save [as 别名]
 def test_deployment_entry(self):
     dc = DataCenter(name='dc1', next_server='ziew')
     dc.save()
     net = Network(name='net', address='127.0.0.0/24', data_center=dc)
     net.save()
     entry = DHCPEntry(ip='127.0.0.1', mac='deadbeefcafe')
     entry.save()
     device = Device(sn='ziew')
     device.save()
     deployment = Deployment(
         ip='127.0.0.1',
         mac='deadbeefcafe',
         device=device,
     )
     deployment.save()
     config = generate_dhcp_config(dc=dc)
     # remove first line with the date and last line
     config = '\n'.join(config.splitlines()[1:-1])
     self.assertEqual(
         config,
         'host 127.0.0.1 { fixed-address 127.0.0.1; '
         'hardware ethernet DE:AD:BE:EF:CA:FE; next-server ziew; }'
     )

# 需要导入模块: from ralph.discovery.models import Device [as 别名]
# 或者: from ralph.discovery.models.Device import save [as 别名]
class GetDeviceDataTest(TestCase):
    def setUp(self):
        self.device_model = DeviceModel(type=DeviceType.rack_server, name="ziew-X")
        self.device_model.save()
        self.device = Device(model=self.device_model, sn="123456789", name="ziew")
        self.device.save()

    def test_basic_data(self):
        data = get_device_data(Device.objects.get(sn="123456789"))
        self.assertEqual(data["serial_number"], "123456789")
        self.assertEqual(data["hostname"], "ziew")
        self.assertEqual(data["type"], "rack server")
        self.assertEqual(data["model_name"], "ziew-X")

    def test_position(self):
        self.device.chassis_position = 3
        self.device.dc = "dc3"
        self.device.rack = "232"
        self.device.save()
        data = get_device_data(Device.objects.get(sn="123456789"))
        self.assertEqual(data["chassis_position"], 3)
        self.assertEqual(data["data_center"], "dc3")
        self.assertEqual(data["rack"], "232")

    def test_memory(self):
        for i in xrange(8):
            m = Memory(label="ziew", size=128, device=self.device, index=i)
            m.save()
        data = get_device_data(Device.objects.get(sn="123456789"))
        memory = data["memory"]
        self.assertEqual(len(memory), 8)
        self.assertEqual(memory[0]["label"], "ziew")
        self.assertEqual(memory[0]["size"], 128)
        self.assertEqual(memory[3]["index"], 3)

    def test_processors(self):
        model = ComponentModel(type=ComponentType.processor, name="CPU Xeon 2533MHz, 4-core")
        model.save()
        for i in xrange(4):
            p = Processor(label="ziew", model=model, device=self.device, index=i)
            p.save()
        data = get_device_data(Device.objects.get(sn="123456789"))
        processors = data["processors"]
        self.assertEqual(len(processors), 4)
        self.assertEqual(processors[0]["label"], "ziew")
        self.assertEqual(processors[0]["model_name"], "CPU Xeon 2533MHz, 4-core")
        self.assertEqual(processors[0]["cores"], 4)
        self.assertEqual(processors[3]["index"], 3)

    def test_disks(self):
        model = ComponentModel(type=ComponentType.disk, name="HP DG0300BALVP SAS 307200MiB, 10000RPM")
        model.save()
        Storage(sn="abc3", device=self.device, label="ziew", mount_point="/dev/hda", model=model, size=307200).save()
        data = get_device_data(Device.objects.get(sn="123456789"))
        disks = data["disks"]
        self.assertEqual(len(disks), 1)
        self.assertEqual(disks[0]["size"], 307200)
        self.assertEqual(disks[0]["serial_number"], "abc3")
        self.assertEqual(disks[0]["mount_point"], "/dev/hda")

    def test_fc(self):
        model = ComponentModel(type=ComponentType.fibre, name="FC-336")
        model.save()
        FibreChannel(physical_id="deadbeefcafe", label="ziew", device=self.device, model=model).save()
        data = get_device_data(Device.objects.get(sn="123456789"))
        fc = data["fibrechannel_cards"]
        self.assertEqual(len(fc), 1)
        self.assertEqual(fc[0]["physical_id"], "deadbeefcafe")
        self.assertEqual(fc[0]["model_name"], "FC-336")

    def test_mac_addresses(self):
        for i in xrange(5):
            mac = "deadbeefcaf%d" % i
            Ethernet(mac=mac, device=self.device).save()

    def test_parts(self):
        model = ComponentModel(type=ComponentType.management, name="weapons of mass destruction")
        model.save()
        GenericComponent(label="ziew", device=self.device, model=model).save()
        data = get_device_data(Device.objects.get(sn="123456789"))
        parts = data["parts"]
        self.assertEqual(parts[0]["type"], "management")
        self.assertEqual(parts[0]["model_name"], "weapons of mass destruction")
        self.assertEqual(len(parts), 1)

    def test_software(self):
        model = ComponentModel(type=ComponentType.software, name="cobol")
        model.save()
        Software(
            label="cobol", device=self.device, model=model, version="1.0.0", path="/usr/bin/cobol", sn="0000001"
        ).save()
        data = get_device_data(Device.objects.get(sn="123456789"))
        soft = data["installed_software"]
        self.assertEqual(soft[0]["version"], "1.0.0")
        self.assertEqual(soft[0]["model_name"], "cobol")
        self.assertEqual(len(soft), 1)

    def test_disk_shares_and_exports(self):
        model = ComponentModel(type=ComponentType.share, name="3par share")
        model.save()
#.........这里部分代码省略.........

# 需要导入模块: from ralph.discovery.models import Device [as 别名]
# 或者: from ralph.discovery.models.Device import save [as 别名]
class SetDeviceDataTest(TestCase):
    def setUp(self):
        self.device_model = DeviceModel(type=DeviceType.rack_server, name="ziew-X")
        self.device_model.save()
        self.device = Device(model=self.device_model, sn="123456789", name="ziew")
        self.device.save()

    def test_basic_data(self):
        data = {
            "serial_number": "aaa123456789",
            "hostname": "mervin",
            "data_center": "chicago",
            "barcode": "00000",
            "rack": "i31",
            "chassis_position": "4",
            "management": "10.10.10.2",
        }
        set_device_data(self.device, data)
        self.device.save()
        device = Device.objects.get(sn="aaa123456789")
        self.assertEqual(device.sn, "aaa123456789")
        self.assertEqual(device.name, "mervin")
        self.assertEqual(device.dc, "chicago")
        self.assertEqual(device.barcode, "00000")
        self.assertEqual(device.rack, "i31")
        self.assertEqual(device.chassis_position, 4)
        self.assertEqual(device.management.address, "10.10.10.2")

    def test_basic_data_with_asset(self):
        asset = DCAssetFactory()
        asset.model.category.is_blade = False
        asset.model.category.save()
        data = {
            "serial_number": "aaa123456789",
            "hostname": "mervin",
            "data_center": "chicago",
            "barcode": "00000",
            "rack": "i31",
            "chassis_position": "4",
            "management": "10.10.10.2",
            "asset": asset,
        }
        warnings = []
        set_device_data(self.device, data, warnings=warnings)
        self.device.save()
        device = Device.objects.get(sn="aaa123456789")
        self.assertIsNone(device.dc)
        self.assertIsNone(device.rack)
        self.assertIsNone(device.chassis_position)
        self.assertIsNone(device.management)
        self.assertEqual(
            warnings,
            [
                "You can not set data for `chassis_position` here - skipped. " "Use assets module.",
                "You can not set data for `data_center` here - skipped. " "Use assets module.",
                "You can not set data for `rack` here - skipped. " "Use assets module.",
                "Management IP address (10.10.10.2) has been ignored. To " "change them, please use the Assets module.",
            ],
        )

    def test_model_name(self):
        data = {"type": "blade_server", "model_name": "ziew-Y"}
        set_device_data(self.device, data)
        self.device.save()
        device = Device.objects.get(sn="123456789")
        self.assertEqual(device.model.name, "ziew-Y")
        self.assertEqual(device.model.type, DeviceType.blade_server)
        data = {"type": "rack_server", "model_name": "ziew-X"}
        set_device_data(self.device, data)
        self.device.save()
        device = Device.objects.get(sn="123456789")
        self.assertEqual(device.model.name, "ziew-X")
        self.assertEqual(device.model.type, DeviceType.rack_server)

    def test_disks(self):
        data = {
            "disks": [
                {
                    "serial_number": "1234",
                    "size": "128",
                    "mount_point": "/dev/sda",
                    "label": "sda",
                    "family": "Simpsons",
                },
                {"size": "512", "mount_point": "/dev/sdb", "label": "sdb", "family": "Jetsons"},
            ]
        }
        set_device_data(self.device, data)
        self.device.save()
        device = Device.objects.get(sn="123456789")
        disks = list(device.storage_set.order_by("label"))
        self.assertEqual(disks[0].mount_point, "/dev/sda")
        self.assertEqual(disks[0].sn, "1234")
        self.assertEqual(disks[0].model.family, "Simpsons")
        self.assertEqual(disks[1].sn, None)
        self.assertEqual(disks[1].mount_point, "/dev/sdb")
        self.assertEqual(disks[1].model.family, "Jetsons")
        self.assertEqual(len(disks), 2)
        data = {
            "disks": [
#.........这里部分代码省略.........

# 需要导入模块: from ralph.discovery.models import Device [as 别名]
# 或者: from ralph.discovery.models.Device import save [as 别名]
class GetDeviceDataTest(TestCase):

    def setUp(self):
        self.device_model = DeviceModel(
            type=DeviceType.rack_server, name="ziew-X")
        self.device_model.save()
        self.device = Device(
            model=self.device_model,
            sn='123456789',
            name='ziew',
        )
        self.device.save()

    def test_basic_data(self):
        data = get_device_data(Device.objects.get(sn='123456789'))
        self.assertEqual(data['serial_number'], '123456789')
        self.assertEqual(data['hostname'], 'ziew')
        self.assertEqual(data['type'], 'rack server')
        self.assertEqual(data['model_name'], 'ziew-X')

    def test_position(self):
        self.device.chassis_position = 3
        self.device.dc = 'dc3'
        self.device.rack = '232'
        self.device.save()
        data = get_device_data(Device.objects.get(sn='123456789'))
        self.assertEqual(data['chassis_position'], 3)
        self.assertEqual(data['data_center'], 'dc3')
        self.assertEqual(data['rack'], '232')

    def test_memory(self):
        for i in xrange(8):
            m = Memory(
                label="ziew",
                size=128,
                device=self.device,
                index=i,
            )
            m.save()
        data = get_device_data(Device.objects.get(sn='123456789'))
        memory = data['memory']
        self.assertEqual(len(memory), 8)
        self.assertEqual(memory[0]['label'], "ziew")
        self.assertEqual(memory[0]['size'], 128)
        self.assertEqual(memory[3]['index'], 3)

    def test_processors(self):
        model = ComponentModel(
            type=ComponentType.processor,
            name="CPU Xeon 2533MHz, 4-core",
        )
        model.save()
        for i in xrange(4):
            p = Processor(
                label="ziew",
                model=model,
                device=self.device,
                index=i,
            )
            p.save()
        data = get_device_data(Device.objects.get(sn='123456789'))
        processors = data['processors']
        self.assertEqual(len(processors), 4)
        self.assertEqual(processors[0]['label'], "ziew")
        self.assertEqual(
            processors[0]['model_name'], "CPU Xeon 2533MHz, 4-core")
        self.assertEqual(processors[0]['cores'], 4)
        self.assertEqual(processors[3]['index'], 3)

    def test_disks(self):
        model = ComponentModel(
            type=ComponentType.disk,
            name="HP DG0300BALVP SAS 307200MiB, 10000RPM",
        )
        model.save()
        Storage(
            sn="abc3",
            device=self.device,
            label="ziew",
            mount_point="/dev/hda",
            model=model,
            size=307200,
        ).save()
        data = get_device_data(Device.objects.get(sn='123456789'))
        disks = data['disks']
        self.assertEqual(len(disks), 1)
        self.assertEqual(disks[0]['size'], 307200)
        self.assertEqual(disks[0]['serial_number'], "abc3")
        self.assertEqual(disks[0]['mount_point'], "/dev/hda")

    def test_fc(self):
        model = ComponentModel(
            type=ComponentType.fibre,
            name="FC-336",
        )
        model.save()
        FibreChannel(
            physical_id='deadbeefcafe',
            label='ziew',
            device=self.device,
#.........这里部分代码省略.........

# 需要导入模块: from ralph.discovery.models import Device [as 别名]
# 或者: from ralph.discovery.models.Device import save [as 别名]
class SetDeviceDataTest(TestCase):

    def setUp(self):
        self.device_model = DeviceModel(
            type=DeviceType.rack_server,
            name="ziew-X",
        )
        self.device_model.save()
        self.device = Device(
            model=self.device_model,
            sn='123456789',
            name='ziew',
        )
        self.device.save()

    def test_basic_data(self):
        data = {
            'serial_number': 'aaa123456789',
            'hostname': 'mervin',
            'data_center': 'chicago',
            'barcode': '00000',
            'rack': 'i31',
            'chassis_position': '4',
        }
        set_device_data(self.device, data)
        self.device.save()
        device = Device.objects.get(sn='aaa123456789')
        self.assertEqual(device.sn, 'aaa123456789')
        self.assertEqual(device.name, 'mervin')
        self.assertEqual(device.dc, 'chicago')
        self.assertEqual(device.barcode, '00000')
        self.assertEqual(device.rack, 'i31')
        self.assertEqual(device.chassis_position, 4)

    def test_model_name(self):
        data = {
            'type': 'blade_server',
            'model_name': 'ziew-Y',
        }
        set_device_data(self.device, data)
        self.device.save()
        device = Device.objects.get(sn='123456789')
        self.assertEqual(device.model.name, 'ziew-Y')
        self.assertEqual(device.model.type, DeviceType.blade_server)
        data = {
            'type': 'rack_server',
            'model_name': 'ziew-X',
        }
        set_device_data(self.device, data)
        self.device.save()
        device = Device.objects.get(sn='123456789')
        self.assertEqual(device.model.name, 'ziew-X')
        self.assertEqual(device.model.type, DeviceType.rack_server)

    def test_disks(self):
        data = {
            'disks': [
                {
                    'serial_number': '1234',
                    'size': '128',
                    'mount_point': '/dev/sda',
                    'label': 'sda',
                    'family': 'Simpsons',
                },
                {
                    'size': '512',
                    'mount_point': '/dev/sdb',
                    'label': 'sdb',
                    'family': 'Jetsons',
                },
            ],
        }
        set_device_data(self.device, data)
        self.device.save()
        device = Device.objects.get(sn='123456789')
        disks = list(device.storage_set.order_by('label'))
        self.assertEqual(disks[0].mount_point, '/dev/sda')
        self.assertEqual(disks[0].sn, '1234')
        self.assertEqual(disks[0].model.family, 'Simpsons')
        self.assertEqual(disks[1].sn, None)
        self.assertEqual(disks[1].mount_point, '/dev/sdb')
        self.assertEqual(disks[1].model.family, 'Jetsons')
        self.assertEqual(len(disks), 2)
        data = {
            'disks': [
                {
                    'mount_point': '/dev/sda',
                    'family': 'Simpsons',
                },
                {
                    'serial_number': '12346',
                    'mount_point': '/dev/sdb',
                },
            ],
        }
        set_device_data(self.device, data)
        self.device.save()
        device = Device.objects.get(sn='123456789')
        disks = list(device.storage_set.order_by('label'))
        self.assertEqual(disks[0].mount_point, '/dev/sda')
#.........这里部分代码省略.........