bitkeeper revision 1.1159.155.7 (41896362-2P6ibesMBXM0pV5gks0Bw)

Apply changes from Mike Wray:
- Get domain creation errors returned to the caller.
- Add logging for domain create failures.

tools/python/xen/xend/server/SrvBase.py

@@ -8,17 +8,18 @@ import types
 import StringIO
 
 from twisted.internet import defer
-#defer.Deferred.debug = 1
 from twisted.internet import reactor
 from twisted.protocols import http
 from twisted.web import error
 from twisted.web import resource
 from twisted.web import server
+from twisted.python.failure import Failure
 
 from xen.xend import sxp
 from xen.xend import PrettyPrint
 from xen.xend.Args import ArgError
 from xen.xend.XendError import XendError
+from xen.xend.XendLogging import log
 
 def uri_pathlist(p):
     """Split a path into a list.
@@ -105,17 +106,17 @@ class SrvBase(resource.Resource):
         try:
             val = op_method(op, req)
         except Exception, err:
-            return self._perform_err(err, req)
+            return self._perform_err(err, op, req)
             
         if isinstance(val, defer.Deferred):
-            val.addCallback(self._perform_cb, req, dfr=1)
-            val.addErrback(self._perform_err, req, dfr=1)
+            val.addCallback(self._perform_cb, op, req, dfr=1)
+            val.addErrback(self._perform_err, op, req, dfr=1)
             return server.NOT_DONE_YET
         else:
-            self._perform_cb(val, req, 0)
+            self._perform_cb(val, op, req, dfr=0)
             return ''
 
-    def _perform_cb(self, val, req, dfr):
+    def _perform_cb(self, val, op, req, dfr=0):
         """Callback to complete the request.
         May be called from a Deferred.
 
@@ -141,7 +142,7 @@ class SrvBase(resource.Resource):
         if dfr:
             req.finish()
 
-    def _perform_err(self, err, req, dfr=0):
+    def _perform_err(self, err, op, req, dfr=0):
         """Error callback to complete a request.
         May be called from a Deferred.
 
@@ -149,13 +150,16 @@ class SrvBase(resource.Resource):
         @param req: request causing the error
         @param dfr: deferred flag
         """
-        if not (isinstance(err, ArgError) or
-                isinstance(err, sxp.ParseError) or
-                isinstance(err, XendError)):
+        if isinstance(err, Failure):
+            err = err.getErrorMessage()
+        elif not (isinstance(err, ArgError) or
+                  isinstance(err, sxp.ParseError) or
+                  isinstance(err, XendError)):
             if dfr:
                 return err
             else:
                 raise
+        log.exception("op=%s: %s", op, str(err))
         if self.use_sxp(req):
             req.setHeader("Content-Type", sxp.mime_type)
             sxp.show(['xend.err', str(err)], out=req)

tools/python/xen/xend/server/SrvDomainDir.py

@@ -11,6 +11,7 @@ from xen.xend import sxp
 from xen.xend import XendDomain
 from xen.xend.Args import FormFn
 from xen.xend.XendError import XendError
+from xen.xend.XendLogging import log
 
 from SrvDir import SrvDir
 from SrvDomain import SrvDomain
@@ -59,18 +60,15 @@ class SrvDomainDir(SrvDir):
         except sxp.ParseError, ex:
             errmsg = 'Invalid configuration ' + str(ex)
         if not ok:
-            req.setResponseCode(http.BAD_REQUEST, errmsg)
-            return errmsg
+            raise XendError(errmsg)
         try:
             deferred = self.xd.domain_create(config)
             deferred.addCallback(self._op_create_cb, configstring, req)
-            deferred.addErrback(self._op_create_err, req)
             return deferred
         except Exception, ex:
             print 'op_create> Exception creating domain:'
             traceback.print_exc()
-            req.setResponseCode(http.BAD_REQUEST, "Error creating domain: " + str(ex))
-            return str(ex)
+            raise XendError("Error creating domain: " + str(ex))
 
     def _op_create_cb(self, dominfo, configstring, req):
         """Callback to handle deferred domain creation.
@@ -92,27 +90,15 @@ class SrvDomainDir(SrvDir):
             out.close()
             return val
 
-    def _op_create_err(self, err, req):
-        """Callback to handle errors in deferred domain creation.
-        """
-        if isinstance(err, Failure):
-            err = err.getErrorMessage()
-        print 'op_create> Deferred Exception creating domain:', err
-        traceback.print_exc()
-        req.setResponseCode(http.BAD_REQUEST, "Error creating domain: " + str(err))
-        return str(err)
-
     def op_restore(self, op, req):
         """Restore a domain from file.
 
         @return: deferred
         """
-        #todo: return is deferred. May need ok and err callbacks.
         fn = FormFn(self.xd.domain_restore,
                     [['file', 'str']])
         deferred = fn(req.args)
         deferred.addCallback(self._op_restore_cb, req)
-        #deferred.addErrback(self._op_restore_err, req)
         return deferred
 
     def _op_restore_cb(self, dominfo, req):
@@ -130,13 +116,6 @@ class SrvDomainDir(SrvDir):
             out.close()
             return val
 
-    def _op_restore_err(self, err, req):
-        if isinstance(err, Failure):
-            err = err.getErrorMessage()
-        print 'op_create> Deferred Exception restoring domain:', err
-        req.setResponseCode(http.BAD_REQUEST, "Error restoring domain: "+ str(err))
-        return str(err)
-        
     def render_POST(self, req):
         return self.perform(req)