Python log.exception函数代码示例

    def perform(self, req):
        """General operation handler for posted operations.
        For operation 'foo' looks for a method op_foo and calls
        it with op_foo(op, req). Replies with code 500 if op_foo
        is not found.

        The method must return a list when req.use_sxp is true
        and an HTML string otherwise (or list).
        Methods may also return a ThreadRequest (for incomplete processing).

        req request
        """
        op = req.args.get('op')
        if op is None or len(op) != 1:
            req.setResponseCode(http.NOT_ACCEPTABLE, "Invalid request")
            return ''
        op = op[0]
        op_method = self.get_op_method(op)
        if op_method is None:
            req.setResponseCode(http.NOT_IMPLEMENTED, "Operation not implemented: " + op)
            req.setHeader("Content-Type", "text/plain")
            req.write("Operation not implemented: " + op)
            return ''
        else:
            try:
                return op_method(op, req)
            except Exception, exn:
                req.setResponseCode(http.INTERNAL_SERVER_ERROR, "Request failed: " + op)
                log.exception("Request %s failed.", op)
                if req.useSxp():
                    return ['xend.err', str(exn)]
                else:
                    return "<p>%s</p>" % str(exn)

    def set_CPU_Affinity(self, vcpu, cpumap):
        domid = self.xend_domain_instance.getDomid()
        dominfo = self.xend_domain_instance
        if not dominfo:
            raise XendInvalidDomain(str(domid))

        # if vcpu is keyword 'all', apply the cpumap to all vcpus
        if str(vcpu).lower() == "all":
            vcpus = range(0, int(dominfo.getVCpuCount()))
        else:
            vcpus = [int(vcpu)]

        # set the same cpumask for all vcpus
        rc = 0
        cpus = dominfo.getCpus()
        cpumap = map(int, cpumap.split(","))
        for v in vcpus:
            try:
                if dominfo._stateGet() in (DOM_STATE_RUNNING,
                                           DOM_STATE_PAUSED):
                    rc = xc.vcpu_setaffinity(domid, v, cpumap)
                cpus[v] = cpumap
            except Exception, ex:
                log.exception(ex)
                raise XendError("Cannot pin vcpu: %d to cpu: %s - %s" % \
                                (v, cpumap, str(ex)))

