Python Logger.error方法代码示例

# 需要导入模块: from xpra.log import Logger [as 别名]
# 或者: from xpra.log.Logger import error [as 别名]
class console_event_catcher(object):
    def __init__(self, event_cb, events=CONSOLE_EXIT_EVENTS):
        self.event_cb = event_cb
        self.events = events
        self.result = 0
        from xpra.log import Logger

        self.log = Logger("win32")

    def __enter__(self):
        try:
            self.result = win32api.SetConsoleCtrlHandler(self.handle_console_event, 1)
            if self.result == 0:
                self.log.error("could not SetConsoleCtrlHandler (error %r)", win32api.GetLastError())
        except Exception as e:
            self.log.error("SetConsoleCtrlHandler error: %s", e)

    def __exit__(self, exc_type, exc_val, exc_tb):
        try:
            win32api.SetConsoleCtrlHandler(None, 0)
        except:
            pass

    def __repr__(self):
        return "console_event_catcher(%s, %s)" % (self.event_cb, self.events)

    def handle_console_event(self, event):
        self.log("handle_console_event(%s)", event)
        if event in self.events:
            self.log.info("received console event %s", event)
            self.event_cb(event)

# 需要导入模块: from xpra.log import Logger [as 别名]
# 或者: from xpra.log.Logger import error [as 别名]
def get_sys_info():
    info = {}
    try:
        import resource
        for k, constant in {"server"   : "RUSAGE_SELF",
                         "children" : "RUSAGE_CHILDREN",
                         "total"    : "RUSAGE_BOTH"}.items():
            try:
                v = getattr(resource, constant)
            except (NameError, AttributeError):
                continue
            stats = resource.getrusage(v)
            prefix = "memory.%s." % k
            for var in ("utime", "stime", "maxrss",
                        "ixrss", "idrss", "isrss",
                        "minflt", "majflt", "nswap",
                        "inblock", "oublock",
                        "msgsnd", "msgrcv",
                        "nsignals", "nvcsw", "nivcsw"):
                value = getattr(stats, "ru_%s" % var)
                if type(value)==float:
                    value = int(value)
                info[prefix+var] = value
    except:
        from xpra.log import Logger
        log = Logger()
        log.error("error getting memory usage info", exc_info=True)
    return info

# 需要导入模块: from xpra.log import Logger [as 别名]
# 或者: from xpra.log.Logger import error [as 别名]
    def err(*msg):
        """ log an error message and return None """
        from xpra.log import Logger

        log = Logger("icon")
        log.error(*msg)
        return None

# 需要导入模块: from xpra.log import Logger [as 别名]
# 或者: from xpra.log.Logger import error [as 别名]
def verify_display_ready(xvfb, display_name, shadowing):
    from xpra.log import Logger
    log = Logger("server")
    from xpra.x11.bindings.wait_for_x_server import wait_for_x_server        #@UnresolvedImport
    # Whether we spawned our server or not, it is now running -- or at least
    # starting.  First wait for it to start up:
    try:
        wait_for_x_server(display_name, 3) # 3s timeout
    except Exception as e:
        sys.stderr.write("%s\n" % e)
        return  None
    # Now we can safely load gtk and connect:
    assert "gtk" not in sys.modules
    import gtk.gdk          #@Reimport
    try:
        import glib
        glib.threads_init()
    except:
        #old versions do not have this method
        pass
    display = gtk.gdk.Display(display_name)
    manager = gtk.gdk.display_manager_get()
    default_display = manager.get_default_display()
    if default_display is not None:
        default_display.close()
    manager.set_default_display(display)
    if not shadowing and not check_xvfb_process(xvfb):
        #if we're here, there is an X11 server, but it isn't the one we started!
        log.error("There is an X11 server already running on display %s:" % display_name)
        log.error("You may want to use:")
        log.error("  'xpra upgrade %s' if an instance of xpra is still connected to it" % display_name)
        log.error("  'xpra --use-display start %s' to connect xpra to an existing X11 server only" % display_name)
        log.error("")
        return  None
    return display

# 需要导入模块: from xpra.log import Logger [as 别名]
# 或者: from xpra.log.Logger import error [as 别名]
def do_get_resources_dir():
    rsc = None
    RESOURCES = "/Resources/"
    #FUGLY warning: importing gtkosx_application causes the dock to appear,
    #and in some cases we don't want that.. so use the env var XPRA_SKIP_UI as workaround for such cases:
    if os.environ.get("XPRA_SKIP_UI", "0")=="0":
        try:
            import gtkosx_application        #@UnresolvedImport
            try:
                rsc = gtkosx_application.gtkosx_application_get_resource_path()
                debug("get_resources_dir() gtkosx_application_get_resource_path=%s", rsc)
            except:
                #maybe we're not running from an app bundle?
                pass
        except:
            #delayed import to prevent cycles:
            from xpra.log import Logger
            log = Logger("util")
            log.error("ERROR: gtkosx_application module is missing - trying to continue anyway")
    else:
        debug("XPRA_SKIP_UI is set, not importing gtkosx_application")
    if rsc is None:
        #try using the path to this file to find the resource path:
        rsc = __file__
    i = rsc.rfind(RESOURCES)
    if i<=0:
        #last fallback: try the default app dir
        from xpra.platform.paths import default_get_app_dir
        rsc = default_get_app_dir()
        debug("get_resources_dir() default_get_app_dir()=%s", rsc)
    i = rsc.rfind(RESOURCES)
    if i>0:
        rsc = rsc[:i+len(RESOURCES)]
    debug("get_resources_dir()=%s", rsc)
    return rsc

