- Remove Twisted dependency from pip-requires

- Remove Twisted patch from tools/install_venv.py
- Remove eventlet patch from tools/install_venv.py
- Remove tools/eventlet-patch
- Remove nova/twistd.py
- Remove nova/tests/test_twistd.py
- Remove bin/nova-instancemonitor
- Remove nova/compute/monitor.py
- Add xattr to pip-requires until glance setup.py installs it correctly
- Remove references to removed files from docs/translations/code

5 files changed, 8 insertions, 771 deletions

diff --git a/nova/compute/monitor.py b/nova/compute/monitor.py
deleted file mode 100644
index 9d8e2a25d..000000000
--- a/nova/compute/monitor.py
+++ /dev/null
@@ -1,435 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright 2010 United States Government as represented by the
-# Administrator of the National Aeronautics and Space Administration.
-# All Rights Reserved.
-#
-#    Licensed under the Apache License, Version 2.0 (the "License"); you may
-#    not use this file except in compliance with the License. You may obtain
-#    a copy of the License at
-#
-#         http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#    License for the specific language governing permissions and limitations
-#    under the License.
-
-"""
-Instance Monitoring:
-
-    Optionally may be run on each compute node. Provides RRD
-    based statistics and graphs and makes them internally available
-    in the object store.
-"""
-
-import datetime
-import os
-import time
-
-import boto
-import boto.s3
-import rrdtool
-from twisted.internet import task
-from twisted.application import service
-
-from nova import flags
-from nova import log as logging
-from nova import utils
-from nova.virt import connection as virt_connection
-
-
-FLAGS = flags.FLAGS
-flags.DEFINE_integer('monitoring_instances_delay', 5,
-                     'Sleep time between updates')
-flags.DEFINE_integer('monitoring_instances_step', 300,
-                     'Interval of RRD updates')
-flags.DEFINE_string('monitoring_rrd_path', '$state_path/monitor/instances',
-                    'Location of RRD files')
-
-
-RRD_VALUES = {
-    'cpu': [
-        'DS:cpu:GAUGE:600:0:100',
-        'RRA:AVERAGE:0.5:1:800',
-        'RRA:AVERAGE:0.5:6:800',
-        'RRA:AVERAGE:0.5:24:800',
-        'RRA:AVERAGE:0.5:288:800',
-        'RRA:MAX:0.5:1:800',
-        'RRA:MAX:0.5:6:800',
-        'RRA:MAX:0.5:24:800',
-        'RRA:MAX:0.5:288:800',
-        ],
-    'net': [
-        'DS:rx:COUNTER:600:0:1250000',
-        'DS:tx:COUNTER:600:0:1250000',
-        'RRA:AVERAGE:0.5:1:800',
-        'RRA:AVERAGE:0.5:6:800',
-        'RRA:AVERAGE:0.5:24:800',
-        'RRA:AVERAGE:0.5:288:800',
-        'RRA:MAX:0.5:1:800',
-        'RRA:MAX:0.5:6:800',
-        'RRA:MAX:0.5:24:800',
-        'RRA:MAX:0.5:288:800',
-        ],
-    'disk': [
-        'DS:rd:COUNTER:600:U:U',
-        'DS:wr:COUNTER:600:U:U',
-        'RRA:AVERAGE:0.5:1:800',
-        'RRA:AVERAGE:0.5:6:800',
-        'RRA:AVERAGE:0.5:24:800',
-        'RRA:AVERAGE:0.5:288:800',
-        'RRA:MAX:0.5:1:800',
-        'RRA:MAX:0.5:6:800',
-        'RRA:MAX:0.5:24:800',
-        'RRA:MAX:0.5:444:800',
-        ]}
-
-
-utcnow = utils.utcnow
-
-
-LOG = logging.getLogger('nova.compute.monitor')
-
-
-def update_rrd(instance, name, data):
-    """
-    Updates the specified RRD file.
-    """
-    filename = os.path.join(instance.get_rrd_path(), '%s.rrd' % name)
-
-    if not os.path.exists(filename):
-        init_rrd(instance, name)
-
-    timestamp = int(time.mktime(utcnow().timetuple()))
-    rrdtool.update(filename, '%d:%s' % (timestamp, data))
-
-
-def init_rrd(instance, name):
-    """
-    Initializes the specified RRD file.
-    """
-    path = os.path.join(FLAGS.monitoring_rrd_path, instance.instance_id)
-
-    if not os.path.exists(path):
-        os.makedirs(path)
-
-    filename = os.path.join(path, '%s.rrd' % name)
-
-    if not os.path.exists(filename):
-        rrdtool.create(
-            filename,
-            '--step', '%d' % FLAGS.monitoring_instances_step,
-            '--start', '0',
-            *RRD_VALUES[name])
-
-
-def graph_cpu(instance, duration):
-    """
-    Creates a graph of cpu usage for the specified instance and duration.
-    """
-    path = instance.get_rrd_path()
-    filename = os.path.join(path, 'cpu-%s.png' % duration)
-
-    rrdtool.graph(
-        filename,
-        '--disable-rrdtool-tag',
-        '--imgformat', 'PNG',
-        '--width', '400',
-        '--height', '120',
-        '--start', 'now-%s' % duration,
-        '--vertical-label', '% cpu used',
-        '-l', '0',
-        '-u', '100',
-        'DEF:cpu=%s:cpu:AVERAGE' % os.path.join(path, 'cpu.rrd'),
-        'AREA:cpu#eacc00:% CPU',)
-
-    store_graph(instance.instance_id, filename)
-
-
-def graph_net(instance, duration):
-    """
-    Creates a graph of network usage for the specified instance and duration.
-    """
-    path = instance.get_rrd_path()
-    filename = os.path.join(path, 'net-%s.png' % duration)
-
-    rrdtool.graph(
-        filename,
-        '--disable-rrdtool-tag',
-        '--imgformat', 'PNG',
-        '--width', '400',
-        '--height', '120',
-        '--start', 'now-%s' % duration,
-        '--vertical-label', 'bytes/s',
-        '--logarithmic',
-        '--units', 'si',
-        '--lower-limit', '1000',
-        '--rigid',
-        'DEF:rx=%s:rx:AVERAGE' % os.path.join(path, 'net.rrd'),
-        'DEF:tx=%s:tx:AVERAGE' % os.path.join(path, 'net.rrd'),
-        'AREA:rx#00FF00:In traffic',
-        'LINE1:tx#0000FF:Out traffic',)
-
-    store_graph(instance.instance_id, filename)
-
-
-def graph_disk(instance, duration):
-    """
-    Creates a graph of disk usage for the specified duration.
-    """
-    path = instance.get_rrd_path()
-    filename = os.path.join(path, 'disk-%s.png' % duration)
-
-    rrdtool.graph(
-        filename,
-        '--disable-rrdtool-tag',
-        '--imgformat', 'PNG',
-        '--width', '400',
-        '--height', '120',
-        '--start', 'now-%s' % duration,
-        '--vertical-label', 'bytes/s',
-        '--logarithmic',
-        '--units', 'si',
-        '--lower-limit', '1000',
-        '--rigid',
-        'DEF:rd=%s:rd:AVERAGE' % os.path.join(path, 'disk.rrd'),
-        'DEF:wr=%s:wr:AVERAGE' % os.path.join(path, 'disk.rrd'),
-        'AREA:rd#00FF00:Read',
-        'LINE1:wr#0000FF:Write',)
-
-    store_graph(instance.instance_id, filename)
-
-
-def store_graph(instance_id, filename):
-    """
-    Transmits the specified graph file to internal object store on cloud
-    controller.
-    """
-    # TODO(devcamcar): Need to use an asynchronous method to make this
-    #       connection. If boto has some separate method that generates
-    #       the request it would like to make and another method to parse
-    #       the response we can make our own client that does the actual
-    #       request and hands it off to the response parser.
-    s3 = boto.s3.connection.S3Connection(
-        aws_access_key_id=FLAGS.aws_access_key_id,
-        aws_secret_access_key=FLAGS.aws_secret_access_key,
-        is_secure=False,
-        calling_format=boto.s3.connection.OrdinaryCallingFormat(),
-        port=FLAGS.s3_port,
-        host=FLAGS.s3_host)
-    bucket_name = '_%s.monitor' % instance_id
-
-    # Object store isn't creating the bucket like it should currently
-    # when it is first requested, so have to catch and create manually.
-    try:
-        bucket = s3.get_bucket(bucket_name)
-    except Exception:
-        bucket = s3.create_bucket(bucket_name)
-
-    key = boto.s3.Key(bucket)
-    key.key = os.path.basename(filename)
-    key.set_contents_from_filename(filename)
-
-
-class Instance(object):
-    def __init__(self, conn, instance_id):
-        self.conn = conn
-        self.instance_id = instance_id
-        self.last_updated = datetime.datetime.min
-        self.cputime = 0
-        self.cputime_last_updated = None
-
-        init_rrd(self, 'cpu')
-        init_rrd(self, 'net')
-        init_rrd(self, 'disk')
-
-    def needs_update(self):
-        """
-        Indicates whether this instance is due to have its statistics updated.
-        """
-        delta = utcnow() - self.last_updated
-        return delta.seconds >= FLAGS.monitoring_instances_step
-
-    def update(self):
-        """
-        Updates the instances statistics and stores the resulting graphs
-        in the internal object store on the cloud controller.
-        """
-        LOG.debug(_('updating %s...'), self.instance_id)
-
-        try:
-            data = self.fetch_cpu_stats()
-            if data is not None:
-                LOG.debug('CPU: %s', data)
-                update_rrd(self, 'cpu', data)
-
-            data = self.fetch_net_stats()
-            LOG.debug('NET: %s', data)
-            update_rrd(self, 'net', data)
-
-            data = self.fetch_disk_stats()
-            LOG.debug('DISK: %s', data)
-            update_rrd(self, 'disk', data)
-
-            # TODO(devcamcar): Turn these into pool.ProcessPool.execute() calls
-            # and make the methods @defer.inlineCallbacks.
-            graph_cpu(self, '1d')
-            graph_cpu(self, '1w')
-            graph_cpu(self, '1m')
-
-            graph_net(self, '1d')
-            graph_net(self, '1w')
-            graph_net(self, '1m')
-
-            graph_disk(self, '1d')
-            graph_disk(self, '1w')
-            graph_disk(self, '1m')
-        except Exception:
-            LOG.exception(_('unexpected error during update'))
-
-        self.last_updated = utcnow()
-
-    def get_rrd_path(self):
-        """
-        Returns the path to where RRD files are stored.
-        """
-        return os.path.join(FLAGS.monitoring_rrd_path, self.instance_id)
-
-    def fetch_cpu_stats(self):
-        """
-        Returns cpu usage statistics for this instance.
-        """
-        info = self.conn.get_info(self.instance_id)
-
-        # Get the previous values.
-        cputime_last = self.cputime
-        cputime_last_updated = self.cputime_last_updated
-
-        # Get the raw CPU time used in nanoseconds.
-        self.cputime = float(info['cpu_time'])
-        self.cputime_last_updated = utcnow()
-
-        LOG.debug('CPU: %d', self.cputime)
-
-        # Skip calculation on first pass. Need delta to get a meaningful value.
-        if cputime_last_updated is None:
-            return None
-
-        # Calculate the number of seconds between samples.
-        d = self.cputime_last_updated - cputime_last_updated
-        t = d.days * 86400 + d.seconds
-
-        LOG.debug('t = %d', t)
-
-        # Calculate change over time in number of nanoseconds of CPU time used.
-        cputime_delta = self.cputime - cputime_last
-
-        LOG.debug('cputime_delta = %s', cputime_delta)
-
-        # Get the number of virtual cpus in this domain.
-        vcpus = int(info['num_cpu'])
-
-        LOG.debug('vcpus = %d', vcpus)
-
-        # Calculate CPU % used and cap at 100.
-        return min(cputime_delta / (t * vcpus * 1.0e9) * 100, 100)
-
-    def fetch_disk_stats(self):
-        """
-        Returns disk usage statistics for this instance.
-        """
-        rd = 0
-        wr = 0
-
-        disks = self.conn.get_disks(self.instance_id)
-
-        # Aggregate the read and write totals.
-        for disk in disks:
-            try:
-                rd_req, rd_bytes, wr_req, wr_bytes, errs = \
-                    self.conn.block_stats(self.instance_id, disk)
-                rd += rd_bytes
-                wr += wr_bytes
-            except TypeError:
-                iid = self.instance_id
-                LOG.error(_('Cannot get blockstats for "%(disk)s"'
-                        ' on "%(iid)s"') % locals())
-                raise
-
-        return '%d:%d' % (rd, wr)
-
-    def fetch_net_stats(self):
-        """
-        Returns network usage statistics for this instance.
-        """
-        rx = 0
-        tx = 0
-
-        interfaces = self.conn.get_interfaces(self.instance_id)
-
-        # Aggregate the in and out totals.
-        for interface in interfaces:
-            try:
-                stats = self.conn.interface_stats(self.instance_id, interface)
-                rx += stats[0]
-                tx += stats[4]
-            except TypeError:
-                iid = self.instance_id
-                LOG.error(_('Cannot get ifstats for "%(interface)s"'
-                        ' on "%(iid)s"') % locals())
-                raise
-
-        return '%d:%d' % (rx, tx)
-
-
-class InstanceMonitor(object, service.Service):
-    """
-    Monitors the running instances of the current machine.
-    """
-
-    def __init__(self):
-        """
-        Initialize the monitoring loop.
-        """
-        self._instances = {}
-        self._loop = task.LoopingCall(self.updateInstances)
-
-    def startService(self):
-        self._instances = {}
-        self._loop.start(interval=FLAGS.monitoring_instances_delay)
-        service.Service.startService(self)
-
-    def stopService(self):
-        self._loop.stop()
-        service.Service.stopService(self)
-
-    def updateInstances(self):
-        """
-        Update resource usage for all running instances.
-        """
-        try:
-            conn = virt_connection.get_connection(read_only=True)
-        except Exception, exn:
-            LOG.exception(_('unexpected exception getting connection'))
-            time.sleep(FLAGS.monitoring_instances_delay)
-            return
-
-        domain_ids = conn.list_instances()
-        try:
-            self.updateInstances_(conn, domain_ids)
-        except Exception, exn:
-            LOG.exception('updateInstances_')
-
-    def updateInstances_(self, conn, domain_ids):
-        for domain_id in domain_ids:
-            if not domain_id in self._instances:
-                instance = Instance(conn, domain_id)
-                self._instances[domain_id] = instance
-                LOG.debug(_('Found instance: %s'), domain_id)
-
-        for key in self._instances.keys():
-            instance = self._instances[key]
-            if instance.needs_update():
-                instance.update()
diff --git a/nova/tests/test_twistd.py b/nova/tests/test_twistd.py
deleted file mode 100644
index ff8627c3b..000000000
--- a/nova/tests/test_twistd.py
+++ /dev/null
@@ -1,53 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright 2010 United States Government as represented by the
-# Administrator of the National Aeronautics and Space Administration.
-# All Rights Reserved.
-#
-#    Licensed under the Apache License, Version 2.0 (the "License"); you may
-#    not use this file except in compliance with the License. You may obtain
-#    a copy of the License at
-#
-#         http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#    License for the specific language governing permissions and limitations
-#    under the License.
-
-import StringIO
-import sys
-
-from nova import twistd
-from nova import exception
-from nova import flags
-from nova import test
-
-
-FLAGS = flags.FLAGS
-
-
-class TwistdTestCase(test.TestCase):
-    def setUp(self):
-        super(TwistdTestCase, self).setUp()
-        self.Options = twistd.WrapTwistedOptions(twistd.TwistdServerOptions)
-        sys.stdout = StringIO.StringIO()
-
-    def tearDown(self):
-        super(TwistdTestCase, self).tearDown()
-        sys.stdout = sys.__stdout__
-
-    def test_basic(self):
-        options = self.Options()
-        argv = options.parseOptions()
-
-    def test_logfile(self):
-        options = self.Options()
-        argv = options.parseOptions(['--logfile=foo'])
-        self.assertEqual(FLAGS.logfile, 'foo')
-
-    def test_help(self):
-        options = self.Options()
-        self.assertRaises(SystemExit, options.parseOptions, ['--help'])
-        self.assert_('pidfile' in sys.stdout.getvalue())
diff --git a/nova/twistd.py b/nova/twistd.py
deleted file mode 100644
index 15cf67825..000000000
--- a/nova/twistd.py
+++ /dev/null
@@ -1,267 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright 2010 United States Government as represented by the
-# Administrator of the National Aeronautics and Space Administration.
-# All Rights Reserved.
-#
-#    Licensed under the Apache License, Version 2.0 (the "License"); you may
-#    not use this file except in compliance with the License. You may obtain
-#    a copy of the License at
-#
-#         http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#    License for the specific language governing permissions and limitations
-#    under the License.
-
-"""
-Twisted daemon helpers, specifically to parse out gFlags from twisted flags,
-manage pid files and support syslogging.
-"""
-
-import gflags
-import os
-import signal
-import sys
-import time
-from twisted.scripts import twistd
-from twisted.python import log
-from twisted.python import reflect
-from twisted.python import runtime
-from twisted.python import usage
-
-from nova import flags
-from nova import log as logging
-
-
-if runtime.platformType == "win32":
-    from twisted.scripts._twistw import ServerOptions
-else:
-    from twisted.scripts._twistd_unix import ServerOptions
-
-
-FLAGS = flags.FLAGS
-
-
-class TwistdServerOptions(ServerOptions):
-    def parseArgs(self, *args):
-        return
-
-
-class FlagParser(object):
-    # this is a required attribute for gflags
-    syntactic_help = ''
-
-    def __init__(self, parser):
-        self.parser = parser
-
-    def Parse(self, s):
-        return self.parser(s)
-
-
-def WrapTwistedOptions(wrapped):
-    class TwistedOptionsToFlags(wrapped):
-        subCommands = None
-
-        def __init__(self):
-            # NOTE(termie): _data exists because Twisted stuff expects
-            #               to be able to set arbitrary things that are
-            #               not actual flags
-            self._data = {}
-            self._flagHandlers = {}
-            self._paramHandlers = {}
-
-            # Absorb the twistd flags into our FLAGS
-            self._absorbFlags()
-            self._absorbParameters()
-            self._absorbHandlers()
-
-            wrapped.__init__(self)
-
-        def _absorbFlags(self):
-            twistd_flags = []
-            reflect.accumulateClassList(self.__class__, 'optFlags',
-                                        twistd_flags)
-            for flag in twistd_flags:
-                key = flag[0].replace('-', '_')
-                if hasattr(FLAGS, key):
-                    continue
-                flags.DEFINE_boolean(key, None, str(flag[-1]))
-
-        def _absorbParameters(self):
-            twistd_params = []
-            reflect.accumulateClassList(self.__class__, 'optParameters',
-                                        twistd_params)
-            for param in twistd_params:
-                key = param[0].replace('-', '_')
-                if hasattr(FLAGS, key):
-                    continue
-                if len(param) > 4:
-                    flags.DEFINE(FlagParser(param[4]),
-                                 key, param[2], str(param[3]),
-                                 serializer=gflags.ArgumentSerializer())
-                else:
-                    flags.DEFINE_string(key, param[2], str(param[3]))
-
-        def _absorbHandlers(self):
-            twistd_handlers = {}
-            reflect.addMethodNamesToDict(self.__class__, twistd_handlers,
-                                         "opt_")
-
-            # NOTE(termie): Much of the following is derived/copied from
-            #               twisted.python.usage with the express purpose of
-            #               providing compatibility
-            for name in twistd_handlers.keys():
-                method = getattr(self, 'opt_' + name)
-
-                takesArg = not usage.flagFunction(method, name)
-                doc = getattr(method, '__doc__', None)
-                if not doc:
-                    doc = 'undocumented'
-
-                if not takesArg:
-                    if name not in FLAGS:
-                        flags.DEFINE_boolean(name, None, doc)
-                    self._flagHandlers[name] = method
-                else:
-                    if name not in FLAGS:
-                        flags.DEFINE_string(name, None, doc)
-                    self._paramHandlers[name] = method
-
-        def _doHandlers(self):
-            for flag, handler in self._flagHandlers.iteritems():
-                if self[flag]:
-                    handler()
-            for param, handler in self._paramHandlers.iteritems():
-                if self[param] is not None:
-                    handler(self[param])
-
-        def __str__(self):
-            return str(FLAGS)
-
-        def parseOptions(self, options=None):
-            if options is None:
-                options = sys.argv
-            else:
-                options.insert(0, '')
-
-            args = FLAGS(options)
-            logging.setup()
-            argv = args[1:]
-            # ignore subcommands
-
-            try:
-                self.parseArgs(*argv)
-            except TypeError:
-                raise usage.UsageError(_("Wrong number of arguments."))
-
-            self.postOptions()
-            return args
-
-        def parseArgs(self, *args):
-            # TODO(termie): figure out a decent way of dealing with args
-            #return
-            wrapped.parseArgs(self, *args)
-
-        def postOptions(self):
-            self._doHandlers()
-
-            wrapped.postOptions(self)
-
-        def __getitem__(self, key):
-            key = key.replace('-', '_')
-            try:
-                return getattr(FLAGS, key)
-            except (AttributeError, KeyError):
-                return self._data[key]
-
-        def __setitem__(self, key, value):
-            key = key.replace('-', '_')
-            try:
-                return setattr(FLAGS, key, value)
-            except (AttributeError, KeyError):
-                self._data[key] = value
-
-        def get(self, key, default):
-            key = key.replace('-', '_')
-            try:
-                return getattr(FLAGS, key)
-            except (AttributeError, KeyError):
-                self._data.get(key, default)
-
-    return TwistedOptionsToFlags
-
-
-def stop(pidfile):
-    """
-    Stop the daemon
-    """
-    # Get the pid from the pidfile
-    try:
-        pf = file(pidfile, 'r')
-        pid = int(pf.read().strip())
-        pf.close()
-    except IOError:
-        pid = None
-
-    if not pid:
-        message = _("pidfile %s does not exist. Daemon not running?\n")
-        sys.stderr.write(message % pidfile)
-        # Not an error in a restart
-        return
-
-    # Try killing the daemon process
-    try:
-        while 1:
-            os.kill(pid, signal.SIGKILL)
-            time.sleep(0.1)
-    except OSError, err:
-        err = str(err)
-        if err.find(_("No such process")) > 0:
-            if os.path.exists(pidfile):
-                os.remove(pidfile)
-        else:
-            print str(err)
-            sys.exit(1)
-
-
-def serve(filename):
-    logging.debug(_("Serving %s") % filename)
-    name = os.path.basename(filename)
-    OptionsClass = WrapTwistedOptions(TwistdServerOptions)
-    options = OptionsClass()
-    argv = options.parseOptions()
-    FLAGS.python = filename
-    FLAGS.no_save = True
-    if not FLAGS.pidfile:
-        FLAGS.pidfile = '%s.pid' % name
-    elif FLAGS.pidfile.endswith('twistd.pid'):
-        FLAGS.pidfile = FLAGS.pidfile.replace('twistd.pid', '%s.pid' % name)
-    if not FLAGS.prefix:
-        FLAGS.prefix = name
-    elif FLAGS.prefix.endswith('twisted'):
-        FLAGS.prefix = FLAGS.prefix.replace('twisted', name)
-
-    action = 'start'
-    if len(argv) > 1:
-        action = argv.pop()
-
-    if action == 'stop':
-        stop(FLAGS.pidfile)
-        sys.exit()
-    elif action == 'restart':
-        stop(FLAGS.pidfile)
-    elif action == 'start':
-        pass
-    else:
-        print 'usage: %s [options] [start|stop|restart]' % argv[0]
-        sys.exit(1)
-
-    logging.debug(_("Full set of FLAGS:"))
-    for flag in FLAGS:
-        logging.debug("%s : %s" % (flag, FLAGS.get(flag, None)))
-
-    logging.audit(_("Starting %s"), name)
-    twistd.runApp(options)
diff --git a/nova/virt/fake.py b/nova/virt/fake.py
index 26bc421c0..2898f23a4 100644
--- a/nova/virt/fake.py
+++ b/nova/virt/fake.py
@@ -340,8 +340,7 @@ class FakeConnection(driver.ComputeDriver):
         only useful for giving back to this layer as a parameter to
         disk_stats).  These IDs only need to be unique for a given instance.
 
