merged from trunk

10 files changed, 393 insertions, 94 deletions

diff --git a/bin/nova-ajax-console-proxy b/bin/nova-ajax-console-proxy
index bbd60bade..d88f59e40 100755
--- a/bin/nova-ajax-console-proxy
+++ b/bin/nova-ajax-console-proxy
@@ -1,5 +1,5 @@
 #!/usr/bin/env python
-# pylint: disable-msg=C0103
+# pylint: disable=C0103
 # vim: tabstop=4 shiftwidth=4 softtabstop=4
 
 # Copyright 2010 United States Government as represented by the
@@ -108,17 +108,17 @@ class AjaxConsoleProxy(object):
             return "Server Error"
 
     def register_listeners(self):
-        class Callback:
-            def __call__(self, data, message):
-                if data['method'] == 'authorize_ajax_console':
-                    AjaxConsoleProxy.tokens[data['args']['token']] =  \
-                        {'args': data['args'], 'last_activity': time.time()}
+        class TopicProxy():
+            @staticmethod
+            def authorize_ajax_console(context, **kwargs):
+                AjaxConsoleProxy.tokens[kwargs['token']] =  \
+                    {'args': kwargs, 'last_activity': time.time()}
 
         conn = rpc.Connection.instance(new=True)
-        consumer = rpc.TopicConsumer(
-                        connection=conn,
-                        topic=FLAGS.ajax_console_proxy_topic)
-        consumer.register_callback(Callback())
+        consumer = rpc.TopicAdapterConsumer(
+                       connection=conn,
+                       proxy=TopicProxy,
+                       topic=FLAGS.ajax_console_proxy_topic)
 
         def delete_expired_tokens():
             now = time.time()
@@ -130,8 +130,7 @@ class AjaxConsoleProxy(object):
             for k in to_delete:
                 del AjaxConsoleProxy.tokens[k]
 
-        utils.LoopingCall(consumer.fetch, auto_ack=True,
-                          enable_callbacks=True).start(0.1)
+        utils.LoopingCall(consumer.fetch, enable_callbacks=True).start(0.1)
         utils.LoopingCall(delete_expired_tokens).start(1)
 
 if __name__ == '__main__':
diff --git a/bin/nova-api b/bin/nova-api
index 06bb855cb..a1088c23d 100755
--- a/bin/nova-api
+++ b/bin/nova-api
@@ -1,5 +1,5 @@
 #!/usr/bin/env python
-# pylint: disable-msg=C0103
+# pylint: disable=C0103
 # vim: tabstop=4 shiftwidth=4 softtabstop=4
 
 # Copyright 2010 United States Government as represented by the
diff --git a/bin/nova-compute b/bin/nova-compute
index 95fa393b1..cd7c78def 100755
--- a/bin/nova-compute
+++ b/bin/nova-compute
@@ -28,11 +28,11 @@ import sys
 
 # If ../nova/__init__.py exists, add ../ to Python search path, so that
 # it will override what happens to be installed in /usr/(local/)lib/python...
