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())