Merge prop fixes and pylint/pep8 cleanup

5 files changed, 91 insertions, 70 deletions

diff --git a/nova/api/rackspace/__init__.py b/nova/api/rackspace/__init__.py
index a10a9c6df..98802663f 100644
--- a/nova/api/rackspace/__init__.py
+++ b/nova/api/rackspace/__init__.py
@@ -31,11 +31,11 @@ import webob
 from nova import flags
 from nova import utils
 from nova import wsgi
+from nova.api.rackspace import backup_schedules
 from nova.api.rackspace import flavors
 from nova.api.rackspace import images
 from nova.api.rackspace import ratelimiting
 from nova.api.rackspace import servers
-from nova.api.rackspace import backup_schedules
 from nova.api.rackspace import sharedipgroups
 from nova.auth import manager
 
diff --git a/nova/api/rackspace/auth.py b/nova/api/rackspace/auth.py
index ce5a967eb..8bfb0753e 100644
--- a/nova/api/rackspace/auth.py
+++ b/nova/api/rackspace/auth.py
@@ -1,13 +1,15 @@
 import datetime
+import hashlib
 import json
 import time
+
 import webob.exc
 import webob.dec
-import hashlib
-from nova import flags
+
 from nova import auth
-from nova import manager
 from nova import db
+from nova import flags
+from nova import manager
 from nova import utils
 
 FLAGS = flags.FLAGS
diff --git a/nova/api/rackspace/backup_schedules.py b/nova/api/rackspace/backup_schedules.py
index a18dfb87c..46da778ee 100644
--- a/nova/api/rackspace/backup_schedules.py
+++ b/nova/api/rackspace/backup_schedules.py
@@ -16,10 +16,11 @@
 #    under the License.
 
 import time
-import nova.image.service
+from webob import exc
+
 from nova import wsgi
 from nova.api.rackspace import _id_translator
-from webob import exc
+import nova.image.service
 
 class Controller(wsgi.Controller):
     def __init__(self):
diff --git a/nova/api/rackspace/images.py b/nova/api/rackspace/images.py
index 10e15de3f..11b058dec 100644
--- a/nova/api/rackspace/images.py
+++ b/nova/api/rackspace/images.py
@@ -15,10 +15,11 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
-import nova.image.service
+from webob import exc
+
 from nova import wsgi
 from nova.api.rackspace import _id_translator
-from webob import exc
+import nova.image.service
 
 class Controller(wsgi.Controller):
 
diff --git a/nova/api/rackspace/servers.py b/nova/api/rackspace/servers.py
index dec369ef0..4ab04bde7 100644
--- a/nova/api/rackspace/servers.py
+++ b/nova/api/rackspace/servers.py
@@ -16,23 +16,43 @@
 #    under the License.
 
 import time
-import nova.image.service
-from nova import wsgi
-from nova import db
+
+from webob import exc
+
 from nova import flags
 from nova import rpc
 from nova import utils
-from nova import compute
-from nova import flags
-from nova.compute import power_state
+from nova import wsgi
 from nova.api.rackspace import _id_translator
-from webob import exc
+from nova.compute import power_state
+import nova.image.service
 
 FLAGS = flags.FLAGS
 
-class Controller(wsgi.Controller):
 