# 需要导入模块: from xpra.log import Logger [as 别名]
# 或者: from xpra.log.Logger import error [as 别名]
def get_sys_info():
    try:
        from xpra.platform.xposix.info import get_sys_info as xposix_get_sys_info
        return xposix_get_sys_info()
    except:
        from xpra.log import Logger
        log = Logger("osx")
        log.error("error getting memory usage info", exc_info=True)
    return  {}

# 需要导入模块: from xpra.log import Logger [as 别名]
# 或者: from xpra.log.Logger import error [as 别名]
def setbinarymode(fd):
    if WIN32:
        #turn on binary mode:
        try:
            import msvcrt
            msvcrt.setmode(fd, os.O_BINARY)         #@UndefinedVariable
        except:
            from xpra.log import Logger
            log = Logger("util")
            log.error("setting stdin to binary mode failed", exc_info=True)

# 需要导入模块: from xpra.log import Logger [as 别名]
# 或者: from xpra.log.Logger import error [as 别名]
def mdns_publish(display_name, mode, listen_on, text_dict={}):
    try:
        from xpra.net.avahi_publisher import AvahiPublishers
    except Exception, e:
        global MDNS_WARNING
        if not MDNS_WARNING:
            MDNS_WARNING = True
            from xpra.log import Logger
            log = Logger("mdns")
            log.error("failed to load the mdns avahi publisher: %s", e)
            log.error("either fix your installation or use the '--no-mdns' flag")
        return

# 需要导入模块: from xpra.log import Logger [as 别名]
# 或者: from xpra.log.Logger import error [as 别名]
def check_xvfb_process(xvfb=None):
    if xvfb is None:
        #we don't have a process to check
        return True
    if xvfb.poll() is None:
        #process is running
        return True
    from xpra.log import Logger
    log = Logger("server")
    log.error("")
    log.error("Xvfb command has terminated! xpra cannot continue")
    log.error(" if the display is already running, try a different one,")
    log.error(" or use the --use-display flag")
    log.error("")
    return False

# 需要导入模块: from xpra.log import Logger [as 别名]
# 或者: from xpra.log.Logger import error [as 别名]
def mdns_publish(display_name, mode, listen_on, text_dict={}):
    try:
        from xpra.net.avahi_publisher import AvahiPublishers
    except Exception as e:
        global MDNS_WARNING
        if not MDNS_WARNING:
            MDNS_WARNING = True
            from xpra.log import Logger
            log = Logger("mdns")
            log.error("failed to load the mdns avahi publisher: %s", e)
            log.error("either fix your installation or use the '--no-mdns' flag")
        return
    d = text_dict.copy()
    d["mode"] = mode
    ap = AvahiPublishers(listen_on, "Xpra %s %s" % (mode, display_name), text_dict=d)
    _when_ready.append(ap.start)
    _cleanups.append(ap.stop)

# 需要导入模块: from xpra.log import Logger [as 别名]
# 或者: from xpra.log.Logger import error [as 别名]
 def abort_test(action):
     """ if ssh dies, we don't need to try to read/write from its sockets """
     e = child.poll()
     if e is not None:
         error_message = "cannot %s using %s: the SSH process has terminated with exit code=%s" % (action, display_desc["full_ssh"], e)
         if debug_cb:
             debug_cb(error_message)
         if ssh_fail_cb:
             ssh_fail_cb(error_message)
         if "ssh_abort" not in display_desc:
             display_desc["ssh_abort"] = True
             from xpra.log import Logger
             log = Logger()
             log.error("The SSH process has terminated with exit code %s", e)
             if conn.input_bytecount==0 and conn.output_bytecount==0:
                 log.error("Connection to the xpra server via SSH failed for: %s", display_name)
                 log.error(" the command line used was: %s", cmd)
                 log.error(" check your username, hostname, display number, etc")
         raise ConnectionClosedException(error_message)

# 需要导入模块: from xpra.log import Logger [as 别名]
# 或者: from xpra.log.Logger import error [as 别名]
def check_xvfb_process(xvfb=None):
    if xvfb is None:
        #we don't have a process to check
        return True
    if xvfb.poll() is None:
        #process is running
        return True
    from xpra.log import Logger
    log = Logger("server")
    log.error("")
    log.error("Xvfb command has terminated! xpra cannot continue")
    log.error("")
    return False

