def testNonexistentDomain(self): """Test that loadDomainState can deal with nonexistent domains.""" doms = {} for i in xrange(6): doms[('debmarshal-%d' % i, 'qemu')] = 500 self.mox.StubOutWithMock(utils, '_clearLibvirtError') utils._clearLibvirtError() self.mox.StubOutWithMock(utils, 'loadState') utils.loadState('debmarshal-domains').AndReturn(dict(doms)) self.mox.StubOutWithMock(hypervisors.qemu.QEMU, 'open') qemu_con = self.mox.CreateMock(libvirt.virConnect) hypervisors.qemu.QEMU.open().AndReturn(qemu_con) qemu_con.lookupByName('debmarshal-0').InAnyOrder() qemu_con.lookupByName('debmarshal-1').InAnyOrder() qemu_con.lookupByName('debmarshal-2').InAnyOrder().AndRaise( libvirt.libvirtError("Domain doesn't exist")) qemu_con.lookupByName('debmarshal-3').InAnyOrder() qemu_con.lookupByName('debmarshal-4').InAnyOrder().AndRaise( libvirt.libvirtError("Domain doesn't exist")) qemu_con.lookupByName('debmarshal-5').InAnyOrder() self.mox.ReplayAll() del doms[('debmarshal-2', 'qemu')] del doms[('debmarshal-4', 'qemu')] self.assertEqual(domains.loadDomainState(), doms)
def testAcquiringConnections(self): """Test acquiring libvirt connections when loading domain state. Also check that loadDomainState can reuse a connection it already has open. """ doms = {('debmarshal-1', 'qemu'): 500, ('debmarshal-2', 'qemu'): 500} self.mox.StubOutWithMock(utils, '_clearLibvirtError') utils._clearLibvirtError() self.mox.StubOutWithMock(utils, 'loadState') utils.loadState('debmarshal-domains').AndReturn(doms) self.mox.StubOutWithMock(hypervisors.qemu.QEMU, 'open') qemu_con = self.mox.CreateMock(libvirt.virConnect) hypervisors.qemu.QEMU.open().AndReturn(qemu_con) virt_domain = self.mox.CreateMock(libvirt.virDomain) qemu_con.lookupByName('debmarshal-1').InAnyOrder().AndReturn(virt_domain) virt_domain = self.mox.CreateMock(libvirt.virDomain) qemu_con.lookupByName('debmarshal-2').InAnyOrder().AndReturn(virt_domain) self.mox.ReplayAll() self.assertEqual(domains.loadDomainState(), doms)
def testEmptyList(self): """Test the domain state file not existing.""" self.mox.StubOutWithMock(utils, 'loadState') utils.loadState('debmarshal-domains').AndReturn(None) self.mox.ReplayAll() self.assertEqual(domains.loadDomainState(), {})
def testNetworkExistenceTest(self): """Make sure that networks get dropped from the list in the state file if they don't still exist. And that they're kept if they do""" self.mox.StubOutWithMock(utils, 'loadState') utils.loadState('debmarshal-networks').AndReturn({ 'foo': 500, 'bar': 501 }) self.mox.StubOutWithMock(networks, '_listBridges') networks._listBridges().AndReturn(['virbr0', 'foo']) self.mox.ReplayAll() self.assertEqual(networks.loadNetworkState(), {'foo': 500})
def testNetworkExistenceTest(self): """Make sure that networks get dropped from the list in the state file if they don't still exist. And that they're kept if they do""" self.mox.StubOutWithMock(utils, 'loadState') utils.loadState('debmarshal-networks').AndReturn( {'foo': 500, 'bar': 501}) self.mox.StubOutWithMock(networks, '_listBridges') networks._listBridges().AndReturn(['virbr0', 'foo']) self.mox.ReplayAll() self.assertEqual(networks.loadNetworkState(), {'foo': 500})
def loadNetworkState(): """Load state for any networks previously created by debmarshal. State is written to /var/run/debmarshal-networks as a pickle. Ubuntu makes /var/run a tmpfs, so state vanishes after reboots - which is good, because the networks debmarshal has created do as well. Not all distributions do this, though, so we loop over the networks in the pickle and see which ones still exist. If a network no longer exists, we assume that it was deleted outside of debmarshal, and we erase our record of it. Returns: A list of networks. Each network is a tuple of (network_name, owner_uid, gateway_ip_address) """ networks = utils.loadState('debmarshal-networks') if not networks: networks = {} bridges = set(_listBridges()) for n in networks.keys(): if n not in bridges: del networks[n] return networks
def testTwoBadNetworks(self): """Test finding two nonexistent networks when loading state.""" nets = {'foo': 500, 'bar': 500, 'baz': 500, 'quux': 500, 'spam': 500, 'eggs': 500} self.mox.StubOutWithMock(utils, 'loadState') utils.loadState('debmarshal-networks').AndReturn(dict(nets)) self.mox.StubOutWithMock(networks, '_listBridges') networks._listBridges().AndReturn(['foo', 'bar', 'quux', 'eggs']) self.mox.ReplayAll() del nets['baz'] del nets['spam'] self.assertEqual(networks.loadNetworkState(), nets)
def testTwoBadNetworks(self): """Test finding two nonexistent networks when loading state.""" nets = { 'foo': 500, 'bar': 500, 'baz': 500, 'quux': 500, 'spam': 500, 'eggs': 500 } self.mox.StubOutWithMock(utils, 'loadState') utils.loadState('debmarshal-networks').AndReturn(dict(nets)) self.mox.StubOutWithMock(networks, '_listBridges') networks._listBridges().AndReturn(['foo', 'bar', 'quux', 'eggs']) self.mox.ReplayAll() del nets['baz'] del nets['spam'] self.assertEqual(networks.loadNetworkState(), nets)
def loadNetworkState(virt_con=None): """Load state for any networks previously created by debmarshal. State is written to /var/run/debmarshal-networks as a pickle. Ubuntu makes /var/run a tmpfs, so state vanishes after reboots - which is good, because the networks debmarshal has created do as well. Not all distributions do this, though, so we loop over the networks in the pickle and see which ones still exist. If a network no longer exists, we assume that it was deleted outside of debmarshal, and we erase our record of it. Args: virt_con: A non-read-only libvirt.virConnect instance. If one isn't passed in, we'll open one of our own. It doesn't really matter which libvirt driver you connect to, because all of them share virtual networks. Returns: A list of networks. Each network is a tuple of (network_name, owner_uid, gateway_ip_address) """ networks = utils.loadState("debmarshal-networks") if not networks: networks = {} if not virt_con: virt_con = libvirt.open("qemu:///system") for n in networks.keys(): try: virt_con.networkLookupByName(n) except libvirt.libvirtError: del networks[n] return networks
def loadDomainState(): """Load stored state for domains previously created by debmarshal. State is stored in /var/run/debmarshal-domains. State is generally lost after reboots - which is good, since running domains tend to go away after reboots as well. Because not all distributions do this, and because domains can stop independent of debmarshal, we loop over the domains and erase our record of any domains that don't still exist. Each hypervisor has its own domain namespace. We'll need to open connections to multiple hypervisors, so there's no point passing a libvirt connection object in. Returns: A list of domains. Each domain is a tuple of (domain_name, owner hypervisor) """ connections = {} domains = utils.loadState('debmarshal-domains') if not domains: return {} for dom, hypervisor in domains.keys(): if hypervisor not in connections: hyper_class = hypervisors.base.hypervisors[hypervisor] connections[hypervisor] = hyper_class.open() try: connections[hypervisor].lookupByName(dom) except libvirt.libvirtError: del domains[(dom, hypervisor)] return domains