Esempio n. 1
0
 def update_vm_process(self, libvirt_id, vm_config):
     if self.vm_procs.get(libvirt_id) != vm_config.oid:
         vm_process = VmProcess(node=self, 
                                libvirt_id=libvirt_id, 
                                vm_config=vm_config)
         Cluster.instance().store(vm_process)
         self.vm_procs[libvirt_id] = vm_process.oid
Esempio n. 2
0
 def update_host_nic(self, name, **kw):
     nic = self.get_host_nic(name)
     if nic:
         nic.set(**kw)
     else:
         nic = HostNic(host=self, name=name, **kw)
         self.host_nics[name] = nic.oid
         Cluster.instance().store(nic)
Esempio n. 3
0
 def setUp(self):
     AsyncTestCase.setUp(self)
     for key in options.keys():
         del options[key]
     define_common_options()
     define_node_options()
     parse_config_file(os.path.join(DIR, 'config_data.py'))
     self.init_storages()
     self.node_oid = str(uuid.uuid1())
     Cluster.instance().init()
Esempio n. 4
0
 def storage(self):
     cluster = Cluster.instance()
     storage = cluster.get(self.storage_oid)
     if storage is None:
         raise RuntimeError(
             "Storage %s for mountpoint %s not exists" % (
                 self.storage_oid, self))
     return storage
Esempio n. 5
0
 def get_host_nic(self, nic_name):
     cluster = Cluster.instance()
     try:
         nic_oid = self.host_nics[nic_name]
         nic = cluster.get(nic_oid)
         if nic is None:
             raise KeyError(nic_name)
         return nic
     except KeyError:
         return None
Esempio n. 6
0
def on_ifconfig(report):
    cluster = Cluster.instance()
    node = cluster.get(report.node_oid)
    if not node:
        # Node is not ready
        return 
    for name, info in report.parsed_data.items():
        mac = info.get('mac')
        if not mac:
            continue # lo 
        node.update_host_nic(name, **info)
Esempio n. 7
0
 def on_mngr_msg(client, body, routing_key):
     default_mngr_callback(client, body, routing_key)
     event = Entity.from_json(body)
     if isinstance(event, NodeOnlineReport):
         node = Cluster.instance().get(self.node_oid)
         self.assertEqual(len(node.storages), 2)
         for mount_point in node.storages:
             if mount_point.storage_oid == self.storage1_oid:
                 self.assertEqual(mount_point.path, 
                                  self.storage1_path)
         self.stop()
Esempio n. 8
0
 def test_vmxml_report_updates_cluster(self):
     on_report(NodeOnlineReport.create(self.node_oid, hostname='testhost'))
     report = VmXMLReport.create(self.node_oid, raw_data = LIBVIRT_XML)
     on_report(report)
     cluster = Cluster.instance()
     vms = cluster.entities_by_class('VmProcess')
     self.assertEqual(len(vms), 1)
     node = cluster.get(self.node_oid)
     self.assertEqual(len(node.get_vm_procs()), 1)
     vm_proc = vms[0]
     self.assertEqual(vm_proc.vm_config.nics[0].target, 'vnet0')
Esempio n. 9
0
 def test_crud(self):
     cluster = Cluster.instance()
     node = Node(hostname='testhost')
     cluster.store(node)
     on_report(IFConfigReport.create(node.oid, raw_data=IFCONFIG_DATA))
     network = Network(title='TestNetwork')
     virbr2 = node.get_host_nic('virbr2')
     network.add_host_nic(virbr2)
     self.assertTrue(virbr2.oid in network.host_nics)
     eth2 = node.get_host_nic('eth2')
     self.assertEqual(len(network.host_nics), 1)
     self.assertFalse(eth2.oid in network.host_nics) # only bridge should be added
Esempio n. 10
0
 def test_update(self):
     cluster = Cluster.instance()
     node = Node(oid=self.node_oid,
                 hostname='hostname')
     cluster.store(node)
     node.vm_procs = dict(a='dummy')
     self.assertEqual(cluster.get(self.node_oid).vm_procs['a'],
                      'dummy')
     cluster.store(Node(oid=self.node_oid,
                        hostname='hostname'))
     self.assertEqual(cluster.get(self.node_oid).vm_procs['a'],
                      'dummy')
Esempio n. 11
0
    def get(self, path):
        """Return view for entity 

        """
        
        entity = Cluster.instance().get(path)
        if not entity:
            raise HTTPError(404)
        self.render('entity.html', 
                    class_name = entity.__class__.__name__,
                    oid = entity.oid,
                    cmd = entity.oid,
                    table = get_entity_view(entity).get_html())
