[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[Xen-devel] [PATCH 1 of 3] remus: remove dead code and unused modules



# HG changeset patch
# User Shriram Rajagopalan <rshriram@xxxxxxxxx>
# Date 1307360439 25200
# Node ID d681b8ed0d03557f896cbc28d7ec244a2bc75bf2
# Parent  6f215b893873d61fc07c693c40466299973b41d4
remus: remove dead code and unused modules

remove unused modules (profile, tapdisk, vdi) and
unused thread classes/qdisc classes from the python code
base.

Signed-off-by: Shriram Rajagopalan <rshriram@xxxxxxxxx>

diff -r 6f215b893873 -r d681b8ed0d03 tools/python/xen/remus/profile.py
--- a/tools/python/xen/remus/profile.py Mon Jun 06 04:40:28 2011 -0700
+++ /dev/null   Thu Jan 01 00:00:00 1970 +0000
@@ -1,56 +0,0 @@
-"""Simple profiling module
-"""
-
-import time
-
-class ProfileBlock(object):
-    """A section of code to be profiled"""
-    def __init__(self, name):
-        self.name = name
-
-    def enter(self):
-        print "PROF: entered %s at %f" % (self.name, time.time())
-
-    def exit(self):
-        print "PROF: exited %s at %f" % (self.name, time.time())
-
-class NullProfiler(object):
-    def enter(self, name):
-        pass
-
-    def exit(self, name=None):
-        pass
-
-class Profiler(object):
-    def __init__(self):
-        self.blocks = {}
-        self.running = []
-
-    def enter(self, name):
-        try:
-            block = self.blocks[name]
-        except KeyError:
-            block = ProfileBlock(name)
-            self.blocks[name] = block
-
-        block.enter()
-        self.running.append(block)
-
-    def exit(self, name=None):
-        if name is not None:
-            block = None
-            while self.running:
-                tmp = self.running.pop()
-                if tmp.name == name:
-                    block = tmp
-                    break
-                tmp.exit()
-            if not block:
-                raise KeyError('block %s not running' % name)
-        else:
-            try:
-                block = self.running.pop()
-            except IndexError:
-                raise KeyError('no block running')
-
-        block.exit()
diff -r 6f215b893873 -r d681b8ed0d03 tools/python/xen/remus/qdisc.py
--- a/tools/python/xen/remus/qdisc.py   Mon Jun 06 04:40:28 2011 -0700
+++ b/tools/python/xen/remus/qdisc.py   Mon Jun 06 04:40:39 2011 -0700
@@ -109,43 +109,6 @@
 qdisc_kinds['prio'] = PrioQdisc
 qdisc_kinds['pfifo_fast'] = PrioQdisc
 
-class CfifoQdisc(Qdisc):
-    fmt = 'II'
-
-    def __init__(self, qdict):
-        super(CfifoQdisc, self).__init__(qdict)
-
-        if qdict.get('options'):
-            self.unpack(qdict['options'])
-        else:
-            self.epoch = 0
-            self.vmid = 0
-
-    def pack(self):
-        return struct.pack(self.fmt, self.epoch, self.vmid)
-
-    def unpack(self, opts):
-        self.epoch, self.vmid = struct.unpack(self.fmt, opts)
-
-    def parse(self, opts):
-        args = list(opts)
-        try:
-            while args:
-                arg = args.pop(0)
-                if arg == 'epoch':
-                    self.epoch = int(args.pop(0))
-                    continue
-                if arg.lower() == 'vmid':
-                    self.vmid = int(args.pop(0))
-                    continue
-        except Exception, inst:
-            raise QdiscException(str(inst))
-
-    def optstr(self):
-        return 'epoch %d vmID %d' % (self.epoch, self.vmid)
-
-qdisc_kinds['cfifo'] = CfifoQdisc
-
 TC_PLUG_CHECKPOINT = 0
 TC_PLUG_RELEASE = 1
 
diff -r 6f215b893873 -r d681b8ed0d03 tools/python/xen/remus/save.py
--- a/tools/python/xen/remus/save.py    Mon Jun 06 04:40:28 2011 -0700
+++ b/tools/python/xen/remus/save.py    Mon Jun 06 04:40:39 2011 -0700
@@ -1,8 +1,7 @@
 #!/usr/bin/env python
 
-import os, select, socket, threading, time, signal, xmlrpclib
+import os, socket, xmlrpclib
 
-from xen.xend.XendClient import server
 from xen.xend.xenstore.xswatch import xswatch
 
 import xen.lowlevel.xc
@@ -13,10 +12,6 @@
 
 import vm, image
 
-XCFLAGS_LIVE =      1
-
-xcsave = '/usr/lib/xen/bin/xc_save'
-
 class _proxy(object):
     "proxy simulates an object without inheritance"
     def __init__(self, obj):
@@ -30,58 +25,6 @@
 
 class CheckpointError(Exception): pass
 
-class CheckpointingFile(_proxy):
-    """Tee writes into separate file objects for each round.
-    This is necessary because xc_save gets a single file descriptor
-    for the duration of checkpointing.
-    """
-    def __init__(self, path):
-        self.path = path
-
-        self.round = 0
-        self.rfd, self.wfd = os.pipe()
-        self.fd = file(path, 'wb')
-
-        # this pipe is used to notify the writer thread of checkpoints
-        self.cprfd, self.cpwfd = os.pipe()
-
-        super(CheckpointingFile, self).__init__(self.fd)
-
-        wt = threading.Thread(target=self._wrthread, name='disk-write-thread')
-        wt.setDaemon(True)
-        wt.start()
-        self.wt = wt
-
-    def fileno(self):
-        return self.wfd
-
-    def close(self):
-        os.close(self.wfd)
-        # closing wfd should signal writer to stop
-        self.wt.join()
-        os.close(self.rfd)
-        os.close(self.cprfd)
-        os.close(self.cpwfd)
-        self.fd.close()
-        self.wt = None
-
-    def checkpoint(self):
-        os.write(self.cpwfd, '1')
-
-    def _wrthread(self):
-        while True:
-            r, o, e = select.select((self.rfd, self.cprfd), (), ())
-            if self.rfd in r:
-                data = os.read(self.rfd, 256 * 1024)
-                if not data:
-                    break
-                self.fd.write(data)
-            if self.cprfd in r:
-                junk = os.read(self.cprfd, 1)
-                self.round += 1
-                self.fd = file('%s.%d' % (self.path, self.round), 'wb')
-                self.proxy(self.fd)
-
 class MigrationSocket(_proxy):
     def __init__(self, address):
         sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
@@ -101,36 +44,6 @@
         fd = os.fdopen(filedesc, 'w+')
         super(NullSocket, self).__init__(fd)
 
-class Keepalive(object):
-    "Call a keepalive method at intervals"
-    def __init__(self, method, interval=0.1):
-        self.keepalive = method
-        self.interval = interval
-
-        self.thread = None
-        self.running = False
-
-    def start(self):
-        if not self.interval:
-            return
-        self.thread = threading.Thread(target=self.run, 
name='keepalive-thread')
-        self.thread.setDaemon(True)
-        self.running = True
-        self.thread.start()
-
-    def stop(self):
-        if not self.thread:
-            return
-        self.running = False
-        self.thread.join()
-        self.thread = None
-
-    def run(self):
-        while self.running:
-            self.keepalive()
-            time.sleep(self.interval)
-        self.keepalive(stop=True)
-
 class Saver(object):
     def __init__(self, domid, fd, suspendcb=None, resumecb=None,
                  checkpointcb=None, interval=0):
@@ -174,10 +87,5 @@
                 pass
 
     def _resume(self):
-        """low-overhead version of XendDomainInfo.resumeDomain"""
-        # TODO: currently assumes SUSPEND_CANCEL is available
-        if True:
             xc.domain_resume(self.vm.domid, 1)
             xsutil.ResumeDomain(self.vm.domid)
-        else:
-            server.xend.domain.resumeDomain(self.vm.domid)
diff -r 6f215b893873 -r d681b8ed0d03 tools/python/xen/remus/tapdisk.py
--- a/tools/python/xen/remus/tapdisk.py Mon Jun 06 04:40:28 2011 -0700
+++ /dev/null   Thu Jan 01 00:00:00 1970 +0000
@@ -1,4 +0,0 @@
-import blkdev
-
-class TapDisk(BlkDev):
-    pass
diff -r 6f215b893873 -r d681b8ed0d03 tools/python/xen/remus/vdi.py
--- a/tools/python/xen/remus/vdi.py     Mon Jun 06 04:40:28 2011 -0700
+++ /dev/null   Thu Jan 01 00:00:00 1970 +0000
@@ -1,121 +0,0 @@
-#code to play with vdis and snapshots
-
-import os
-
-def run(cmd):
-    fd = os.popen(cmd)
-    res = [l for l in fd if l.rstrip()]
-    return not fd.close(), res
-
-
-_blockstore = '/blockstore.dat'
-
-def set_blockstore(blockstore):
-    global _blockstore
-    __blockstore = blockstore
-
-
-class SnapShot:
-    def __init__(self, vdi, block, index):
-       self.__vdi = vdi
-       self.__block = block
-       self.__index = index
-
-       #TODO add snapshot date and radix
-
-    def __str__(self):
-       return '%d %d %d' % (self.__vdi.id(), self.__block, self.__index)
-
-    def vdi(self):
-       return self.__vdi
-
-    def block(self):
-       return self.__block
-
-    def index(self):
-       return self.__index
-
-    def match(self, block, index):
-       return self.__block == block and self.__index == index
-
-
-class VDIException(Exception):
-       pass
-
-
-class VDI:
-    def __init__(self, id, name):
-       self.__id = id
-       self.__name = name
-
-    def __str__(self):
-       return 'vdi: %d %s' % (self.__id, self.__name)
-
-    def id(self):
-       return self.__id
-
-    def name(self):
-       return self.__name
-
-    def list_snapshots(self):
-       res, ls = run('vdi_snap_list %s %d' % (_blockstore, self.__id))
-       if res:
-           return [SnapShot(self, int(l[0]), int(l[1])) for l in [l.split() 
for l in ls[1:]]]
-       else:
-           raise VDIException("Error reading snapshot list")
-
-    def snapshot(self):
-       res, ls = run('vdi_checkpoint %s %d' % (_blockstore, self.__id))
-       if res:
-           _, block, idx = ls[0].split()
-           return SnapShot(self, int(block), int(idx))
-       else:
-           raise VDIException("Error taking vdi snapshot")
-
-
-def create(name, snap):
-    res, _ = run('vdi_create %s %s %d %d'
-                % (_blockstore, name, snap.block(), snap.index()))
-    if res:
-       return lookup_by_name(name)
-    else:
-       raise VDIException('Unable to create vdi from snapshot')
-
-
-def fill(name, img_file):
-    res, _ = run('vdi_create %s %s' % (_blockstore, name))
-
-    if res:
-       vdi = lookup_by_name(name)
-       res, _ = run('vdi_fill %d %s' % (vdi.id(), img_file))
-       if res:
-           return vdi
-    raise VDIException('Unable to create vdi from disk img file')
-
-
-def list_vdis():
-    vdis = []
-    res, lines = run('vdi_list %s' % _blockstore)
-    if res:
-       for l in lines:
-           r = l.split()
-           vdis.append(VDI(int(r[0]), r[1]))
-       return vdis
-    else:
-       raise VDIException("Error doing vdi list")
-
-
-def lookup_by_id(id):
-    vdis = list_vdis()
-    for v in vdis:
-       if v.id() == id:
-           return v
-    raise VDIException("No match from vdi id")
-
-
-def lookup_by_name(name):
-    vdis = list_vdis()
-    for v in vdis:
-       if v.name() == name:
-           return v
-    raise VDIException("No match for vdi name")
diff -r 6f215b893873 -r d681b8ed0d03 tools/python/xen/remus/vm.py
--- a/tools/python/xen/remus/vm.py      Mon Jun 06 04:40:28 2011 -0700
+++ b/tools/python/xen/remus/vm.py      Mon Jun 06 04:40:39 2011 -0700
@@ -143,10 +143,6 @@
 
     return [blkdev.parse(disk) for disk in disks]
 
-def fromxend(domid):
-    "create a VM object from xend information"
-    return VM(domid)
-
 def getshadowmem(vm):
     "Balloon down domain0 to create free memory for shadow paging."
     maxmem = int(vm.dom['maxmem'])
diff -r 6f215b893873 -r d681b8ed0d03 tools/remus/remus
--- a/tools/remus/remus Mon Jun 06 04:40:28 2011 -0700
+++ b/tools/remus/remus Mon Jun 06 04:40:39 2011 -0700
@@ -78,12 +78,9 @@
         # I am not sure what the best way to die is. xm destroy is another 
option,
         # or we could attempt to trigger some instant reboot.
         print "dying..."
-        print util.runcmd(['sudo', 'ifdown', 'eth2'])
-        # dangling imq0 handle on vif locks up the system
         for buf in bufs:
             buf.uninstall()
         print util.runcmd(['sudo', 'xm', 'destroy', cfg.domid])
-        print util.runcmd(['sudo', 'ifup', 'eth2'])
 
     def getcommand():
         """Get a command to execute while running.

_______________________________________________
Xen-devel mailing list
Xen-devel@xxxxxxxxxxxxxxxxxxx
http://lists.xensource.com/xen-devel


 


Rackspace

Lists.xenproject.org is hosted with RackSpace, monitoring our
servers 24x7x365 and backed by RackSpace's Fanatical Support®.