All Samples(3697) | Call(3571) | Derive(0) | Import(126)
Log a message with severity 'ERROR' on the root logger.
def error(msg, *args, **kwargs):
"""
Log a message with severity 'ERROR' on the root logger.
"""
if len(root.handlers) == 0:
basicConfig()
root.error(msg, *args, **kwargs)
from vertebra.util import memoize from logging import error,fatal,info,warn # NOTE: The registry has to have a local connection in order to accept # registrations of local identities. class router(list):
warn("failed to start connection %r",c)
started |= bool(thisstart)
except Exception:
error("crash starting connection %r",c,exc_info=True)
self.remove(c)
if not started:
fatal("failed to start any connections!")
warn("failed to stop connection %r",c)
stopped |= bool(thisstop)
except Exception:
error("crash stopping connection %r",c,exc_info=True)
return stopped
@memoize
def find_conn(self,ident):
for conn in self:
try:
if conn.accept_ident(ident):
return conn
except Exception:
error("connection %s crashed routing %s",conn,ident,exc_info=True)
def send(self,msg):
c = conn.find_conn(msg.to)
if c is None:
error("no connection can handle %s to %s, dropping message" % (msg,to,))
return False
src/m/o/motools-HEAD/gnat/examples/trackuri.py motools(Download)
import os
import os.path
import logging
from logging import log, error, warning, info, debug
sys.path.append(os.path.abspath("")+"/../src/gnat/")
src/v/e/vertebra-py-HEAD/lib/vertebra/conn/xmpp/conn.py vertebra-py(Download)
import pyxmpp.all from pyxmpp.interface import implements from pyxmpp.interfaces import IStanzaHandlersProvider,IFeaturesProvider from logging import debug,info,error from time import time,sleep from socket import error as socket_error from os import fdopen,pipe
if time() - tick >= SUCCESS_TIME:
self.resetBackoff()
except (socket_error,pyxmpp.all.FatalStreamError), e:
error("Error in XMPP processing: %s",e,exc_info=True)
# TODO: Should we catch getting booted off to better handle when two
# agents are knocking each other off?
except Exception, e:
error("Unhandled Error In XMPP Processing: %s", e, exc_info=True)
src/v/e/vertebra-py-HEAD/lib/vertebra/conn/base.py vertebra-py(Download)
""" from threading import Thread,currentThread from logging import debug,info,error,warn from time import sleep from socket import error as socket_error from backoff import exponential_backoff
def handle_crash(self,e): # Returns True if crash is handled
error("Unhandled Error In Connection Processing: %s", e, exc_info=True)
is_handled = not self.crash_fatal
return is_handled
def connect(self):
raise NotImplementedError()
def send(self,msg):
try:
m = self.codec.marshall(msg)
except MarshalError:
error("failed to marshall message %s",msg,exc_info=True)
else:
c = self.client
src/p/y/python-ptrace-0.6.2/gdb.py python-ptrace(Download)
from optparse import OptionParser from os import getpid from sys import stdout, stderr, exit from logging import getLogger, info, warning, error from ptrace.version import VERSION, WEBSITE from ptrace.error import PTRACE_ERRORS, writeError from ptrace.binding import HAS_PTRACE_SINGLESTEP
def _continueProcess(self, process, signum=None):
if not signum and process in self.last_signal:
signum = self.last_signal[process]
if signum:
error("Send %s to %s" % (signalName(signum), process))
process.cont(signum)
ip -= 1
breakpoint = self.process.findBreakpoint(ip)
if breakpoint:
error("Stopped at %s" % breakpoint)
breakpoint.desinstall(set_ip=True)
else:
self.processSignal(signal)
def print_(self, command):
try:
value = self.parseInteger(command)
except ValueError, err:
return str(err)
error("Decimal: %s" % value)
error("Hexadecimal: %s" % formatWordHex(value))
for map in self.process.readMappings():
if value not in map:
continue
error("Address is part of mapping: %s" % map)
read_error = None
# Display line
error("%s| %s| %s" % (formatAddress(address), hexa, ascii))
except PtraceError:
if not read_error:
read_error = [address, address + size]
def backtrace(self):
trace = self.process.getBacktrace()
for func in trace:
error(func)
if trace.truncated:
error("--limited to depth %s--" % len(trace))
return None
def procList(self):
for process in self.debugger:
text = str(process)
if self.process == process:
text += " (active)"
error(text)
self.process.setreg(key, value)
except ProcessError, err:
return "Unable to set $%s=%s: %s" % (key, value, err)
error("Set $%s to %s" % (key, value))
return None
def displayInstr(self, prefix):
try:
if HAS_DISASSEMBLER:
instr = self.process.disassembleOne()
error("%s %s: %s" % (
else:
self.process.dumpCode()
except PtraceError, err:
error("Unable to read current instruction: %s" % err)
def attachProcess(self, text):
try:
def newProcess(self, event):
error("New process: %s" % event.process)
# FIXME: This function doesn't work multiple multiple processes
# especially when a parent waits for a child
def syscallTrace(self):
# Trace until syscall enter
text = "%s = %s" % (syscall.format(), syscall.result_text)
if self.show_pid:
text = "Process %s exits %s" % (syscall.process.pid, text)
error(text)
else:
text = syscall.format()
if self.show_pid:
text = "Process %s enters %s" % (syscall.process.pid, text)
error(text)
def switchProcess(self, process):
if self.process == process:
return
error("Switch to %s" % process)
self.process = process
def nextProcess(self):
def displayBreakpoints(self):
found = False
for process in self.debugger:
for bp in process.breakpoints.itervalues():
found = True
error("%s:%s" % (process, bp))
if not found:
error("(no breakpoint)")
def displaySignals(self):
signals = SIGNAMES.items()
signals.sort(key=lambda (key, value): key)
for signum, name in signals:
error("% 2s: %s" % (signum, name))
except PtraceError, err:
return "Unable to set breakpoint at %s: %s" % (
formatAddress(address), err)
error("New breakpoint: %s" % bp)
return None
def delete(self, command):
if not breakpoint:
return "No breakpoint at %s " % formatAddress(address)
breakpoint.desinstall()
error("%s deleted" % breakpoint)
return None
def help(self):
for command, description in COMMANDS:
error("%s: %s" % (command, description))
error('')
error("Value can be an hexadecimal/decimal number or a register name ($reg)")
error("You can use operators a+b, a-b, a*b, a/b, a<<b, a>>b, a**b, and parenthesis in expressions")
error('Use ";" to write multiple commands on the same line (eg. "step; print $eax")')
def processSignal(self, event):
event.display()
self.switchProcess(event.process)
self.last_signal[self.process] = event.signum
error("%s interrupted by %s" % (self.process, event.name))
def processExecution(self, event):
error(event)
self.switchProcess(event.process)
self.interrupt()
def debuggerInfo(self):
error("Debugger process ID: %s" % getpid())
error("python-ptrace version %s" % VERSION)
def debuggerInfo(self):
error("Debugger process ID: %s" % getpid())
error("python-ptrace version %s" % VERSION)
error("Website: %s" % WEBSITE)
def interrupt(self):
waitlist = []
def deleteProcess(self, pid):
try:
process = self.debugger[pid]
except KeyError:
return
event = process.processTerminated()
error(str(event))
if process == self.process:
self.nextProcess()
def restoreTerminal(self):
if enableEchoMode():
error("Terminal: restore echo mode")
print
return True
except KeyboardInterrupt:
error("User interrupt!")
self.interrupt()
return False
except ProcessSignal, event:
self.processSignal(event)
except ProcessExit, event:
error(event)
self.nextProcess()
except ProcessExecution, event:
self.processExecution(event)
except PtraceError, err:
error("ERROR: %s" % err)
def main(self):
self.debugger = PtraceDebugger()
try:
self.runDebugger()
except KeyboardInterrupt:
error("Interrupt debugger: quit!")
except PTRACE_ERRORS, err:
writeError(getLogger(), err, "Debugger error")
self.process = None
self.debugger.quit()
error("Quit gdb.")
src/m/o/motools-HEAD/gnat/src/gnat/AudioCollection.py motools(Download)
from RdfFile import RdfFile from ExternalSources import * from Id3Writer import * from logging import log, error, warning, info, debug from optparse import OptionParser from urllib import quote as urlencode
f_out=open('info_metadata.csv','w')
else:
if not self.rdf.open("info_"+commandName+".rdf"):
error("Existing info_"+commandName+".rdf file found !")
raise Exception("Couldn't create output file !")
try:
for line in f:
self.rdf.write()
self.rdf.clear()
except Exception, e:
error("Malformed CSV !")
raise
else:
error("Filepath given is not a directory ! "+filepath)
elif os.path.exists(filepath) and filepath.find("info_") != -1 and filepath.find(".rdf") != -1:
os.remove(filepath)
else:
error("Filepath given is not a directory or an rdf file ! "+filepath)
def metadata(self, filename, true_md=None, just_URI=False) :
debug("Considering "+filename)
mi.add(af); mi.add(mbz)
self.succeeded+=1
except MbzLookupException, e:
error(" - " + e.message)
except FileTypeException, e:
error(" - " + e.message)
if just_URI:
src/m/o/motools-HEAD/myspace-serv/trunk/src/helpers/create_based_near_rdf.py motools(Download)
from SPARQLWrapper.SPARQLExceptions import QueryBadFormed, EndPointNotFound import sys import logging from logging import debug, error, info from rdflib import ConjunctiveGraph, Namespace, URIRef import cPickle as pickle import os
try:
ret = sparql.query()
except QueryBadFormed, err:
error(err)
sys.exit(1)
except EndPointNotFound, err:
error(err)
try:
graph.add((URIRef(person), FOAF['based_near'], URIRef(COUNTRIES[country])))
except KeyError, err:
error(err)
fname = 'offset-%s.rdf' % str(offset)
fname = os.path.join(WRITE_PATH, fname)
src/m/o/motools-HEAD/gnat/src/gnat/FPTrackLookup.py motools(Download)
import rdflib import xml.dom.minidom import logging from logging import log, error, warning, info, debug from time import asctime import re from urllib import quote as urlencode
# genres.append(genre_node.getElementsByTagName("name")[0].childNodes[0].wholeText)
except Exception, e:
error("Failure while parsing results !")
debug("xml :\n"+"".join(res_xml))
error(str(e))
return MusicInfo()
mbzconvert = MbzURIConverter(mbzuri)
track.URI = mbzconvert.getURI()
if (mbzconvert.getURI().find("track") == -1):
error("Incomprehensible URI for track !")
signal.URI = mbzconvert.getURI().replace("track","signal")
except MbzLookupException, e:
error(" - " + e.message)
except FileTypeException, e:
error(" - " + e.message)
src/p/y/pymclevel-HEAD/mclevel.py pymclevel(Download)
from box import BoundingBox import logging from logging import log, debug, warn, info, error, critical FaceXIncreasing = 0 FaceXDecreasing = 1
data = gzipper.read();
if data == None: return;
except Exception, e:
error( u"Error reading compressed data, assuming uncompressed: {0}".format(e) )
data = self.compressedTag
gzipper.close();
try:
self.root_tag = nbt.load(buf=fromstring(data, dtype='uint8'));
except Exception, e:
error( u"Malformed NBT data in file: {0} ({1})".format(self.filename, e) )
try:
self.shapeChunkData()
except KeyError:
error( u"Incorrect chunk format in file: " + self.filename )
self.world.malformedChunk(*self.chunkPosition);
raise ChunkMalformed, self.filename
try:
root_tag = nbt.load(filename)
except IOError,e:
error( u"Failed to load file {0}".format (e) )
else:
self.filename = None
except IOError,e:
try: os.rename(self.filename + ".old", self.filename)
except: warn( u"Unable to restore old chunk file" )
error( u"Failed to save {0}: {1}".format(self.filename, e) )
try: os.remove(self.filename + ".old")
except Exception,e:
src/m/o/motools-HEAD/gnat/src/gnat/RdfFile.py motools(Download)
import os import mopy from mopy.RDFInterface import exportRDFFile from mopy.MusicInfo import MusicInfo import logging from logging import log, error, warning, info, debug
self.mi = MusicInfo()
return True
except Exception, e:
error("Couldn't open file for writing : "+filename+"\nException info : "+str(e))
return False
def addMusicInfo(self, mi):
1 | 2 | 3 | 4 | 5 | 6 Next