Esempio n. 12
0
 def on_mngr_msg(client, body, routing_key):
     report = Entity.from_json(body)
     on_report(report)
     self.assertEqual(report.reporter_oid, self.node_oid)
     if report.__class__.__name__ == 'NodeOnlineReport':
         on_report(IFConfigReport.create(self.node_oid, 
                                         raw_data=IFCONFIG_DATA))
         client.send_task(VMInventoryTask(node_oid=self.node_oid))
     if report.__class__.__name__ == 'VmXMLReport':
         cluster = Cluster.instance()
         vm_config = cluster.entities_by_class('VmConfig')[0]
         self.assertEqual(vm_config.oid, 'c2127a40-eb4c-4e3c-af5b-ab455fd8bb40')
         self.stop()
Esempio n. 13
0
 def test_update_cluster(self):
     import uuid
     storage_oid = str(uuid.uuid4())
     on_report(NodeOnlineReport.create(self.node_oid,
                                       hostname='testhost',
                                      storages=[dict(
                     node_oid=self.node_oid,
                     storage_oid=storage_oid,
                     path='/home/storage1')]))
     on_report(DFReport.create(self.node_oid, raw_data=DF_RAW))
     cluster = Cluster.instance()
     storage = cluster.get(storage_oid)
     self.assertTrue(storage)
     self.assertEqual(storage.avail, '702G')
Esempio n. 14
0
 def post(self):
     import IPython; IPython.embed()
     cmd = self.get_argument('cmd', '')
     cluster = Cluster.instance()
     view = None
     if cmd == 'vms':
         view = vm_list_view(
             cluster.entities_by_class('VmProcess'))
     entity = cluster.search(cmd)
     if entity:
         self.redirect('/%s' % entity.oid)
     self.render('page.html',
                 cmd=cmd,
                 view=view)
Esempio n. 15
0
 def test_report_arrived(self):
     node_oid = str(uuid.uuid1())
     on_report(NodeOnlineReport.create(node_oid, hostname='testhost'))
     on_report(IFConfigReport.create(node_oid, raw_data=IFCONFIG_DATA))
     on_report(BrctlShowReport.create(node_oid, raw_data=BRCTL_SHOW_DATA))
     cluster = Cluster.instance()
     node = cluster.get(node_oid)
     self.assertTrue(node)
     eth2 = node.get_host_nic('eth2')
     self.assertTrue(eth2)
     self.assertEqual(eth2.in_bridge, 'virbr2')
     virbr2 = node.get_host_nic('virbr2')
     self.assertEqual(virbr2.bridge_for,
                      ['eth2', 'vnet0', 'vnet1'])
Esempio n. 16
0
 def test_entites_storing(self):
     cluster = Cluster.instance()
     item1 = Item('foo')
     item2 = Item('bar')
     item3 = Baz('baz')
     cluster.store(item1)
     cluster.store(item2)
     cluster.store(item3)
     
     self.assertEqual(cluster.get(item1.oid), item1)
     self.assertEqual(len(cluster.entities_by_class('Item')), 2)
     self.assertEqual(len(cluster.entities_by_class(Baz)), 1)
     self.assertEqual(cluster.entities_by_class(Baz)[0],
                      item3)
     cluster.delete(item1)
     self.assertEqual(len(cluster.oids_by_class(Item)), 1)
Esempio n. 17
0
def on_brctl_show(report):
    cluster = Cluster.instance()
    node = cluster.get(report.node_oid)
    if not node:
        return 

    for bridge_name, nic_names in report.parsed_data.items():
        for nic_name in nic_names:
            nic = node.get_host_nic(nic_name)
            if nic:
                # if not - didn't get ifconfig report yet, nothing we can do
                nic.in_bridge = bridge_name
                cluster.store(nic)
        bridge = node.get_host_nic(bridge_name)
        if bridge:
            bridge.bridge_for = nic_names
            cluster.store(bridge)
Esempio n. 18
0
        def on_mngr_msg(client, body, routing_key):
            inst = self.entity_from_json(body)
            default_callback(client, body, routing_key)

            if isinstance(inst, NodeOnlineReport):
                self.node.publish_report(
                    IFConfigReport.create(self.node_oid, raw_data=RAW_DATA))

            if isinstance(inst, IFConfigReport):
                self.assertEqual(inst.raw_data, RAW_DATA)
                cluster = Cluster.instance()
                node = cluster.get(self.node_oid)
                self.assertTrue(node)
                self.assertEqual(node.get_host_nic('eth1').inet_addr,
                                 '10.0.1.1')
                self.assertEqual(node.get_host_nic('vnet0').rx_bytes,
                                 11546476)
                self.stop()