def restore(xd, fd, dominfo = None, paused = False, relocating = False):
    try:
        if not os.path.isdir("/var/lib/xen"):
            os.makedirs("/var/lib/xen")
    except Exception, exn:
        log.exception("Can't create directory '/var/lib/xen'")
        raise XendError("Can't create directory '/var/lib/xen'")

    def run(self):
        """Runs the method and stores the result for later access.

        Is invoked by threading.Thread.start().
        """

        self.thread_id = thread.get_ident()
        self.task_progress_lock.acquire()
        try:
            self.task_progress[self.thread_id] = {}
            self.progress = 0         
            self.created = now()   
        finally:
            self.task_progress_lock.release()

        try:
            result = self.func(*self.args)
            if result['Status'] == 'Success':
                self.result = result['Value']
                self.set_status(XEN_API_TASK_STATUS_TYPE[1])
            else:
                self.error_info = result['ErrorDescription']
                self.set_status(XEN_API_TASK_STATUS_TYPE[2])                
        except Exception, e:
            log.exception('Error running Async Task')
            self.error_info = ['INTERNAL ERROR', str(e)]
            self.set_status(XEN_API_TASK_STATUS_TYPE[2])

    def run(self, status):
        try:
            log.info("Xend Daemon started")

            xc = xen.lowlevel.xc.xc()
            xinfo = xc.xeninfo()
            log.info("Xend changeset: %s.", xinfo['xen_changeset'])
            del xc

            try:
                from xen import VERSION
                log.info("Xend version: %s", VERSION)
            except ImportError:
                log.info("Xend version: Unknown.")

            relocate.listenRelocation()
            servers = SrvServer.create()
            servers.start(status)
            del servers
            
        except Exception, ex:
            print >>sys.stderr, 'Exception starting xend:', ex
            if XEND_DEBUG:
                traceback.print_exc()
            log.exception("Exception starting xend (%s)" % ex)
            if status:
                status.write('1')
                status.close()
            sys.exit(1)

 def destroyDeviceModel(self):
     if self.device_model is None:
         return
     if self.pid:
         self.sentinel_lock.acquire()
         try:
             try:
                 os.kill(self.pid, signal.SIGHUP)
             except OSError, exn:
                 log.exception(exn)
             try:
                 # Try to reap the child every 100ms for 10s. Then SIGKILL it.
                 for i in xrange(100):
                     (p, rv) = os.waitpid(self.pid, os.WNOHANG)
                     if p == self.pid:
                         break
                     time.sleep(0.1)
                 else:
                     log.warning("DeviceModel %d took more than 10s "
                                 "to terminate: sending SIGKILL" % self.pid)
                     os.kill(self.pid, signal.SIGKILL)
                     os.waitpid(self.pid, 0)
             except OSError, exn:
                 # This is expected if Xend has been restarted within the
                 # life of this domain.  In this case, we can kill the process,
                 # but we can't wait for it because it's not our child.
                 # We just make really sure it's going away (SIGKILL) first.
                 os.kill(self.pid, signal.SIGKILL)
             state = xstransact.Remove("/local/domain/0/device-model/%i"
                                       % self.vm.getDomid())

 def destroyXenPaging(self):
     if self.actmem == "0":
         return
     if self.xenpaging_pid:
         try:
             os.kill(self.xenpaging_pid, signal.SIGHUP)
         except OSError, exn:
             log.exception(exn)
         for i in xrange(100):
             try:
                 (p, rv) = os.waitpid(self.xenpaging_pid, os.WNOHANG)
                 if p == self.xenpaging_pid:
                     break
             except OSError:
                 # This is expected if Xend has been restarted within
                 # the life of this domain.  In this case, we can kill
                 # the process, but we can't wait for it because it's
                 # not our child. We continue this loop, and after it is
                 # terminated make really sure the process is going away
                 # (SIGKILL).
                 pass
             time.sleep(0.1)
         else:
             log.warning("xenpaging %d took more than 10s "
                         "to terminate: sending SIGKILL" % self.xenpaging_pid)
             try:
                 os.kill(self.xenpaging_pid, signal.SIGKILL)
                 os.waitpid(self.xenpaging_pid, 0)
             except OSError:
                 # This happens if the process doesn't exist.
                 pass

    def prepareEnvironment(self):
        """Prepare the environment for the execution of the domain. This
        method is called before any devices are set up."""

        domid = self.vm.getDomid()

        # Delete left-over pipes
        try:
            os.unlink("/var/run/tap/qemu-read-%d" % domid)
            os.unlink("/var/run/tap/qemu-write-%d" % domid)
        except:
            pass

        # No device model, don't create pipes
        if self.device_model is None:
            return

        if platform.system() != "SunOS":
            # If we use a device model, the pipes for communication between
            # blktapctrl and ioemu must be present before the devices are
            # created (blktapctrl must access them for new block devices)

            try:
                os.makedirs("/var/run/tap", 0755)
            except:
                pass

            try:
                os.mkfifo("/var/run/tap/qemu-read-%d" % domid, 0600)
                os.mkfifo("/var/run/tap/qemu-write-%d" % domid, 0600)
            except OSError, e:
                log.warn("Could not create blktap pipes for domain %d" % domid)
                log.exception(e)
                pass

def save(fd, dominfo, network, live, dst, checkpoint=False, node=-1):
    try:
        if not os.path.isdir("/var/lib/xen"):
            os.makedirs("/var/lib/xen")
    except Exception, exn:
        log.exception("Can't create directory '/var/lib/xen'")
        raise XendError("Can't create directory '/var/lib/xen'")