-    _power_mapping = { 
+
+def translator_instance():
+    """ Helper method for initializing the image id translator """
+    service = nova.image.service.ImageService.load()
+    return _id_translator.RackspaceAPIIdTranslator(
+            "image", service.__class__.__name__)
+
+def _filter_params(inst_dict):
+    """ Extracts all updatable parameters for a server update request """
+    keys = ['name', 'adminPass']
+    new_attrs = {}
+    for k in keys:
+        if inst_dict.has_key(k):
+            new_attrs[k] = inst_dict[k]
+    return new_attrs
+
+def _entity_list(entities):
+    """ Coerces a list of servers into proper dictionary format """
+    return dict(servers=entities)
+
+def _entity_detail(inst):
+    """ Maps everything to Rackspace-like attributes for return"""
+    power_mapping = { 
         power_state.NOSTATE:  'build', 
         power_state.RUNNING:  'active',
         power_state.BLOCKED:  'active',
@@ -41,6 +61,28 @@ class Controller(wsgi.Controller):
         power_state.SHUTOFF:  'active',
         power_state.CRASHED:  'error'
     }
+    inst_dict = {}
+
+    mapped_keys = dict(status='state', imageId='image_id', 
+        flavorId='instance_type', name='server_name', id='id')
+
+    for k, v in mapped_keys.iteritems():
+        inst_dict[k] = inst[v]
+
+    inst_dict['status'] = power_mapping[inst_dict['status']]
+    inst_dict['addresses'] = dict(public=[], private=[])
+    inst_dict['metadata'] = {}
+    inst_dict['hostId'] = ''
+
+    return dict(server=inst_dict)
+
+def _entity_inst(inst):
+    """ Filters all model attributes save for id and name """
+    return dict(server=dict(id=inst['id'], name=inst['server_name']))
+
+class Controller(wsgi.Controller):
+    """ The Server API controller for the Openstack API """
+    
 
     _serialization_metadata = {
         'application/xml': {
@@ -54,37 +96,43 @@ class Controller(wsgi.Controller):
     def __init__(self, db_driver=None):
         if not db_driver:
             db_driver = FLAGS.db_driver
-        self.db = utils.import_object(db_driver)
+        self.db_driver = utils.import_object(db_driver)
+        super(Controller, self).__init__()
 
     def index(self, req):
+        """ Returns a list of server names and ids for a given user """
         user_id = req.environ['nova.context']['user']['id']
-        instance_list = self.db.instance_get_all_by_user(None, user_id)
-        res = [self._entity_inst(inst)['server'] for inst in instance_list]
-        return self._entity_list(res)
+        instance_list = self.db_driver.instance_get_all_by_user(None, user_id)
+        res = [_entity_inst(inst)['server'] for inst in instance_list]
+        return _entity_list(res)
 
     def detail(self, req):
+        """ Returns a list of server details for a given user """
         user_id = req.environ['nova.context']['user']['id']
-        res = [self._entity_detail(inst)['server'] for inst in 
-                self.db.instance_get_all_by_user(None, user_id)]
-        return self._entity_list(res)
+        res = [_entity_detail(inst)['server'] for inst in 
+                self.db_driver.instance_get_all_by_user(None, user_id)]
+        return _entity_list(res)
 
     def show(self, req, id):
+        """ Returns server details by server id """
         user_id = req.environ['nova.context']['user']['id']
-        inst = self.db.instance_get(None, id)
+        inst = self.db_driver.instance_get(None, id)
         if inst:
             if inst.user_id == user_id:
-                return self._entity_detail(inst)
+                return _entity_detail(inst)
         raise exc.HTTPNotFound()
 
     def delete(self, req, id):
+        """ Destroys a server """
         user_id = req.environ['nova.context']['user']['id']
-        instance = self.db.instance_get(None, id)
+        instance = self.db_driver.instance_get(None, id)
         if instance and instance['user_id'] == user_id:
-            self.db.instance_destroy(None, id)
+            self.db_driver.instance_destroy(None, id)
             return exc.HTTPAccepted()
         return exc.HTTPNotFound()
 
     def create(self, req):
+        """ Creates a new server for a given user """
         if not req.environ.has_key('inst_dict'):
             return exc.HTTPUnprocessableEntity()
 
@@ -93,20 +141,21 @@ class Controller(wsgi.Controller):
         rpc.cast(
             FLAGS.compute_topic, {
                 "method": "run_instance",
-                "args": {"instance_id": inst.id}})
+                "args": {"instance_id": inst['id']}})
         return _entity_inst(inst)
 
     def update(self, req, id):
+        """ Updates the server name or password """
         if not req.environ.has_key('inst_dict'):
             return exc.HTTPUnprocessableEntity()
 
-        instance = self.db.instance_get(None, id)
+        instance = self.db_driver.instance_get(None, id)
         if not instance:
             return exc.HTTPNotFound()
 
         attrs = req.environ['nova.context'].get('model_attributes', None)
         if attrs:
-            self.db.instance_update(None, id, self._filter_params(attrs))
+            self.db_driver.instance_update(None, id, _filter_params(attrs))
         return exc.HTTPNoContent()
 
     def action(self, req, id):
@@ -115,11 +164,6 @@ class Controller(wsgi.Controller):
         if not req.environ.has_key('inst_dict'):
             return exc.HTTPUnprocessableEntity()
 
-    def translator_instance(self):
-        service = nova.image.service.ImageService.load()
-        return _id_translator.RackspaceAPIIdTranslator(
-                "image", service.__class__.__name__)
-
     def _build_server_instance(self, req):
         """Build instance data structure and save it to the data store."""
         ltime = time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime())
@@ -128,9 +172,9 @@ class Controller(wsgi.Controller):
         env = req.environ['inst_dict']
 
         image_id = env['server']['imageId']
-        opaque_id = self.translator_instance().from_rs_id(image_id)
+        opaque_id = translator_instance().from_rs_id(image_id)
 
-        inst['name'] = env['server']['name']
+        inst['name'] = env['server']['server_name']
         inst['image_id'] = opaque_id
         inst['instance_type'] = env['server']['flavorId']
 
@@ -148,43 +192,16 @@ class Controller(wsgi.Controller):
                     inst['user_id'],
                     inst['project_id'],
                     mac=inst['mac_address'])
+
         inst['private_dns_name'] = str(address)
         inst['bridge_name'] = network.BridgedNetwork.get_network_for_project(
                                 inst['user_id'],
                                 inst['project_id'],
                                 'default')['bridge_name']
 
-        self.db.instance_create(None, inst)
+        ref = self.db_driver.instance_create(None, inst)
+        inst['id'] = ref.id
+        
         return inst
 
-    def _filter_params(self, inst_dict):
-        keys = ['name', 'adminPass']
-        new_attrs = {}
-        for k in keys:
-            if inst_dict.has_key(k):
-                new_attrs[k] = inst_dict[k]
-        return new_attrs
-
-    def _entity_list(self, entities):
-        return dict(servers=entities)
-
-    def _entity_detail(self, inst):
-        """ Maps everything to Rackspace-like attributes for return"""
-        inst_dict = {}
-
-        mapped_keys = dict(status='state', imageId='image_id', 
-            flavorId='instance_type', name='name', id='id')
-
-        for k,v in mapped_keys.iteritems():
-            inst_dict[k] = inst[v]
-
-        inst_dict['status'] = Controller._power_mapping[inst_dict['status']]
-        inst_dict['addresses'] = dict(public=[], private=[])
-        inst_dict['metadata'] = {}
-        inst_dict['hostId'] = ''
-
-        return dict(server=inst_dict)
-
-    def _entity_inst(self, inst):
-        """ Filters all model attributes save for id and name """
-        return dict(server=dict(id=inst['id'], name=inst['name']))
+