def _checkLogMessage(self, record):
try:
if self._notAgain.checkState() == Qt.Checked:
return
if record.levelno >= logging.ERROR:
recMsg = record.msg
if not isinstance(recMsg, basestring):
recMsg = unicode(recMsg)
err = convert_string(recMsg) % record.args
component = record.name
if component.startswith("lunchinator."):
component = component[12:]
msg = u"%s - In component %s (%s:%d):\n%s" % (strftime("%H:%M:%S", localtime(record.created)),
component,
record.pathname,
record.lineno,
err)
if record.exc_info:
out = StringIO()
traceback.print_tb(record.exc_info[2], file=out)
msg += u"\nStack trace:\n" + out.getvalue() + formatException(record.exc_info) + u"\n"
self._errorLog.append(msg)
self._empty = False
if not self.isVisible():
self.showNormal()
self.raise_()
self.activateWindow()
except:
from lunchinator.log import getCoreLogger
getCoreLogger().info(formatException())
def run(self):
try:
self.performSend()
self.successfullyTransferred.emit(self)
except CanceledException:
self.transferCanceled.emit(self)
except socket.error:
msg = formatException()
self.logger.warning("Error sending: %s", msg)
self.errorOnTransfer.emit(self, msg)
except:
self.logger.exception("Error sending")
self.errorOnTransfer.emit(self, formatException())
def run(self):
nTries = 0
while nTries < self.NUMBER_OF_TRIES:
if nTries > 0:
self.target.seek(0)
QThread.sleep(self.TIMEOUT)
nTries += 1
#try standard first (with proxy if environment variable is set)
try:
if not self._no_proxy:
try:
hdr = {'User-Agent': 'Mozilla/5.0', 'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8'}
req = urllib2.Request(self.url.encode('utf-8'), headers=hdr)
with contextlib.closing(urllib2.urlopen(req)) as u:
self._readData(u)
break
except urllib2.URLError:
#very likely a proxy error
self.logger.debug("Downloading %s failed, forcing without proxy now", self.url)
#try again without proxy
req2 = urllib2.Request(self.url.encode('utf-8'), headers=hdr)
proxy_handler = urllib2.ProxyHandler({})
no_proxy_opener = urllib2.build_opener(proxy_handler)
with contextlib.closing(no_proxy_opener.open(req2)) as n_u:
self._readData(n_u)
# finished
break
except HTTPError as e:
# don't print trace on HTTP error
self.logger.warning("Error while downloading %s (%s)", self.url, e)
if nTries >= self.NUMBER_OF_TRIES or e.code == 404:
self.error.emit(self, formatException())
if e.code == 404:
# no need to retry
break
except:
self.logger.warning("Error while downloading %s", self.url)
self.error.emit(self, formatException())
break
def testReceive(openPort, targetPath, totalSize, sendDict):
global errorReceive
try:
if sendDict is not None:
dt = DataReceiverThreadBase.receive(SENDER, targetPath, openPort, sendDict, getCoreLogger())
else:
dt = DataReceiverThreadBase.receiveSingleFile(SENDER, targetPath, totalSize, openPort, getCoreLogger())
dt.performReceive()
except:
errorReceive = True
getCoreLogger().error(u"Error receiving: %s", formatException())
def _getMD(self):
if self._md is None:
try:
from markdown import Markdown
if getPlatform()==PLATFORM_WINDOWS and isPyinstallerBuild():
self._md = Markdown()
else:
self._md = Markdown(extensions=['extra'])
except ImportError:
self.logger.error("Cannot enable Markdown (%s)", formatException())
raise
return self._md
def run(self):
try:
self.performReceive()
self.successfullyTransferred.emit(self, self._targetPath)
except CanceledException:
self.transferCanceled.emit(self)
except IncompleteTransfer:
self.errorOnTransfer.emit(self, u"Transfer incomplete.")
except socket.timeout:
self.errorOnTransfer.emit(self, u"Socket timed out.")
except:
self.logger.exception("Error receiving")
self.errorOnTransfer.emit(self, formatException())
def testSend(openPort, filesOrData, sendDict):
global errorSend
try:
if sendDict is not None:
dt = DataSenderThreadBase.send(RECEIVER, openPort, filesOrData, sendDict, getCoreLogger())
elif type(filesOrData) is str:
dt = DataSenderThreadBase.sendData(RECEIVER, openPort, filesOrData, getCoreLogger())
else:
dt = DataSenderThreadBase.sendSingleFile(RECEIVER, openPort, filesOrData[0], getCoreLogger())
dt.performSend()
except:
errorSend = True
getCoreLogger().error(u"Error sending: %s", formatException())
def _selectionChanged(self, newSel, _oldSel):
if len(newSel.indexes()) == 0:
self._detailsView.clear()
else:
index = newSel.indexes()[0]
record = self._records[index.row()]
try:
logMsg = convert_string(record.msg) % record.args
except:
logMsg = convert_string(record.msg) + ', '.join(str(arg) for arg in record.args)
msg = u"%s - In %s:%d: %s" % (strftime("%H:%M:%S", localtime(record.created)),
record.pathname,
record.lineno,
logMsg)
if record.exc_info:
out = StringIO()
traceback.print_tb(record.exc_info[2], file=out)
msg += u"\nStack trace:\n" + out.getvalue() + formatException(record.exc_info) + u"\n"
self._detailsView.setPlainText(msg)
def processEvent(self, xmsg, addr, _eventTime, newPeer, fromQueue):
""" process any non-message event
@type xmsg: extMessageIncoming
@type addr: unicode
@type _eventTime: float
@type newPeer: bool
@type fromQueue: bool
"""
msgData = None
cmd = xmsg.getCommand()
value = xmsg.getCommandPayload()
action = PeerActions.get().getPeerAction(cmd)
peerID = get_peers().getPeerID(pIP=addr)
if action is not None:
if peerID is None:
getCoreLogger().error(u"Could not get peer ID for IP %s", addr)
return
try:
msgData = action.preProcessMessageData(value)
except:
getCoreLogger().error("Error preprocessing data for peer action %s: %s", action.getName(), formatException())
return
if action.willIgnorePeerAction(msgData):
getCoreLogger().debug("Ignore peer action %s.%s from peer %s (message: %s)",
action.getPluginName(), action.getName(),
peerID, value)
if action.hasCategories():
category = action.getCategoryFromMessage(msgData)
else:
category = None
shouldProcess = PeerActions.get().shouldProcessMessage(action, category, peerID, self.getMainGUI(), msgData)
getCoreLogger().debug(u"%s peer action %s.%s from peer %s%s",
"Accept" if shouldProcess else "Reject",
action.getPluginName(), action.getName(),
peerID, ("" if category is None else " category " + category))
if not shouldProcess:
return
self.processPluginCall(addr, lambda p, ip, member_info: p.process_command(xmsg, ip, member_info, msgData), newPeer, fromQueue, action)
#deprecated:
self.processPluginCall(addr, lambda p, ip, member_info: p.process_event("HELO_"+cmd, value, ip, member_info, msgData), newPeer, fromQueue, action)
def run(self):
try:
self.performSend()
except:
self.logger.warning("Error sending file: %s", formatException())