def _loadConfig(servers, root, reload):
    if xoptions.get_xend_http_server():
        servers.add(HttpServer(root,
                               xoptions.get_xend_address(),
                               xoptions.get_xend_port()))
    if  xoptions.get_xend_unix_server():
        path = xoptions.get_xend_unix_path()
        log.info('unix path=' + path)
        servers.add(UnixHttpServer(root, path))

    api_cfg = xoptions.get_xen_api_server()
    if api_cfg:
        try:
            for server_cfg in api_cfg:
                # Parse the xen-api-server config
                
                ssl_key_file = None
                ssl_cert_file = None
                auth_method = XendAPI.AUTH_NONE
                hosts_allowed = None
                
                host_addr = server_cfg[0].split(':', 1)
                if len(host_addr) == 1:
                    if host_addr[0].lower() == 'unix':
                        use_tcp = False
                        host = 'localhost'
                        port = 0
                    else:
                        use_tcp = True
                        host = ''
                        port = int(host_addr[0])
                else:
                    use_tcp = True
                    host = str(host_addr[0])
                    port = int(host_addr[1])

                if len(server_cfg) > 1:
                    if server_cfg[1] in [XendAPI.AUTH_PAM, XendAPI.AUTH_NONE]:
                        auth_method = server_cfg[1]

                if len(server_cfg) > 2 and len(server_cfg[2]):
                    hosts_allowed = map(re.compile, server_cfg[2].split(' '))

                if len(server_cfg) > 4:
                    # SSL key and cert file
                    ssl_key_file = server_cfg[3]
                    ssl_cert_file = server_cfg[4]


                servers.add(XMLRPCServer(auth_method, True, use_tcp = use_tcp,
                                         ssl_key_file = ssl_key_file,
                                         ssl_cert_file = ssl_cert_file,
                                         host = host, port = port,
                                         path = XEN_API_SOCKET,
                                         hosts_allowed = hosts_allowed))

        except (ValueError, TypeError), exn:
            log.exception('Xen API Server init failed')
            log.error('Xen-API server configuration %s is invalid.', api_cfg)

def save(fd, dominfo, network, live, dst, checkpoint=False, node=-1, sock=None, name=None, diskonly=False):
    from xen.xend import XendDomain

    try:
        if not os.path.isdir("/var/lib/xen"):
            os.makedirs("/var/lib/xen")
    except Exception, exn:
        log.exception("Can't create directory '/var/lib/xen'")
        raise XendError("Can't create directory '/var/lib/xen'")

def watchMain():
    while True:
        try:
            we = xs.read_watch()
            watch = we[1]
            res = watch.fn(we[0], *watch.args, **watch.kwargs)
            if not res:
                watch.unwatch()
        except:
            log.exception("read_watch failed")

 def unwatchAerState(self):
     """Remove the watch on the domain's aerState node, if any."""
     try:
         try:
             if self.aerStateWatch:
                 self.aerStateWatch.unwatch()
         finally:
             self.aerStateWatch = None
     except:
         log.exception("Unwatching aerState failed.")

    def unregister_shutdown_watch(self):
        """Remove the watch on the control/shutdown, if any. Nothrow
        guarantee."""

        try:
            if self.shutdownWatch:
                self.shutdownWatch.unwatch()
        except:
            log.exception("Unwatching hvm shutdown watch failed.")
        self.shutdownWatch = None
        log.debug("hvm shutdown watch unregistered")

    def domain_restore_fd(self, fd):
        """Restore a domain from the given file descriptor."""

        try:
            return XendCheckpoint.restore(self, fd)
        except:
            # I don't really want to log this exception here, but the error
            # handling in the relocation-socket handling code (relocate.py) is
            # poor, so we need to log this for debugging.
            log.exception("Restore failed")
            raise