-possible_topdir = os.path.normpath(os.path.join(os.path.abspath(sys.argv[0]),
+POSSIBLE_TOPDIR = os.path.normpath(os.path.join(os.path.abspath(sys.argv[0]),
                                    os.pardir,
                                    os.pardir))
-if os.path.exists(os.path.join(possible_topdir, 'nova', '__init__.py')):
-    sys.path.insert(0, possible_topdir)
+if os.path.exists(os.path.join(POSSIBLE_TOPDIR, 'nova', '__init__.py')):
+    sys.path.insert(0, POSSIBLE_TOPDIR)
 
 gettext.install('nova', unicode=1)
 
diff --git a/bin/nova-dhcpbridge b/bin/nova-dhcpbridge
index 3dd9de367..f42dfd6b5 100755
--- a/bin/nova-dhcpbridge
+++ b/bin/nova-dhcpbridge
@@ -48,6 +48,7 @@ flags.DECLARE('auth_driver', 'nova.auth.manager')
 flags.DECLARE('network_size', 'nova.network.manager')
 flags.DECLARE('num_networks', 'nova.network.manager')
 flags.DECLARE('update_dhcp_on_disassociate', 'nova.network.manager')
+flags.DEFINE_string('dnsmasq_interface', 'br0', 'Default Dnsmasq interface')
 
 LOG = logging.getLogger('nova.dhcpbridge')
 
@@ -94,7 +95,7 @@ def init_leases(interface):
     """Get the list of hosts for an interface."""
     ctxt = context.get_admin_context()
     network_ref = db.network_get_by_bridge(ctxt, interface)
-    return linux_net.get_dhcp_hosts(ctxt, network_ref['id'])
+    return linux_net.get_dhcp_leases(ctxt, network_ref['id'])
 
 
 def main():
@@ -103,7 +104,8 @@ def main():
     utils.default_flagfile(flagfile)
     argv = FLAGS(sys.argv)
     logging.setup()
-    interface = os.environ.get('DNSMASQ_INTERFACE', 'br0')
+    # check ENV first so we don't break any older deploys
+    interface = os.environ.get('DNSMASQ_INTERFACE', FLAGS.dnsmasq_interface)
     if int(os.environ.get('TESTING', '0')):
         from nova.tests import fake_flags
     action = argv[1]
diff --git a/bin/nova-direct-api b/bin/nova-direct-api
index bf29d9a5e..83ec72722 100755
--- a/bin/nova-direct-api
+++ b/bin/nova-direct-api
@@ -1,5 +1,5 @@
 #!/usr/bin/env python
-# pylint: disable-msg=C0103
+# pylint: disable=C0103
 # vim: tabstop=4 shiftwidth=4 softtabstop=4
 
 # Copyright 2010 United States Government as represented by the
@@ -34,12 +34,14 @@ if os.path.exists(os.path.join(possible_topdir, 'nova', '__init__.py')):
 
 gettext.install('nova', unicode=1)
 
+from nova import compute
 from nova import flags
 from nova import log as logging
+from nova import network
 from nova import utils
+from nova import volume
 from nova import wsgi
 from nova.api import direct
-from nova.compute import api as compute_api
 
 
 FLAGS = flags.FLAGS
@@ -50,13 +52,42 @@ flags.DEFINE_flag(flags.HelpshortFlag())
 flags.DEFINE_flag(flags.HelpXMLFlag())
 
 
+# An example of an API that only exposes read-only methods.
+# In this case we're just limiting which methods are exposed.
+class ReadOnlyCompute(direct.Limited):
+    """Read-only Compute API."""
+
+    _allowed = ['get', 'get_all', 'get_console_output']
+
+
+# An example of an API that provides a backwards compatibility layer.
+# In this case we're overwriting the implementation to ensure
+# compatibility with an older version. In reality we would want the
+# "description=None" to be part of the actual API so that code
+# like this isn't even necessary, but this example shows what one can
+# do if that isn't the situation.
+class VolumeVersionOne(direct.Limited):
+    _allowed = ['create', 'delete', 'update', 'get']
+
+    def create(self, context, size, name):
+        self.proxy.create(context, size, name, description=None)
+
+
 if __name__ == '__main__':
     utils.default_flagfile()
     FLAGS(sys.argv)
     logging.setup()
 
-    direct.register_service('compute', compute_api.API())
+    direct.register_service('compute', compute.API())
+    direct.register_service('volume', volume.API())
+    direct.register_service('network', network.API())
     direct.register_service('reflect', direct.Reflection())
+
+    # Here is how we could expose the code in the examples above.
+    #direct.register_service('compute-readonly',
+    #                        ReadOnlyCompute(compute.API()))
+    #direct.register_service('volume-v1', VolumeVersionOne(volume.API()))
+
     router = direct.Router()
     with_json = direct.JsonParamsMiddleware(router)
     with_req = direct.PostParamsMiddleware(with_json)
diff --git a/bin/nova-instancemonitor b/bin/nova-instancemonitor
index 24cc9fd23..b9d4e49d7 100755
--- a/bin/nova-instancemonitor
+++ b/bin/nova-instancemonitor
@@ -50,7 +50,7 @@ if __name__ == '__main__':
 
 if __name__ == '__builtin__':
     LOG.warn(_('Starting instance monitor'))
-    # pylint: disable-msg=C0103
+    # pylint: disable=C0103
     monitor = monitor.InstanceMonitor()
 
     # This is the parent service that twistd will be looking for when it
diff --git a/bin/nova-manage b/bin/nova-manage
index a880a9c2f..a36ec86d0 100755
--- a/bin/nova-manage
+++ b/bin/nova-manage
@@ -58,7 +58,6 @@ import gettext
 import glob
 import json
 import os
-import re
 import sys
 import time
 
@@ -66,11 +65,11 @@ import IPy
 
 # If ../nova/__init__.py exists, add ../ to Python search path, so that
 # it will override what happens to be installed in /usr/(local/)lib/python...
-possible_topdir = os.path.normpath(os.path.join(os.path.abspath(sys.argv[0]),
+POSSIBLE_TOPDIR = os.path.normpath(os.path.join(os.path.abspath(sys.argv[0]),
                                    os.pardir,
                                    os.pardir))
-if os.path.exists(os.path.join(possible_topdir, 'nova', '__init__.py')):
-    sys.path.insert(0, possible_topdir)
+if os.path.exists(os.path.join(POSSIBLE_TOPDIR, 'nova', '__init__.py')):
+    sys.path.insert(0, POSSIBLE_TOPDIR)
 
 gettext.install('nova', unicode=1)
 
@@ -83,6 +82,7 @@ from nova import log as logging
 from nova import quota
 from nova import rpc
 from nova import utils
+from nova import version
 from nova.api.ec2 import ec2utils
 from nova.auth import manager
 from nova.cloudpipe import pipelib
@@ -97,6 +97,7 @@ flags.DECLARE('vlan_start', 'nova.network.manager')
 flags.DECLARE('vpn_start', 'nova.network.manager')
 flags.DECLARE('fixed_range_v6', 'nova.network.manager')
 flags.DECLARE('images_path', 'nova.image.local')
+flags.DECLARE('libvirt_type', 'nova.virt.libvirt_conn')
 flags.DEFINE_flag(flags.HelpFlag())
 flags.DEFINE_flag(flags.HelpshortFlag())
 flags.DEFINE_flag(flags.HelpXMLFlag())
@@ -150,7 +151,7 @@ class VpnCommands(object):
                     state = 'up'
                 print address,
                 print vpn['host'],
-                print vpn['ec2_id'],
+                print ec2utils.id_to_ec2_id(vpn['id']),
                 print vpn['state_description'],
                 print state
             else:
@@ -276,7 +277,7 @@ def _db_error(caught_exception):
     print caught_exception
     print _("The above error may show that the database has not "
             "been created.\nPlease create a database using "
-            "nova-manage sync db before running this command.")
+            "'nova-manage db sync' before running this command.")
     exit(1)
 
 
@@ -385,10 +386,10 @@ class ProjectCommands(object):
         with open(filename, 'w') as f:
             f.write(rc)
 
-    def list(self):
+    def list(self, username=None):
         """Lists all projects
-        arguments: <none>"""
-        for project in self.manager.get_projects():
+        arguments: [username]"""
+        for project in self.manager.get_projects(username):
             print project.name
 
     def quota(self, project_id, key=None, value=None):
@@ -446,10 +447,15 @@ class FixedIpCommands(object):
     def list(self, host=None):
         """Lists all fixed ips (optionally by host) arguments: [host]"""
         ctxt = context.get_admin_context()
-        if host == None:
-            fixed_ips = db.fixed_ip_get_all(ctxt)
-        else:
-            fixed_ips = db.fixed_ip_get_all_by_host(ctxt, host)
+
+        try:
+            if host is None:
+                fixed_ips = db.fixed_ip_get_all(ctxt)
+            else:
+                fixed_ips = db.fixed_ip_get_all_by_host(ctxt, host)
+        except exception.NotFound as ex:
+            print "error: %s" % ex
+            sys.exit(2)
 
         print "%-18s\t%-15s\t%-17s\t%-15s\t%s" % (_('network'),
                                                   _('IP address'),
@@ -466,9 +472,9 @@ class FixedIpCommands(object):
                 host = instance['host']
                 mac_address = instance['mac_address']
             print "%-18s\t%-15s\t%-17s\t%-15s\t%s" % (
-                                  fixed_ip['network']['cidr'],
-                                  fixed_ip['address'],
-                                  mac_address, hostname, host)
+                    fixed_ip['network']['cidr'],
+                    fixed_ip['address'],
+                    mac_address, hostname, host)
 
 
 class FloatingIpCommands(object):
@@ -493,7 +499,7 @@ class FloatingIpCommands(object):
         """Lists all floating ips (optionally by host)
         arguments: [host]"""
         ctxt = context.get_admin_context()
-        if host == None:
+        if host is None:
             floating_ips = db.floating_ip_get_all(ctxt)
         else:
             floating_ips = db.floating_ip_get_all_by_host(ctxt, host)
@@ -513,11 +519,12 @@ class NetworkCommands(object):
                network_size=None, vlan_start=None,
                vpn_start=None, fixed_range_v6=None, label='public'):
         """Creates fixed ips for host by range
-        arguments: [fixed_range=FLAG], [num_networks=FLAG],
+        arguments: fixed_range=FLAG, [num_networks=FLAG],
                    [network_size=FLAG], [vlan_start=FLAG],
                    [vpn_start=FLAG], [fixed_range_v6=FLAG]"""
         if not fixed_range:
-            fixed_range = FLAGS.fixed_range
+            raise TypeError(_('Fixed range in the form of 10.0.0.0/8 is '
+                              'required to create networks.'))
         if not num_networks:
             num_networks = FLAGS.num_networks
         if not network_size:
@@ -560,6 +567,85 @@ class NetworkCommands(object):
         db.network_delete_safe(context.get_admin_context(), network.id)
 
 
+class VmCommands(object):
+    """Class for mangaging VM instances."""
+
+    def list(self, host=None):
+        """Show a list of all instances
+
+        :param host: show all instance on specified host.
+        :param instance: show specificed instance.
+        """
+        print "%-10s %-15s %-10s %-10s %-19s %-12s %-12s %-12s" \
+              "  %-10s %-10s %-10s %-5s" % (
+            _('instance'),
+            _('node'),
+            _('type'),
+            _('state'),
+            _('launched'),
+            _('image'),
+            _('kernel'),
+            _('ramdisk'),
+            _('project'),
+            _('user'),
+            _('zone'),
+            _('index'))
+
+        if host is None:
+            instances = db.instance_get_all(context.get_admin_context())
+        else:
+            instances = db.instance_get_all_by_host(
+                           context.get_admin_context(), host)
+
+        for instance in instances:
+            print "%-10s %-15s %-10s %-10s %-19s %-12s %-12s %-12s" \
+                  "  %-10s %-10s %-10s %-5d" % (
+                instance['hostname'],
+                instance['host'],
+                instance['instance_type'],
+                instance['state_description'],
+                instance['launched_at'],
+                instance['image_id'],
+                instance['kernel_id'],
+                instance['ramdisk_id'],
+                instance['project_id'],
+                instance['user_id'],
+                instance['availability_zone'],
+                instance['launch_index'])
+
+    def live_migration(self, ec2_id, dest):
+        """Migrates a running instance to a new machine.
+
+        :param ec2_id: instance id which comes from euca-describe-instance.
+        :param dest: destination host name.
+
+        """
+
+        ctxt = context.get_admin_context()
+        instance_id = ec2utils.ec2_id_to_id(ec2_id)
+
+        if (FLAGS.connection_type != 'libvirt' or
+           (FLAGS.connection_type == 'libvirt' and
+            FLAGS.libvirt_type not in ['kvm', 'qemu'])):
+            msg = _('Only KVM and QEmu are supported for now. Sorry!')
+            raise exception.Error(msg)
+
+        if (FLAGS.volume_driver != 'nova.volume.driver.AOEDriver' and \
+            FLAGS.volume_driver != 'nova.volume.driver.ISCSIDriver'):
+            msg = _("Support only AOEDriver and ISCSIDriver. Sorry!")
+            raise exception.Error(msg)
+
+        rpc.call(ctxt,
+                 FLAGS.scheduler_topic,
+                 {"method": "live_migration",
+                  "args": {"instance_id": instance_id,
+                           "dest": dest,
+                           "topic": FLAGS.compute_topic}})
+
+        print _('Migration of %s initiated.'
+               'Check its progress using euca-describe-instances.') % ec2_id
+
+
 class ServiceCommands(object):
     """Enable and disable running services"""
 
@@ -568,7 +654,7 @@ class ServiceCommands(object):
         args: [host] [service]"""
         ctxt = context.get_admin_context()
         now = datetime.datetime.utcnow()
-        services = db.service_get_all(ctxt) + db.service_get_all(ctxt, True)
+        services = db.service_get_all(ctxt)
         if host:
             services = [s for s in services if s['host'] == host]
         if service:
@@ -604,14 +690,58 @@ class ServiceCommands(object):
             return
         db.service_update(ctxt, svc['id'], {'disabled': True})
 
+    def describe_resource(self, host):
+        """Describes cpu/memory/hdd info for host.
+
+        :param host: hostname.
+
+        """
+
+        result = rpc.call(context.get_admin_context(),
+                     FLAGS.scheduler_topic,
+                     {"method": "show_host_resources",
+                      "args": {"host": host}})
+
+        if type(result) != dict:
+            print _('An unexpected error has occurred.')
+            print _('[Result]'), result
+        else:
+            cpu = result['resource']['vcpus']
+            mem = result['resource']['memory_mb']
+            hdd = result['resource']['local_gb']
+            cpu_u = result['resource']['vcpus_used']
+            mem_u = result['resource']['memory_mb_used']
+            hdd_u = result['resource']['local_gb_used']
+
+            print 'HOST\t\t\tPROJECT\t\tcpu\tmem(mb)\tdisk(gb)'
+            print '%s(total)\t\t\t%s\t%s\t%s' % (host, cpu, mem, hdd)
+            print '%s(used)\t\t\t%s\t%s\t%s' % (host, cpu_u, mem_u, hdd_u)
+            for p_id, val in result['usage'].items():
+                print '%s\t\t%s\t\t%s\t%s\t%s' % (host,
+                                                  p_id,
+                                                  val['vcpus'],
+                                                  val['memory_mb'],
+                                                  val['local_gb'])
+
+    def update_resource(self, host):
+        """Updates available vcpu/memory/disk info for host.
+
+        :param host: hostname.
+
+        """
 
-class LogCommands(object):
-    def request(self, request_id, logfile='/var/log/nova.log'):
-        """Show all fields in the log for the given request.  Assumes you
-        haven't changed the log format too much.
-        ARGS: request_id [logfile]"""
-        lines = utils.execute("cat %s | grep '\[%s '" % (logfile, request_id))
-        print re.sub('#012', "\n", "\n".join(lines))
+        ctxt = context.get_admin_context()
+        service_refs = db.service_get_all_by_host(ctxt, host)
+        if len(service_refs) <= 0:
+            raise exception.Invalid(_('%s does not exist.') % host)
+
+        service_refs = [s for s in service_refs if s['topic'] == 'compute']
+        if len(service_refs) <= 0:
+            raise exception.Invalid(_('%s is not compute node.') % host)
+
+        rpc.call(ctxt,
+                 db.queue_get_for(ctxt, FLAGS.compute_topic, host),
+                 {"method": "update_available_resource"})
 
 
 class DbCommands(object):
@@ -629,6 +759,17 @@ class DbCommands(object):
         print migration.db_version()
 
 
+class VersionCommands(object):
+    """Class for exposing the codebase version."""
+
+    def __init__(self):
+        pass
+
+    def list(self):
+        print _("%s (%s)") %\
+                (version.version_string(), version.version_string_with_vcs())
+
+
 class VolumeCommands(object):
     """Methods for dealing with a cloud in an odd state"""
 
@@ -679,11 +820,11 @@ class VolumeCommands(object):
 class InstanceTypeCommands(object):
     """Class for managing instance types / flavors."""
 
-    def _print_instance_types(self, n, val):
+    def _print_instance_types(self, name, val):
         deleted = ('', ', inactive')[val["deleted"] == 1]
         print ("%s: Memory: %sMB, VCPUS: %s, Storage: %sGB, FlavorID: %s, "
             "Swap: %sGB, RXTX Quota: %sGB, RXTX Cap: %sMB%s") % (
-            n, val["memory_mb"], val["vcpus"], val["local_gb"],
+            name, val["memory_mb"], val["vcpus"], val["local_gb"],
             val["flavorid"], val["swap"], val["rxtx_quota"],
             val["rxtx_cap"], deleted)
 
@@ -697,11 +838,17 @@ class InstanceTypeCommands(object):
             instance_types.create(name, memory, vcpus, local_gb,
                                   flavorid, swap, rxtx_quota, rxtx_cap)
         except exception.InvalidInputException:
-            print "Must supply valid parameters to create instance type"
+            print "Must supply valid parameters to create instance_type"
             print e
             sys.exit(1)
-        except exception.DBError, e:
-            print "DB Error: %s" % e
+        except exception.ApiError, e:
+            print "\n\n"
+            print "\n%s" % e
+            print "Please ensure instance_type name and flavorid are unique."
+            print "To complete remove a instance_type, use the --purge flag:"
+            print "\n     # nova-manage instance_type delete <name> --purge\n"
+            print "Currently defined instance_type names and flavorids:"
+            self.list("--all")
             sys.exit(2)
         except:
             print "Unknown error"
@@ -734,12 +881,12 @@ class InstanceTypeCommands(object):
         """Lists all active or specific instance types / flavors
         arguments: [name]"""
         try:
-            if name == None:
+            if name is None:
                 inst_types = instance_types.get_all_types()
             elif name == "--all":
-                inst_types = instance_types.get_all_types(1)
+                inst_types = instance_types.get_all_types(True)
             else:
-                inst_types = instance_types.get_instance_type(name)
+                inst_types = instance_types.get_instance_type_by_name(name)
         except exception.DBError, e:
             _db_error(e)
         if isinstance(inst_types.values()[0], dict):
@@ -755,20 +902,17 @@ class ImageCommands(object):
     def __init__(self, *args, **kwargs):
         self.image_service = utils.import_object(FLAGS.image_service)
 
-    def _register(self, image_type, disk_format, container_format,
+    def _register(self, container_format, disk_format,
                   path, owner, name=None, is_public='T',
                   architecture='x86_64', kernel_id=None, ramdisk_id=None):
-        meta = {'is_public': True,
+        meta = {'is_public': (is_public == 'T'),
                 'name': name,
-                'disk_format': disk_format,
                 'container_format': container_format,
+                'disk_format': disk_format,
                 'properties': {'image_state': 'available',
-                               'owner': owner,
-                               'type': image_type,
+                               'project_id': owner,
                                'architecture': architecture,
-                               'image_location': 'local',
-                               'is_public': (is_public == 'T')}}
-        print image_type, meta
+                               'image_location': 'local'}}
         if kernel_id:
             meta['properties']['kernel_id'] = int(kernel_id)
         if ramdisk_id:
@@ -793,16 +937,18 @@ class ImageCommands(object):
         ramdisk_id = self.ramdisk_register(ramdisk, owner, None,
                                     is_public, architecture)
         self.image_register(image, owner, name, is_public,
-                       architecture, kernel_id, ramdisk_id)
+                            architecture, 'ami', 'ami',
+                            kernel_id, ramdisk_id)
 
     def image_register(self, path, owner, name=None, is_public='T',
-                       architecture='x86_64', kernel_id=None, ramdisk_id=None,
-                       disk_format='ami', container_format='ami'):
+                       architecture='x86_64', container_format='bare',
+                       disk_format='raw', kernel_id=None, ramdisk_id=None):
         """Uploads an image into the image_service
         arguments: path owner [name] [is_public='T'] [architecture='x86_64']
+                   [container_format='bare'] [disk_format='raw']
                    [kernel_id=None] [ramdisk_id=None]
-                   [disk_format='ami'] [container_format='ami']"""
-        return self._register('machine', disk_format, container_format, path,
+        """
+        return self._register(container_format, disk_format, path,
                               owner, name, is_public, architecture,
                               kernel_id, ramdisk_id)
 
@@ -811,7 +957,7 @@ class ImageCommands(object):
         """Uploads a kernel into the image_service
         arguments: path owner [name] [is_public='T'] [architecture='x86_64']
         """
-        return self._register('kernel', 'aki', 'aki', path, owner, name,
+        return self._register('aki', 'aki', path, owner, name,
                               is_public, architecture)
 
     def ramdisk_register(self, path, owner, name=None, is_public='T',
@@ -819,14 +965,14 @@ class ImageCommands(object):
         """Uploads a ramdisk into the image_service
         arguments: path owner [name] [is_public='T'] [architecture='x86_64']
         """
-        return self._register('ramdisk', 'ari', 'ari', path, owner, name,
+        return self._register('ari', 'ari', path, owner, name,
                               is_public, architecture)
 
     def _lookup(self, old_image_id):
         try:
             internal_id = ec2utils.ec2_id_to_id(old_image_id)
             image = self.image_service.show(context, internal_id)
-        except exception.NotFound:
+        except (exception.InvalidEc2Id, exception.ImageNotFound):
             image = self.image_service.show_by_name(context, old_image_id)
         return image['id']
 
@@ -836,16 +982,17 @@ class ImageCommands(object):
                    'ramdisk': 'ari'}
         container_format = mapping[old['type']]
         disk_format = container_format
+        if container_format == 'ami' and not old.get('kernelId'):
+            container_format = 'bare'
+            disk_format = 'raw'
         new = {'disk_format': disk_format,
                'container_format': container_format,
-               'is_public': True,
+               'is_public': old['isPublic'],
                'name': old['imageId'],
                'properties': {'image_state': old['imageState'],
-                              'owner': old['imageOwnerId'],
+                              'project_id': old['imageOwnerId'],
                               'architecture': old['architecture'],
-                              'type': old['type'],
-                              'image_location': old['imageLocation'],
-                              'is_public': old['isPublic']}}
+                              'image_location': old['imageLocation']}}
         if old.get('kernelId'):
             new['properties']['kernel_id'] = self._lookup(old['kernelId'])
         if old.get('ramdiskId'):
@@ -879,7 +1026,7 @@ class ImageCommands(object):
         if (FLAGS.image_service == 'nova.image.local.LocalImageService'
             and directory == os.path.abspath(FLAGS.images_path)):
             new_dir = "%s_bak" % directory
-            os.move(directory, new_dir)
+            os.rename(directory, new_dir)
             os.mkdir(directory)
             directory = new_dir
         for fn in glob.glob("%s/*/info.json" % directory):
@@ -891,7 +1038,7 @@ class ImageCommands(object):
                     machine_images[image_path] = image_metadata
                 else:
                     other_images[image_path] = image_metadata
-            except Exception as exc:
+            except Exception:
                 print _("Failed to load %(fn)s.") % locals()
         # NOTE(vish): do kernels and ramdisks first so images
         self._convert_images(other_images)
@@ -908,13 +1055,14 @@ CATEGORIES = [
     ('fixed', FixedIpCommands),
     ('floating', FloatingIpCommands),
     ('network', NetworkCommands),
+    ('vm', VmCommands),
     ('service', ServiceCommands),
-    ('log', LogCommands),
     ('db', DbCommands),
     ('volume', VolumeCommands),
     ('instance_type', InstanceTypeCommands),
     ('image', ImageCommands),
-    ('flavor', InstanceTypeCommands)]
+    ('flavor', InstanceTypeCommands),
+    ('version', VersionCommands)]
 
 
 def lazy_match(name, key_value_tuples):
@@ -956,9 +1104,11 @@ def main():
 
     script_name = argv.pop(0)
     if len(argv) < 1:
+        print _("\nOpenStack Nova version: %s (%s)\n") %\
+                (version.version_string(), version.version_string_with_vcs())
         print script_name + " category action [<args>]"
-        print "Available categories:"
-        for k, _ in CATEGORIES:
+        print _("Available categories:")
+        for k, _v in CATEGORIES:
             print "\t%s" % k
         sys.exit(2)
     category = argv.pop(0)
@@ -969,7 +1119,7 @@ def main():
     actions = methods_of(command_object)
     if len(argv) < 1:
         print script_name + " category action [<args>]"
-        print "Available actions for %s category:" % category
+        print _("Available actions for %s category:") % category
         for k, _v in actions:
             print "\t%s" % k
         sys.exit(2)
@@ -981,9 +1131,12 @@ def main():
         fn(*argv)
         sys.exit(0)
     except TypeError:
-        print "Possible wrong number of arguments supplied"
+        print _("Possible wrong number of arguments supplied")
         print "%s %s: %s" % (category, action, fn.__doc__)
         raise
+    except Exception:
+        print _("Command failed, please check log for more info")
+        raise
 
 if __name__ == '__main__':
     main()
diff --git a/bin/nova-objectstore b/bin/nova-objectstore
index 9fbe228a2..6ef841b85 100755
--- a/bin/nova-objectstore
+++ b/bin/nova-objectstore
@@ -36,9 +36,10 @@ if os.path.exists(os.path.join(possible_topdir, 'nova', '__init__.py')):
 gettext.install('nova', unicode=1)
 
 from nova import flags
+from nova import log as logging
 from nova import utils
-from nova import twistd
-from nova.objectstore import handler
+from nova import wsgi
+from nova.objectstore import s3server
 
 
 FLAGS = flags.FLAGS
@@ -46,7 +47,9 @@ FLAGS = flags.FLAGS
 
 if __name__ == '__main__':
     utils.default_flagfile()
-    twistd.serve(__file__)
-
-if __name__ == '__builtin__':
-    application = handler.get_application()  # pylint: disable-msg=C0103
+    FLAGS(sys.argv)
+    logging.setup()
+    router = s3server.S3Application(FLAGS.buckets_path)
+    server = wsgi.Server()
+    server.start(router, FLAGS.s3_port, host=FLAGS.s3_host)
+    server.wait()
diff --git a/bin/nova-vncproxy b/bin/nova-vncproxy
new file mode 100755
index 000000000..ccb97e3a3
--- /dev/null
+++ b/bin/nova-vncproxy
@@ -0,0 +1,101 @@
+#!/usr/bin/env python
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright (c) 2010 Openstack, LLC.
+# 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.
+
+"""VNC Console Proxy Server."""
+
+import eventlet
+import gettext
+import os
+import sys
+
+possible_topdir = os.path.normpath(os.path.join(os.path.abspath(sys.argv[0]),
+                                   os.pardir,
+                                   os.pardir))
+if os.path.exists(os.path.join(possible_topdir, 'nova', '__init__.py')):
+    sys.path.insert(0, possible_topdir)
+
+gettext.install('nova', unicode=1)
+
+from nova import flags
+from nova import log as logging
+from nova import service
+from nova import utils
+from nova import wsgi
+from nova import version
+from nova.vnc import auth
+from nova.vnc import proxy
+
+
+LOG = logging.getLogger('nova.vnc-proxy')
+
+
+FLAGS = flags.FLAGS
+flags.DEFINE_string('vncproxy_wwwroot', '/var/lib/nova/noVNC/',
+                     'Full path to noVNC directory')
+flags.DEFINE_boolean('vnc_debug', False,
+                     'Enable debugging features, like token bypassing')
+flags.DEFINE_integer('vncproxy_port', 6080,
+                     'Port that the VNC proxy should bind to')
+flags.DEFINE_string('vncproxy_host', '0.0.0.0',
+                     'Address that the VNC proxy should bind to')
+flags.DEFINE_integer('vnc_token_ttl', 300,
+                     'How many seconds before deleting tokens')
+flags.DEFINE_string('vncproxy_manager', 'nova.vnc.auth.VNCProxyAuthManager',
+                    'Manager for vncproxy auth')
+
+flags.DEFINE_flag(flags.HelpFlag())
+flags.DEFINE_flag(flags.HelpshortFlag())
+flags.DEFINE_flag(flags.HelpXMLFlag())
+
+
+if __name__ == "__main__":
+    utils.default_flagfile()
+    FLAGS(sys.argv)
+    logging.setup()
+
+    LOG.audit(_("Starting nova-vnc-proxy node (version %s)"),
+              version.version_string_with_vcs())
+
+    if not (os.path.exists(FLAGS.vncproxy_wwwroot) and
+            os.path.exists(FLAGS.vncproxy_wwwroot + '/vnc_auto.html')):
+        LOG.info(_("Missing vncproxy_wwwroot (version %s)"),
+                    FLAGS.vncproxy_wwwroot)
+        LOG.info(_("You need a slightly modified version of noVNC "
+                   "to work with the nova-vnc-proxy"))
+        LOG.info(_("Check out the most recent nova noVNC code: %s"),
+                   "git://github.com/sleepsonthefloor/noVNC.git")
+        LOG.info(_("And drop it in %s"), FLAGS.vncproxy_wwwroot)
+        exit(1)
+
+    app = proxy.WebsocketVNCProxy(FLAGS.vncproxy_wwwroot)
+
+    LOG.audit(_("Allowing access to the following files: %s"),
+              app.get_whitelist())
+
+    with_logging = auth.LoggingMiddleware(app)
+
+    if FLAGS.vnc_debug:
+        with_auth = proxy.DebugMiddleware(with_logging)
+    else:
+        with_auth = auth.VNCNovaAuthMiddleware(with_logging)
+
+    service.serve()
+
+    server = wsgi.Server()
+    server.start(with_auth, FLAGS.vncproxy_port, host=FLAGS.vncproxy_host)
+    server.wait()
diff --git a/bin/stack b/bin/stack
index 25caca06f..d84a82e27 100755
--- a/bin/stack
+++ b/bin/stack
@@ -59,11 +59,21 @@ USAGE = """usage: stack [options] <controller> <method> [arg1=value arg2=value]
 
 def format_help(d):
     """Format help text, keys are labels and values are descriptions."""
+    MAX_INDENT = 30
     indent = max([len(k) for k in d])
+    if indent > MAX_INDENT:
+        indent = MAX_INDENT - 6
+
     out = []
     for k, v in d.iteritems():
-        t = textwrap.TextWrapper(initial_indent='   %s   ' % k.ljust(indent),
-                                 subsequent_indent=' ' * (indent + 6))
+        if (len(k) + 6) > MAX_INDENT:
+            out.extend(['   %s' % k])
+            initial_indent = ' ' * (indent + 6)
+        else:
+            initial_indent = '   %s   ' % k.ljust(indent)
+        subsequent_indent = ' ' * (indent + 6)
+        t = textwrap.TextWrapper(initial_indent=initial_indent,
+                                 subsequent_indent=subsequent_indent)
         out.extend(t.wrap(v))
     return out