# 需要导入模块: from xpra.log import Logger [as 别名]
# 或者: from xpra.log.Logger import error [as 别名]
            log("io_thread_loop(%s, %s) loop starting", name, callback)
            while not self._closed:
                callback()
            log("io_thread_loop(%s, %s) loop ended, closed=%s", name, callback, self._closed)
        except KeyboardInterrupt, e:
            raise e
        except ConnectionClosedException, e:
            if not self._closed:
                #log it at debug level
                #(rely on location where we raise to provide better logging)
                log("%s connection closed for %s", name, self._conn)
                self._call_connection_lost("%s connection closed: %s" % (name, e))
        except (OSError, IOError, socket_error), e:
            if not self._closed:
                if e.args[0] in ABORT:
                    log.error("%s connection reset or aborted for %s", name, self._conn)
                    self._call_connection_lost("%s connection reset: %s" % (name, e))
                else:
                    log.error("%s error for %s", name, self._conn, exc_info=True)
                    self._call_connection_lost("%s error on connection: %s" % (name, e))
        except Exception, e:
            #can happen during close(), in which case we just ignore:
            if not self._closed:
                log.error("%s error on %s", name, self._conn, exc_info=True)
                self.close()

    def _write_thread_loop(self):
        self._io_thread_loop("write", self._write)
    def _write(self):
        items = self._write_queue.get()
        # Used to signal that we should exit:

# 需要导入模块: from xpra.log import Logger [as 别名]
# 或者: from xpra.log.Logger import error [as 别名]
log = Logger("sound", "gstreamer")


#used on the server (reversed):
XPRA_PULSE_SOURCE_DEVICE_NAME = "Speaker"
XPRA_PULSE_SINK_DEVICE_NAME = "Microphone"

GST_QUEUE_NO_LEAK             = 0
GST_QUEUE_LEAK_UPSTREAM       = 1
GST_QUEUE_LEAK_DOWNSTREAM     = 2
GST_QUEUE_LEAK_DEFAULT = GST_QUEUE_LEAK_DOWNSTREAM
MS_TO_NS = 1000000

QUEUE_LEAK = int(os.environ.get("XPRA_SOUND_QUEUE_LEAK", GST_QUEUE_LEAK_DEFAULT))
if QUEUE_LEAK not in (GST_QUEUE_NO_LEAK, GST_QUEUE_LEAK_UPSTREAM, GST_QUEUE_LEAK_DOWNSTREAM):
    log.error("invalid leak option %s", QUEUE_LEAK)
    QUEUE_LEAK = GST_QUEUE_LEAK_DEFAULT

def get_queue_time(default_value=450, prefix=""):
    queue_time = int(os.environ.get("XPRA_SOUND_QUEUE_%sTIME" % prefix, default_value))*MS_TO_NS
    queue_time = max(0, queue_time)
    return queue_time


WIN32 = sys.platform.startswith("win")
OSX = sys.platform.startswith("darwin")

ALLOW_SOUND_LOOP = os.environ.get("XPRA_ALLOW_SOUND_LOOP", "0")=="1"
GSTREAMER1 = os.environ.get("XPRA_GSTREAMER1", "1")=="1"
PULSEAUDIO_DEVICE_NAME = os.environ.get("XPRA_PULSEAUDIO_DEVICE_NAME", "")
USE_DEFAULT_DEVICE = os.environ.get("XPRA_USE_DEFAULT_DEVICE", "1")=="1"

# 需要导入模块: from xpra.log import Logger [as 别名]
# 或者: from xpra.log.Logger import error [as 别名]
    DEFAULT_SINK = "osxaudiosink"
elif sys.platform.startswith("win"):
    SINKS.append("directsoundsink")
    DEFAULT_SINK = "directsoundsink"
if os.name == "posix":
    SINKS += ["alsasink", "osssink", "oss4sink", "jackaudiosink"]

# SINK_SHARED_DEFAULT_ATTRIBUTES = {"sync" : False,
#                                  "async" : True}
SINK_SHARED_DEFAULT_ATTRIBUTES = {"sync": False, "async": True, "qos": True}

SINK_DEFAULT_ATTRIBUTES = {0: {"pulsesink": {"client": "Xpra"}}, 1: {"pulsesink": {"client-name": "Xpra"}}}

DEFAULT_SINK = os.environ.get("XPRA_SOUND_SINK", DEFAULT_SINK)
if DEFAULT_SINK not in SINKS:
    log.error("invalid default sound sink: '%s' is not in %s, using %s instead", DEFAULT_SINK, SINKS, SINKS[0])
    DEFAULT_SINK = SINKS[0]
QUEUE_SILENT = 0
QUEUE_TIME = get_queue_time(450)
QUEUE_MIN_TIME = get_queue_time(QUEUE_TIME // 10 // MS_TO_NS, "MIN")
assert QUEUE_MIN_TIME <= QUEUE_TIME

VARIABLE_MIN_QUEUE = os.environ.get("XPRA_VARIABLE_MIN_QUEUE", "1") == "1"


GST_FORMAT_BUFFERS = 4


def sink_has_device_attribute(sink):
    return sink not in ("autoaudiosink", "jackaudiosink", "directsoundsink")