-        Note that this function takes an instance ID, not a
-        compute.service.Instance, so that it can be called by compute.monitor.
+        Note that this function takes an instance ID.
         """
         return ['A_DISK']
 
@@ -353,8 +352,7 @@ class FakeConnection(driver.ComputeDriver):
         interface_stats).  These IDs only need to be unique for a given
         instance.
 
-        Note that this function takes an instance ID, not a
-        compute.service.Instance, so that it can be called by compute.monitor.
+        Note that this function takes an instance ID.
         """
         return ['A_VIF']
 
@@ -374,8 +372,7 @@ class FakeConnection(driver.ComputeDriver):
         having to do the aggregation.  On those platforms, this method is
         unused.
 
-        Note that this function takes an instance ID, not a
-        compute.service.Instance, so that it can be called by compute.monitor.
+        Note that this function takes an instance ID.
         """
         return [0L, 0L, 0L, 0L, None]
 
@@ -395,8 +392,7 @@ class FakeConnection(driver.ComputeDriver):
         having to do the aggregation.  On those platforms, this method is
         unused.
 
-        Note that this function takes an instance ID, not a
-        compute.service.Instance, so that it can be called by compute.monitor.
+        Note that this function takes an instance ID.
         """
         return [0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L]
 
diff --git a/nova/virt/libvirt/connection.py b/nova/virt/libvirt/connection.py
index 17c328a83..b9b247aab 100644
--- a/nova/virt/libvirt/connection.py
+++ b/nova/virt/libvirt/connection.py
@@ -1087,8 +1087,7 @@ class LibvirtConnection(driver.ComputeDriver):
 
     def get_disks(self, instance_name):
         """
-        Note that this function takes an instance name, not an Instance, so
-        that it can be called by monitor.
+        Note that this function takes an instance name.
 
         Returns a list of all block devices for this domain.
         """
@@ -1129,8 +1128,7 @@ class LibvirtConnection(driver.ComputeDriver):
 
     def get_interfaces(self, instance_name):
         """
-        Note that this function takes an instance name, not an Instance, so
-        that it can be called by monitor.
+        Note that this function takes an instance name.
 
         Returns a list of all network interfaces for this instance.
         """
@@ -1345,16 +1343,14 @@ class LibvirtConnection(driver.ComputeDriver):
 
     def block_stats(self, instance_name, disk):
         """
-        Note that this function takes an instance name, not an Instance, so
-        that it can be called by monitor.
+        Note that this function takes an instance name.
         """
         domain = self._lookup_by_name(instance_name)
         return domain.blockStats(disk)
 
     def interface_stats(self, instance_name, interface):
         """
-        Note that this function takes an instance name, not an Instance, so
-        that it can be called by monitor.
+        Note that this function takes an instance name.
         """
         domain = self._lookup_by_name(instance_name)
         return domain.interfaceStats(interface)