Esempio n. 19
0
    def test_node_online_update_cluster(self):
        def on_mngr_msg(client, body, routing_key):
            default_mngr_callback(client, body, routing_key)
            event = Entity.from_json(body)
            if isinstance(event, NodeOnlineReport):
                node = Cluster.instance().get(self.node_oid)
                self.assertEqual(len(node.storages), 2)
                for mount_point in node.storages:
                    if mount_point.storage_oid == self.storage1_oid:
                        self.assertEqual(mount_point.path, 
                                         self.storage1_path)
                self.stop()

        self.set_manager(on_mngr_msg)
        self.set_node()
        self.wait()
        cluster = Cluster.instance()
        node = cluster.get(self.node_oid)
        self.assertTrue(isinstance(node, Node))
Esempio n. 20
0
def on_node_online(report):
    from swarm.stuff import Storage
    from swarm.tasks import VMInventoryTask
    cluster = Cluster.instance()
    if not cluster.is_stored(report.node_oid):
        node = Node(oid=report.node_oid, 
                    hostname=report.hostname,
                    state='online')
        cluster.store(node)
        if CLIENT:
            task = VMInventoryTask(node_oid=node.oid)
            cluster.store(task)
            CLIENT.send_task(task)
        else:
            log.warn("No client available in on_node_online")
    else:
        node = cluster.get(report.node_oid)
        node.state = 'online'
    Storage.update_points(node, report.storages)
Esempio n. 21
0
def on_vmxml(report):
    "Procedures on libvirt xml report"
    cluster = Cluster.instance()
    node = cluster.get(report.node_oid)
    if node is None:
        return on_report_from_offline_node(report)
    data = report.parsed_data
    nics = []
    for nic in data['nics']:
        nics.append(VmNic(**nic))
    vm_config = VmConfig(oid=data['uuid'],
                         vcpu=data['vcpu'],
                         memory=data['memory'],
                         name=data['name'],
                         features=data['features'],
                         libvirt_xml=report.raw_data,
                         nics=nics)
    cluster.store(vm_config)
    if data.get('libvirt_id'):
        node.update_vm_process(data['libvirt_id'], vm_config)
Esempio n. 22
0
def on_dfreport(report):

    def choose_mount_point(report, storage_point):
        report_pathes = [(len(x), x) for x in report.parsed_data.keys()]
        report_pathes.sort(key=lambda x:x[0], reverse=True)
        report_pathes = [x[1] for x in report_pathes]
        for mount_point in report_pathes:
            if storage_point.path.startswith(mount_point):
                return mount_point
        raise RuntimeError("No mount point for given storage points")

    cluster = Cluster.instance()
    if not cluster.is_stored(report.node_oid):
        return 
    for storage_point in report.node.storages:
        mount_point = choose_mount_point(report, storage_point)
        storage = cluster.get(storage_point.storage_oid) or Storage(
            storage_point.storage_oid)
        storage.avail = report.parsed_data[mount_point]['avail']
        cluster.store(storage)
Esempio n. 23
0
    def update_points(cls, node, points):

        cluster = Cluster.instance()

        def is_exists(info):
            for spoint in cluster.entities_by_class(StoragePoint):
                if spoint.node_oid == node.oid and \
                        spoint.path == info['path'] and \
                        spoint.storage_oid == info['storage_oid']:
                    return True
            return False

        for point in points:
            storage_oid = point['storage_oid']
            if not cluster.is_stored(storage_oid):
                cluster.store(Storage(oid=storage_oid))
            if not is_exists(point):
                cluster.store(StoragePoint(node_oid=node.oid,
                                           storage_oid=point['storage_oid'],
                                           path=point['path']))
Esempio n. 24
0
 def get(self):
     cluster = Cluster.instance()
     import IPython; IPython.embed()
     self.redirect('/')
Esempio n. 25
0
 def host(self):
     cluster = Cluster.instance()
     for proc in cluster.entities_by_class("VmProcess"):
         if proc.vm_config.oid == self.oid:
             return proc.node
     return None
Esempio n. 26
0
 def storages(self):
     return [x for x in Cluster.instance().entities_by_class(
             StoragePoint) if x.node_oid == self.oid]
Esempio n. 27
0
 def get_vm_procs(self):
     cluster = Cluster.instance()
     return [cluster.get(x) for x in self.vm_procs.values()]
Esempio n. 28
0
 def from_store(self, value):
     from swarm.cluster import Cluster
     return Cluster.instance().get(value)
Esempio n. 29
0
 def node(self):
     from swarm.cluster import Cluster
     return Cluster.instance().get_or_error(self.node_oid)
Esempio n. 30
0
 def test_instance(self):
     self.assertEqual(
         Cluster.instance(), Cluster.instance())