def checkExceptionPerGreenlet(outfileName=None, ignoreHealthyOnes=True):
mylog("Trying to detect greenlets...", verboseLevel=-2)
if not outfileName:
for ob in gc.get_objects():
if not hasattr(ob, 'parent_args'):
continue
if not ob:
continue
if ignoreHealthyOnes and (not ob.exception):
continue
mylog('%s[%s] called with parent arg\n(%s)\n%s' % (ob.name, repr(ob.args), repr(ob.parent_args),
''.join(traceback.format_stack(ob.gr_frame))), verboseLevel=-2)
mylog(ob.exception, verboseLevel=-2)
else:
handler = open(outfileName, 'w')
for ob in gc.get_objects():
if not hasattr(ob, 'parent_args'):
continue
if not ob:
continue
if ignoreHealthyOnes and (not ob.exception):
continue
handler.write('%s[%s] called with parent arg\n(%s)\n%s' % (ob.name, repr(ob.args), repr(ob.parent_args),
''.join(traceback.format_stack(ob.gr_frame))))
handler.write(ob.exception)
def endrun(self, status):
"""By convention for now, status is one of:
'DEAD'
'UNSUBMITTED' (a pseudo-status defined in the ready-loop of alive())
'EXIT rc'
"""
name = status.split()[0]
if name == 'DEAD':
log.warning(''.join(traceback.format_stack()))
log.error('Task {}\n is DEAD, meaning no HEARTBEAT, but this can be a race-condition. If it was not killed, then restarting might suffice. Otherwise, you might have excessive clock-skew.'.format(self.brief()))
self.setTargetStatus(pypeflow.task.TaskFail) # for lack of anything better
elif name == 'UNSUBMITTED':
log.warning(''.join(traceback.format_stack()))
log.error('Task {}\n is UNSUBMITTED, meaning job-submission somehow failed. Possibly a re-start would work. Otherwise, you need to investigate.'.format(self.brief()))
self.setTargetStatus(pypeflow.task.TaskFail) # for lack of anything better
elif name != 'EXIT':
raise Exception('Unexpected status {!r}'.format(name))
else:
code = int(status.split()[1])
if 0 == code:
self.__target.check_missing()
# TODO: If missing, just leave the status as TaskInitialized?
else:
log.error('Task {} failed with exit-code={}'.format(self.brief(), code))
self.setTargetStatus(pypeflow.task.TaskFail) # for lack of anything better
self.__target.finish()
def entryExitLoggingWrap(*args, **kwargs):
if entryExitLogLevel is None:
enabled = False
else:
logger = getLoggerCallback()
enabled = logger.isEnabledFor(entryExitLogLevel)
if not enabled:
return func(*args, **kwargs)
funcName = str(func)
if logArgs:
argsRepr = ', '.join(
[repr(a) for a in args] +
['%s=%r' % (k,v,) for k,v in kwargs.iteritems()])
else:
argsRepr = ''
logger.log(
entryExitLogLevel, "ENTERING: %s(%s)%s", funcName, argsRepr,
'' if not logTraceback else '; ' + repr(traceback.format_stack()))
try:
return func(*args, **kwargs)
finally:
logger.log(
entryExitLogLevel, "LEAVING: %s(%s)%s", funcName, argsRepr,
'' if not logTraceback else '; ' + repr(traceback.format_stack()))
def _submit(runConfig):
if registry.has_run(runConfig.runid):
msg = "Runid %s does already exist" % runConfig.runid
return SubmissionResponse(runConfig.runid, SUBM_ALREADY_SUBMITTED, msg)
try:
pipeline_exec = PipelineExecution(runConfig, server_model.config)
logger.debug("PipelineExecution object for runid %s created."%runConfig.runid)
pipeline_exec.initialize()
logger.debug("PipelineExecution object for runid %s initialized."%runConfig.runid)
registry.add_run(runConfig.runid, pipeline_exec)
logger.debug("PipelineExecution object for runid %s registered."%runConfig.runid)
_ = pipeline_exec.start()
msg = "Pipeline execution for runid %s started."%runConfig.runid
logger.info(msg)
except ConfigurationError as ce:
msg = 'Submission failed with exception %s.' % str(ce)
stacktrace= 'Stacktrace: \n%s'%'\n'.join(traceback.format_stack())
logger.warn(msg)
return SubmissionResponse(runConfig.runid, SUBM_FAILED, msg, stacktrace)
except Exception as e:
msg = 'Submission failed with exception %s.' % str(e)
stacktrace= 'Stacktrace: \n%s'%'\n'.join(traceback.format_stack())
logger.error(msg)
return SubmissionResponse(runConfig.runid, SUBM_ERROR, msg, stacktrace)
try:
history.add_entry("Runid %s submitted to the system" % runConfig.runid, datetime.datetime.now())
except Exception as e:
logger.warn("Runid %s could not be appended to the history."%runConfig.runid)
msg=msg+"\n But not entry could be added the server history."
return SubmissionResponse(runConfig.runid, SUBM_EXECUTING, msg)
def deprecated(self, method):
"""Output a deprecation warning.
The implementation of WebKit sometimes invokes this method which prints
a warning that the method you are using has been deprecated.
This method expects that deprecated methods say so at the beginning of
their doc string and terminate that msg with @. For example:
DEPRECATED: Class.foo() on 01/24/01 in ver 0.5. Use Class.bar() instead. @
Putting this information in the doc string is important for accuracy
in the generated docs.
Example call:
self.deprecated(self.foo)
"""
docString = method.__doc__
if docString:
msg = docString.split('@')[0]
msg = '\n'.join(map(lambda s: s.strip(), msg.splitlines()))
else:
msg = 'DEPRECATED: %s (no doc string)' % method
print msg
try:
from traceback import format_stack
print format_stack(limit =3)[0]
except Exception:
print 'Could not determine calling function.'
def __init__(self, *args, **kwargs):
if len(args) == 1 and not kwargs and isinstance(args[0], Exception):
# we shall just wrap a non-caused exception
self.stack = (
traceback.format_stack()[:-2] +
traceback.format_tb(sys.exc_info()[2]))
# ^^^ let's hope the information is still there; caller must take
# care of this.
self.wrapped = args[0]
self._cause = []
super(CausedException, self).__init__(repr(args[0]))
# ^^^ to display what it is wrapping, in case it gets printed or similar
return
self.wrapped = None
self.stack = traceback.format_stack()[:-1] # cut off current frame
try:
cause = kwargs['cause']
del kwargs['cause']
except KeyError:
cause = []
if not isinstance(cause, list):
cause = [cause]
self._cause = [CausedException(e) if not isinstance(e, CausedException) else e for e in cause]
self.kwargs = kwargs
super(CausedException, self).__init__(*args)
def error(event, raises=False, e_type=Exception, log_trace=True, limit=None):
"""A level of information that may have caused an error.
:param event: error event instance
:param raises: boolean of whether or not an error should be raised
:param e_type: exception type to be raised
:param log_trace: boolean of whether or not log traceback
:param limit: integer of traceback limit
"""
if raises:
if hasattr(event, "info"):
logged_exception = e_type(event.info)
else:
logged_exception = e_type(event)
if log_trace:
try:
raise logged_exception
except Exception as err:
given_traceback = traceback.format_stack(limit=limit)[:-1]
given_traceback.append(traceback.format_exc(limit=limit))
event.info += '\n' + ''.join(given_traceback)
finally:
raise logged_exception
else:
raise logged_exception
elif log_trace:
event.info += ''.join(traceback.format_stack())
def trace(self, output=''):
if output == 'stderr':
sys.stderr.write(''.join(traceback.format_stack()))
sys.stderr.flush()
else:
sys.stdout.write(''.join(traceback.format_stack()))
sys.stdout.flush()
def _ensure_transport(self):
"""
Ensures this Channel has been activated with the Node.
"""
# log.debug("BaseChannel._ensure_transport (current: %s)", self._transport is not None)
if not self._transport:
raise ChannelError("No transport attached")
if not self._lock:
raise ChannelError("No lock available")
# is lock already acquired? spit out a notice
if self._lock._is_owned():
log.warn("INTERLEAVE DETECTED:\n\nCURRENT STACK:\n%s\n\nSTACK THAT LOCKED: %s\n",
"".join(traceback.format_stack()), "".join(self._lock_trace))
with self._lock:
# we could wait and wait, and it gets closed, and unless we check again, we'd never know!
if not self._transport:
raise ChannelError("No transport attached")
self._lock_trace = traceback.format_stack()
try:
yield
finally:
self._lock_trace = None
def queuedb_query_execute( cur, query, values ):
"""
Execute a query. If it fails, exit.
DO NOT CALL THIS DIRECTLY.
"""
timeout = 1.0
while True:
try:
ret = cur.execute( query, values )
return ret
except sqlite3.OperationalError as oe:
if oe.message == "database is locked":
timeout = timeout * 2 + timeout * random.random()
log.error("Query timed out due to lock; retrying in %s: %s" % (timeout, namedb_format_query( query, values )))
time.sleep(timeout)
else:
log.exception(oe)
log.error("FATAL: failed to execute query (%s, %s)" % (query, values))
log.error("\n".join(traceback.format_stack()))
os.abort()
except Exception, e:
log.exception(e)
log.error("FATAL: failed to execute query (%s, %s)" % (query, values))
log.error("\n".join(traceback.format_stack()))
os.abort()
def upsert(self, pgUrl, commit=True, **kwargs):
if "url" in kwargs and "drive_web" in kwargs["url"]:
self.log.error("")
self.log.error("")
self.log.error("WAT")
self.log.error("")
self.log.error(traceback.format_stack())
self.log.error("")
if "url" in kwargs and not kwargs["url"].startswith("http"):
self.log.error("")
self.log.error("")
self.log.error("WAT")
self.log.error("")
self.log.error(traceback.format_stack())
self.log.error("")
# print("Upserting!")
with self.transaction(commit=commit) as cur:
# Do everything in one transaction
try:
self.insertIntoDb(url=pgUrl, cursor=cur, **kwargs)
except psycopg2.IntegrityError:
if kwargs:
cur.execute("ROLLBACK")
cur.execute("BEGIN")
self.updateDbEntry(url=pgUrl, cursor=cur, **kwargs)
def __formatFailure(self, failure, logMessage, extras):
"""Generates a dict from the given Failure object."""
parts = ['Traceback (most recent call last):']
if not failure.frames:
parts += traceback.format_stack()
else:
for functionName, filename, lineNumber, _, _ in failure.frames:
parts.append('File "%s", line %s, in %s' % (filename, lineNumber, functionName))
backtrace = '\n'.join(parts)
result = {
'project': self.__project,
'type': failure.type.__module__ + '.' + failure.type.__name__,
'message': str(failure.value),
'environment': self.__environment,
'serverName': self.__serverName,
'logMessage': logMessage,
'backtrace': backtrace,
'loggedFrom': '\n'.join(traceback.format_stack())
}
if extras and 'level' in extras:
result['errorLevel'] = extras['level']
del extras['level']
if context and context.all():
result['context'] = context.all()
if extras:
result['context'] = result['context'].copy()
result['context'].update(extras)
elif extras:
result['context'] = extras
return result
def drop_transaction(self, transaction):
"""Drops the specified transaction, validating that it is
actually saved away under the current executing thread.
"""
thread_id = transaction.thread_id
if not thread_id in self._cache:
_logger.error('Runtime instrumentation error. Attempt to '
'to drop the transaction but where none is active. '
'Report this issue to New Relic support.\n%s',
''.join(traceback.format_stack()[:-1]))
raise RuntimeError('no active transaction')
current = self._cache.get(thread_id)
if transaction != current:
_logger.error('Runtime instrumentation error. Attempt to '
'to drop the transaction when it is not the current '
'transaction. Report this issue to New Relic support.\n%s',
''.join(traceback.format_stack()[:-1]))
raise RuntimeError('not the current transaction')
transaction._greenlet = None
del self._cache[thread_id]
def __init__(self, *args, **kwargs):
if len(args) == 1 and not kwargs and isinstance(args[0], Exception):
# we shall just wrap a non-caused exception
self.stack = traceback.format_stack()[:-2] + traceback.format_tb(sys.exc_info()[2])
# ^^^ let's hope the information is still there; caller must take
# care of this.
self.wrapped = args[0]
self.cause = ()
super(CausedException, self).__init__(repr(args[0]))
# ^^^ to display what it is wrapping, in case it gets printed or similar
return
self.wrapped = None
# cut off frames we don't care about
class_depth = max(ancestor_class_depth(CausedException, self.__class__), 0)
self.stack = traceback.format_stack()[: -(class_depth + 1)]
try:
cause = kwargs["cause"]
del kwargs["cause"]
except:
cause = ()
if isinstance(cause, Exception) and not isinstance(cause, CausedException):
cause = CausedException(cause)
self.cause = cause if isinstance(cause, tuple) else (cause,)
super(CausedException, self).__init__(*args, **kwargs)
def dump_stacks():
dump = []
# threads
threads = dict([(th.ident, th.name)
for th in threading.enumerate()])
for thread, frame in sys._current_frames().items():
if thread not in threads:
continue
dump.append('Thread 0x%x (%s)\n' % (thread, threads[thread]))
dump.append(''.join(traceback.format_stack(frame)))
dump.append('\n')
# greenlets
try:
from greenlet import greenlet
except ImportError:
return dump
# if greenlet is present, let's dump each greenlet stack
for ob in gc.get_objects():
if not isinstance(ob, greenlet):
continue
if not ob:
continue # not running anymore or not started
dump.append('Greenlet\n')
dump.append(''.join(traceback.format_stack(ob.gr_frame)))
dump.append('\n')
return dump
def updateObject(self, table_name, flt, values, turn_n = None):
#table_name = '%s_%s'%(table, turn_n) if turn_n else table
try:
self.cur.execute('update %s SET %s WHERE %s'%(table_name, ','.join(['%s=%s'%(k,v) for k,v in values.iteritems()]), ' AND '.join(flt)))
self.conn.commit()
except sqlite3.Error, e:
log.error('Error "%s", when executing: delete from %s WHERE %s'%(e, table_name, ' AND '.join(data)))
print traceback.format_stack()
def eraseObject(self, table_name, data, turn_n = None):
#table_name = '%s_%s'%(table, turn_n) if turn_n else table
try:
self.cur.execute('delete from %s WHERE %s'%(table_name, ' AND '.join(data)))
self.conn.commit()
except sqlite3.Error, e:
log.error('Error "%s", when executing: delete from %s WHERE %s'%(e, table_name, ' AND '.join(data)))
print traceback.format_stack()
def timeout(self):
try:
import time
now = time.strftime('%c')
self.journal.info("## %s: %s ##" % (now, self.message))
except:
import traceback
traceback.format_stack()
def printTrace(self, output=''):
if output == 'stderr':
sys.stderr.write(''.join(traceback.format_stack()))
if self.__log_level >= self.__levels['debug']:
sys.stderr.flush()
else:
sys.stdout.write(''.join(traceback.format_stack()))
if self.__log_level >= self.__levels['debug']:
sys.stdout.flush()
def printTrace(output=''):
if output == 'stderr':
sys.stderr.write(''.join(traceback.format_stack()))
if log_level >= LOG_DEBUG:
sys.stderr.flush()
else:
sys.stdout.write(''.join(traceback.format_stack()))
if log_level >= LOG_DEBUG:
sys.stdout.flush()
def prlk_stack(siPrevio=False):
import traceback
if siPrevio:
prlk("-" * 80 + "\n")
prlk(traceback.format_stack())
prlk("\n" + "-" * 80 + "\n")
for line in traceback.format_stack()[:-1]:
prlk(line.strip() + "\n")
def _assert(cond, msg=''):
"""
Custom C{assert}-like function to verify the assertions
even on release builds.
"""
if not cond:
logger.error('Assertion failed: "%s". %s',
msg, traceback.format_stack())
print msg, traceback.format_stack()
raise AssertionError(msg)
def file_writelines(self, file_path, lines):
'''写数组到文件中
'''
try:
fw = codecs.open(file_path, 'w', 'utf-8')
fw.writelines([line + '\n' for line in lines])
fw.flush()
fw.close()
except:
print traceback.format_stack()
def _explain(curs):
try:
explain = curs.explain()
except (TypeError, OperationFailure), e:
explain = {'error': 'stack:\n\n%s\n\nexception:\n\n%s' %
(''.join(traceback.format_stack()),
''.join(traceback.format_exc()))}
logging.exception('error trying to run explain on curs\n\n'
'stack:\n\n%s\n\nexception:\n\n' %
(''.join(traceback.format_stack())))
def log(msg, level = logging.DEBUG):
logging.log(level, msg)
print('%s [%s], msg:%s' % (datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'), level, msg))
if level == logging.WARNING or level == logging.ERROR:
for line in traceback.format_stack():
print(line.strip())
for line in traceback.format_stack():
logging.log(level, line.strip())
def exception(group, message, *args, exc=None, log_current_callstack=True, frame=DEFAULT, use_format_stack=False, level=LEVEL_EXCEPTION, owner=None):
if owner:
message = ('[{owner}] ' + message).format(owner=owner, *args)
elif args:
message = message.format(*args)
if frame is DEFAULT:
frame = sys._getframe(1)
if exc is None:
(exc_type, exc, exc_tb) = sys.exc_info()
log_current_callstack_prefix = ''
else:
exc_type = type(exc)
exc_tb = exc.__traceback__
log_current_callstack_prefix = 'Caught and logged:\n'
if callback_on_error_or_exception is not None:
callback_on_error_or_exception(message)
tb = format_exc(exc)
if use_format_stack:
dialog_text = ''.join(traceback.format_stack(frame))
else:
dialog_text = tb
if exc is not None:
try:
headline = str(exc)
except:
headline = '<unprintable exception {}>'.format(type(exc).__name__)
classname = exc_type.__name__
if classname in headline:
headline = ' ({})'.format(headline)
elif headline:
headline = ' ({}: {})'.format(classname, headline)
else:
headline = ' ({})'.format(classname)
message += headline
message_base = message
tbx = tb.split('\n', 1)
message += '\n' + tbx[0] + '\n'
if log_current_callstack:
message += log_current_callstack_prefix
message += ''.join(traceback.format_stack(frame))
message += tbx[1]
blank_line(group, level, frame, ring_bell=ring_bell_on_exception)
ConsoleColor.change_color(get_console_color(level, group))
_trace.trace(TYPE_LOG, message, group, level, get_log_zone(), frame)
errorLog = '<report><version>2</version><sessionid>%lld</sessionid><type>desync</type>'
errorLog += '<sku>ea.maxis.sims4.13.pc</sku><createtime>'
errorLog += datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
errorLog += '</createtime><buildsignature>Local.Unknown.Unknown.0.0.0.0.Debug</buildsignature>'
errorLog += '<categoryid>%s</categoryid>'
errorLog += '<desyncid>%lld</desyncid>'
errorLog += '<systemconfig/><screenshot/>'
errorLog += '<desyncdata>%s</desyncdata></report>\n'
_trace.log_exception(errorLog, tbx[1], frame)
sim_error_dialog(message_base, exc_tb, dialog_text, level=level)
def retryWrap(*args, **kwargs):
numAttempts = 0
delaySec = initialRetryDelaySec
startTime = time.time()
# Make sure it gets called at least once
while True:
numAttempts += 1
try:
result = func(*args, **kwargs)
except retryExceptions, e:
if not retryFilter(e, args, kwargs):
logger = getLoggerCallback()
if logger.isEnabledFor(logging.DEBUG):
logger.debug(
'[%s] Failure in %r; retries aborted by custom retryFilter. '
'Caller stack:\n%s', clientLabel, func,
''.join(traceback.format_stack()), exc_info=True)
raise
now = time.time()
# Compensate for negative time adjustment so we don't get stuck
# waiting way too long (python doesn't provide monotonic time yet)
if now < startTime:
startTime = now
if (now - startTime) >= timeoutSec:
getLoggerCallback().exception(
'[%s] Exhausted retry timeout (%s sec.; %s attempts) for %r. '
'Caller stack:\n%s', clientLabel, timeoutSec, numAttempts, func,
''.join(traceback.format_stack()))
raise
if numAttempts == 1:
getLoggerCallback().warning(
'[%s] First failure in %r; initial retry in %s sec.; '
'timeoutSec=%s. Caller stack:\n%s', clientLabel, func, delaySec,
timeoutSec, ''.join(traceback.format_stack()), exc_info=True)
else:
getLoggerCallback().debug(
'[%s] %r failed %s times; retrying in %s sec.; timeoutSec=%s. '
'Caller stack:\n%s',
clientLabel, func, numAttempts, delaySec, timeoutSec,
''.join(traceback.format_stack()), exc_info=True)
time.sleep(delaySec)
delaySec = min(delaySec*2, maxRetryDelaySec)
else:
if numAttempts > 1:
getLoggerCallback().info('[%s] %r succeeded on attempt # %d',
clientLabel, func, numAttempts)
return result
def thread(self, id):
id = int(id)
print id
print sys._current_frames()
stack = '<br />'.join(traceback.format_stack(sys._current_frames()[id]))
stack = traceback.format_stack(sys._current_frames()[id])
locals = sys._current_frames()[id].f_locals
globals = sys._current_frames()[id].f_globals
t = _env.get_template('thread.html')
return t.render(id=id, stack=stack, locals=locals, globals=globals)
def file_write(self, file_path, content):
'''写入内容到某个文件中
'''
try:
# 普通的write和writelines接口无法写入utf8,需要通过codecs的open函数写入
fw = codecs.open(file_path, 'w', 'utf-8')
fw.write(content)
fw.close()
except:
print 'error!:'
print traceback.format_stack()
fw.close()
def file_writelines(self, file_path, lines):
'''写入内容到某个文件中,此时的内容是一个数组
'''
try:
fw = codecs.open(file_path, 'w', 'utf-8')
fw.writelines(lines)
fw.close()
except:
print 'error!:'
print traceback.format_stack()
pdb.set_trace()
fw.close()
def main(args, net, datadir_path, merged_urls, worker_endpoint):
try:
print 'p2pool (version %s)' % (p2pool.__version__, )
print
@defer.inlineCallbacks
def connect_p2p():
# connect to bitcoind over bitcoin-p2p
print '''Testing bitcoind P2P connection to '%s:%s'...''' % (
args.bitcoind_address, args.bitcoind_p2p_port)
factory = bitcoin_p2p.ClientFactory(net.PARENT)
reactor.connectTCP(args.bitcoind_address, args.bitcoind_p2p_port,
factory)
def long():
print ''' ...taking a while. Common reasons for this include all of bitcoind's connection slots being used...'''
long_dc = reactor.callLater(5, long)
yield factory.getProtocol() # waits until handshake is successful
if not long_dc.called: long_dc.cancel()
print ' ...success!'
print
defer.returnValue(factory)
if args.testnet: # establish p2p connection first if testnet so bitcoind can work without connections
factory = yield connect_p2p()
# connect to bitcoind over JSON-RPC and do initial getmemorypool
url = '%s://%s:%i/' % ('https' if args.bitcoind_rpc_ssl else 'http',
args.bitcoind_address, args.bitcoind_rpc_port)
print '''Testing bitcoind RPC connection to '%s' with username '%s'...''' % (
url, args.bitcoind_rpc_username)
bitcoind = jsonrpc.HTTPProxy(
url,
dict(Authorization='Basic ' +
base64.b64encode(args.bitcoind_rpc_username + ':' +
args.bitcoind_rpc_password)),
timeout=30)
yield helper.check(bitcoind, net, args)
temp_work = yield helper.getwork(bitcoind)
bitcoind_getinfo_var = variable.Variable(None)
@defer.inlineCallbacks
def poll_warnings():
bitcoind_getinfo_var.set(
(yield deferral.retry('Error while calling getinfo:')(
bitcoind.rpc_getnetworkinfo)()))
yield poll_warnings()
deferral.RobustLoopingCall(poll_warnings).start(20 * 60)
print ' ...success!'
print ' Current block hash: %x' % (temp_work['previous_block'], )
print ' Current block height: %i' % (temp_work['height'] - 1, )
print
if not args.testnet:
factory = yield connect_p2p()
print 'Determining payout address...'
pubkeys = keypool()
if args.pubkey_hash is None and args.address != 'dynamic':
address_path = os.path.join(datadir_path, 'cached_payout_address')
if os.path.exists(address_path):
with open(address_path, 'rb') as f:
address = f.read().strip('\r\n')
print ' Loaded cached address: %s...' % (address, )
else:
address = None
if address is not None:
res = yield deferral.retry(
'Error validating cached address:',
5)(lambda: bitcoind.rpc_getaddressinfo(address))()
if not res['ismine']:
print ' Cached address is either invalid or not controlled by local bitcoind!'
address = None
if address is None:
print ' Getting payout address from bitcoind...'
address = yield deferral.retry(
'Error getting payout address from bitcoind:',
5)(lambda: bitcoind.rpc_getaccountaddress('p2pool'))()
with open(address_path, 'wb') as f:
f.write(address)
my_address = address
print(' ...success! Payout address: %s' % my_address)
print()
pubkeys.addkey({'address': my_address})
elif args.address != 'dynamic':
my_address = args.address
print(' ...success! Payout address: %s' % my_address)
print()
pubkeys.addkey({'address': my_address})
else:
print ' Entering dynamic address mode.'
if args.numaddresses < 2:
print ' ERROR: Can not use fewer than 2 addresses in dynamic mode. Resetting to 2.'
args.numaddresses = 2
for i in range(args.numaddresses):
address = yield deferral.retry(
'Error getting a dynamic address from bitcoind:', 5
)(lambda: bitcoind.rpc_getnewaddress('p2pool', 'legacy'))()
pubkeys.addkey({'address': address})
pubkeys.updatestamp(time.time())
my_address = pubkeys.keys[0]['address']
for i in range(len(pubkeys.keys)):
print(' ...payout %d: %s' % (i, pubkeys[i]['address']))
print "Loading shares..."
shares = {}
known_verified = set()
def share_cb(share):
share.time_seen = 0 # XXX
shares[share.hash] = share
if len(shares) % 1000 == 0 and shares:
print " %i" % (len(shares), )
ss = p2pool_data.ShareStore(os.path.join(datadir_path, 'shares.'), net,
share_cb, known_verified.add)
print " ...done loading %i shares (%i verified)!" % (
len(shares), len(known_verified))
print
print 'Initializing work...'
global gnode
gnode = node = p2pool_node.Node(factory, bitcoind, shares.values(),
known_verified, net)
yield node.start()
for share_hash in shares:
if share_hash not in node.tracker.items:
ss.forget_share(share_hash)
for share_hash in known_verified:
if share_hash not in node.tracker.verified.items:
ss.forget_verified_share(share_hash)
node.tracker.removed.watch(lambda share: ss.forget_share(share.hash))
node.tracker.verified.removed.watch(
lambda share: ss.forget_verified_share(share.hash))
def save_shares():
for share in node.tracker.get_chain(
node.best_share_var.value,
min(node.tracker.get_height(node.best_share_var.value),
2 * net.CHAIN_LENGTH)):
ss.add_share(share)
if share.hash in node.tracker.verified.items:
ss.add_verified_hash(share.hash)
deferral.RobustLoopingCall(save_shares).start(60)
if len(shares) > net.CHAIN_LENGTH:
best_share = shares[node.best_share_var.value]
previous_share = shares[
best_share.share_data['previous_share_hash']]
counts = p2pool_data.get_desired_version_counts(
node.tracker,
node.tracker.get_nth_parent_hash(previous_share.hash,
net.CHAIN_LENGTH * 9 // 10),
net.CHAIN_LENGTH // 10)
p2pool_data.update_min_protocol_version(counts, best_share)
print ' ...success!'
print
print 'Joining p2pool network using port %i...' % (args.p2pool_port, )
@defer.inlineCallbacks
def parse(host):
port = net.P2P_PORT
if ':' in host:
host, port_str = host.split(':')
port = int(port_str)
defer.returnValue(((yield reactor.resolve(host)), port))
addrs = {}
if os.path.exists(os.path.join(datadir_path, 'addrs')):
try:
with open(os.path.join(datadir_path, 'addrs'), 'rb') as f:
addrs.update(
dict((tuple(k), v) for k, v in json.loads(f.read())))
except:
print >> sys.stderr, 'error parsing addrs'
for addr_df in map(parse, net.BOOTSTRAP_ADDRS):
try:
addr = yield addr_df
if addr not in addrs:
addrs[addr] = (0, time.time(), time.time())
except:
log.err()
connect_addrs = set()
for addr_df in map(parse, args.p2pool_nodes):
try:
connect_addrs.add((yield addr_df))
except:
log.err()
node.p2p_node = p2pool_node.P2PNode(
node,
port=args.p2pool_port,
max_incoming_conns=args.p2pool_conns,
addr_store=addrs,
connect_addrs=connect_addrs,
desired_outgoing_conns=args.p2pool_outgoing_conns,
advertise_ip=args.advertise_ip,
external_ip=args.p2pool_external_ip,
)
node.p2p_node.start()
def save_addrs():
with open(os.path.join(datadir_path, 'addrs'), 'wb') as f:
f.write(json.dumps(node.p2p_node.addr_store.items()))
deferral.RobustLoopingCall(save_addrs).start(60)
print ' ...success!'
print
if args.upnp:
@defer.inlineCallbacks
def upnp_thread():
while True:
try:
is_lan, lan_ip = yield ipdiscover.get_local_ip()
if is_lan:
pm = yield portmapper.get_port_mapper()
yield pm._upnp.add_port_mapping(
lan_ip, args.p2pool_port, args.p2pool_port,
'p2pool', 'TCP')
except defer.TimeoutError:
pass
except:
if p2pool.DEBUG:
log.err(None, 'UPnP error:')
yield deferral.sleep(random.expovariate(1 / 120))
upnp_thread()
# start listening for workers with a JSON-RPC server
print 'Listening for workers on %r port %i...' % (worker_endpoint[0],
worker_endpoint[1])
wb = work.WorkerBridge(node, my_address, 0.0, merged_urls,
args.worker_fee, args, pubkeys, bitcoind,
args.share_rate)
web_root = web.get_web_root(wb,
datadir_path,
bitcoind_getinfo_var,
static_dir=args.web_static)
caching_wb = worker_interface.CachingWorkerBridge(wb)
worker_interface.WorkerInterface(caching_wb).attach_to(
web_root, get_handler=lambda request: request.redirect('/static/'))
web_serverfactory = server.Site(web_root)
serverfactory = switchprotocol.FirstByteSwitchFactory(
{'{': stratum.StratumServerFactory(caching_wb)}, web_serverfactory)
deferral.retry('Error binding to worker port:', traceback=False)(
reactor.listenTCP)(worker_endpoint[1],
serverfactory,
interface=worker_endpoint[0])
with open(os.path.join(os.path.join(datadir_path, 'ready_flag')),
'wb') as f:
pass
print ' ...success!'
print
# done!
print 'Started successfully!'
print 'Go to http://127.0.0.1:%i/ to view graphs and statistics!' % (
worker_endpoint[1], )
print
if hasattr(signal, 'SIGALRM'):
signal.signal(
signal.SIGALRM, lambda signum, frame: reactor.callFromThread(
sys.stderr.write, 'Watchdog timer went off at:\n' + ''.
join(traceback.format_stack())))
signal.siginterrupt(signal.SIGALRM, False)
deferral.RobustLoopingCall(signal.alarm, 30).start(1)
if args.irc_announce:
from twisted.words.protocols import irc
class IRCClient(irc.IRCClient):
nickname = 'p2pool%02i' % (random.randrange(100), )
channel = net.ANNOUNCE_CHANNEL
def lineReceived(self, line):
if p2pool.DEBUG:
print repr(line)
irc.IRCClient.lineReceived(self, line)
def signedOn(self):
self.in_channel = False
irc.IRCClient.signedOn(self)
self.factory.resetDelay()
self.join(self.channel)
@defer.inlineCallbacks
def new_share(share):
if not self.in_channel:
return
if share.pow_hash <= share.header[
'bits'].target and abs(share.timestamp -
time.time()) < 10 * 60:
yield deferral.sleep(random.expovariate(1 / 60))
message = '\x02%s BLOCK FOUND by %s! %s%064x' % (
net.NAME.upper(),
bitcoin_data.script2_to_address(
share.new_script, net.ADDRESS_VERSION, -1,
net.PARENT)
if share.VERSION < 34 else share.address,
net.PARENT.BLOCK_EXPLORER_URL_PREFIX,
share.header_hash)
if all('%x' %
(share.header_hash, ) not in old_message
for old_message in self.recent_messages):
self.say(self.channel, message)
self._remember_message(message)
self.watch_id = node.tracker.verified.added.watch(
new_share)
self.recent_messages = []
def joined(self, channel):
self.in_channel = True
def left(self, channel):
self.in_channel = False
def _remember_message(self, message):
self.recent_messages.append(message)
while len(self.recent_messages) > 100:
self.recent_messages.pop(0)
def privmsg(self, user, channel, message):
if channel == self.channel:
self._remember_message(message)
def connectionLost(self, reason):
node.tracker.verified.added.unwatch(self.watch_id)
print 'IRC connection lost:', reason.getErrorMessage()
class IRCClientFactory(protocol.ReconnectingClientFactory):
protocol = IRCClient
reactor.connectTCP("irc.freenode.net",
6667,
IRCClientFactory(),
bindAddress=(worker_endpoint[0], 0))
@defer.inlineCallbacks
def status_thread():
last_str = None
last_time = 0
while True:
yield deferral.sleep(30)
try:
height = node.tracker.get_height(node.best_share_var.value)
this_str = 'P2Pool: %i shares in chain (%i verified/%i total) Peers: %i (%i incoming)' % (
height,
len(node.tracker.verified.items),
len(node.tracker.items),
len(node.p2p_node.peers),
sum(1 for peer in node.p2p_node.peers.itervalues()
if peer.incoming),
) + (' FDs: %i R/%i W' %
(len(reactor.getReaders()), len(reactor.getWriters()))
if p2pool.DEBUG else '')
datums, dt = wb.local_rate_monitor.get_datums_in_last()
my_att_s = sum(datum['work'] / dt for datum in datums)
my_shares_per_s = sum(
datum['work'] / dt /
bitcoin_data.target_to_average_attempts(
datum['share_target']) for datum in datums)
this_str += '\n Local: %sH/s in last %s Local dead on arrival: %s Expected time to share: %s' % (
math.format(int(my_att_s)),
math.format_dt(dt),
math.format_binomial_conf(
sum(1 for datum in datums if datum['dead']),
len(datums), 0.95),
math.format_dt(1 / my_shares_per_s)
if my_shares_per_s else '???',
)
if height > 2:
(stale_orphan_shares,
stale_doa_shares), shares, _ = wb.get_stale_counts()
stale_prop = p2pool_data.get_average_stale_prop(
node.tracker, node.best_share_var.value,
min(60 * 60 // net.SHARE_PERIOD, height))
real_att_s = p2pool_data.get_pool_attempts_per_second(
node.tracker, node.best_share_var.value,
min(height - 1, 60 * 60 //
net.SHARE_PERIOD)) / (1 - stale_prop)
paystr = ''
paytot = 0.0
for i in range(len(pubkeys.keys)):
curtot = node.get_current_txouts().get(
pubkeys.keys[i]['address'], 0)
paytot += curtot * 1e-8
paystr += "(%.4f)" % (curtot * 1e-8, )
paystr += "=%.4f" % (paytot, )
this_str += '\n Shares: %i (%i orphan, %i dead) Stale rate: %s Efficiency: %s Current payout: %s %s' % (
shares,
stale_orphan_shares,
stale_doa_shares,
math.format_binomial_conf(
stale_orphan_shares + stale_doa_shares, shares,
0.95),
math.format_binomial_conf(
stale_orphan_shares + stale_doa_shares, shares,
0.95, lambda x: (1 - x) / (1 - stale_prop)),
paystr,
net.PARENT.SYMBOL,
)
this_str += '\n Pool: %sH/s Stale rate: %.1f%% Expected time to block: %s' % (
math.format(int(real_att_s)),
100 * stale_prop,
math.format_dt(
2**256 /
node.bitcoind_work.value['bits'].target /
real_att_s),
)
for warning in p2pool_data.get_warnings(
node.tracker, node.best_share_var.value, net,
bitcoind_getinfo_var.value,
node.bitcoind_work.value):
print >> sys.stderr, '#' * 40
print >> sys.stderr, '>>> Warning: ' + warning
print >> sys.stderr, '#' * 40
if gc.garbage:
print '%i pieces of uncollectable cyclic garbage! Types: %r' % (
len(gc.garbage), map(type, gc.garbage))
if this_str != last_str or time.time() > last_time + 15:
print this_str
last_str = this_str
last_time = time.time()
except:
log.err()
status_thread()
except:
reactor.stop()
log.err(None, 'Fatal error:')
'Intended Audience :: Developers',
'Programming Language :: Python',
'Programming Language :: C',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.3',
'Programming Language :: Python :: 3.4',
'Programming Language :: Python :: Implementation :: CPython',
'Programming Language :: Python :: Implementation :: Jython',
'Programming Language :: Python :: Implementation :: PyPy',
'Operating System :: Microsoft :: Windows',
'Operating System :: POSIX',
'License :: OSI Approved :: BSD License',
'Topic :: Software Development :: Libraries :: Python Modules',
'Topic :: System :: Distributed Computing',
],
**extras)
try:
run_setup(not (is_jython or is_pypy or is_py3k))
except BaseException:
if _is_build_command(sys.argv):
import traceback
print(BUILD_WARNING % '\n'.join(traceback.format_stack()),
file=sys.stderr)
run_setup(False)
else:
raise
def dump_thread_handler(signum, frame):
# type: (int, FrameType) -> None
for thread_id, thread_frame in sys._current_frames().items():
print("-- thread id {}:".format(thread_id))
print("".join(traceback.format_stack(thread_frame)))
def logstacktrace(self):
self.ui.log(
"remotefilelog",
"excess remotefilelog fetching:\n%s\n",
"".join(traceback.format_stack()),
)
def __init__(self,
robot,
joystick=None,
log_data=True,
log_name=None,
log_dir=None,
debug_prints=False):
"""
:param robot: a subclass instance of the atlasbuggy.robot.Robot class
:param joystick: a subclass instance of the atlasbuggy.buggyjoystick.BuggyJoystick class
:param log_data: enable data logging (debug prints logged even if they are not enabled)
:param log_name: log file name (today's date is substituted if None (YYYY_MM_DD))
:param log_dir: log directory (today's date is substituted if None (YYYY_MM_DD))
Tuple feature: ("some_data", None) -> produces "some_data/YYYY_MM_DD"
:param debug_prints: print debug messages
"""
super(RobotRunner, self).__init__(robot, debug_prints, "Interface")
# clock properties
self.loop_ups = RobotRunner.loop_updates_per_second
self.port_ups = RobotRunner.port_updates_per_second
self.lag_warning_thrown = False # prevents the terminal from being spammed
self.clock = Clock(self.loop_ups)
self.start_time = 0
# keep the last packet info for crash info
self.prev_packet_info = [None, None, None]
# pass around reference to joystick
self.joystick = joystick
self.robot.joystick = joystick
# initialize logger
self.logger = Logger(log_name, log_dir)
self.robot.logger = self.logger
if log_data:
self.logger.open()
print("Writing to:", self.logger.full_path)
for robot_object in self.robot.objects.values():
robot_object.is_live = True
self.robot.is_live = True
self.robot.debug_enabled = self.debug_enabled
# create a pipe from all port processes to the main loop
self.packet_queue = Queue()
self.packet_counter = Value('i', 0)
self.port_lock = Lock()
# open all available ports
self.ports = {}
threads = []
# call _configure_port for each available serial port
self.duplicate_id_error = [False, None] # [did error occur, whoiam ID]
for port_info in serial.tools.list_ports.comports():
config_thread = threading.Thread(target=self._configure_port,
args=(port_info, self.port_ups))
threads.append(config_thread)
config_thread.start()
# wait for threads to finish
for thread in threads:
thread.join()
if self.duplicate_id_error[0]:
self._close_ports("error")
raise self._handle_error(
RobotSerialPortWhoiamIdTaken(
"whoiam ID already being used by another port! It's possible "
"the same code was uploaded for two boards.",
self.prev_packet_info, self.duplicate_id_error[1]),
traceback.format_stack())
# throw an error if a port isn't configured correctly
for port_name, port in self.ports.items():
if not port.configured:
self._print_port_info(port)
raise self._handle_error(
RobotSerialPortNotConfiguredError("Port not configured!",
self.prev_packet_info,
port),
traceback.format_stack())
self._debug_print("Discovered ports:", list(self.ports.keys()))
self._check_objects() # check that all objects are assigned a port
self._check_ports() # check that all ports are assigned an object
for whoiam in self.ports.keys():
self._debug_print("[%s] has ID '%s'" %
(self.ports[whoiam].address, whoiam))
# notify user of disabled robot objects
if len(self.robot.inactive_ids) > 0 and self.debug_enabled:
self._debug_print("Ignored IDs:")
for whoiam in self.robot.inactive_ids:
self._debug_print(whoiam)
self._send_first_packets() # distribute initialization packets
def g():
for line in traceback.format_stack():
print(line.strip())
def fetch_enterprise_learner_data(self, user):
"""
Fetch information related to enterprise from the Enterprise Service.
Example:
fetch_enterprise_learner_data(user)
Argument:
user: (User) django auth user
Returns:
dict:
{
"count": 1,
"num_pages": 1,
"current_page": 1,
"next": null,
"start": 0,
"previous": null
"results": [
{
"enterprise_customer": {
"uuid": "cf246b88-d5f6-4908-a522-fc307e0b0c59",
"name": "TestShib",
"active": true,
"site": {
"domain": "example.com",
"name": "example.com"
},
"enable_data_sharing_consent": true,
"enforce_data_sharing_consent": "at_login",
"branding_configuration": {
"enterprise_customer": "cf246b88-d5f6-4908-a522-fc307e0b0c59",
"logo": "https://open.edx.org/sites/all/themes/edx_open/logo.png"
},
"enterprise_customer_entitlements": [
{
"enterprise_customer": "cf246b88-d5f6-4908-a522-fc307e0b0c59",
"entitlement_id": 69
}
],
"replace_sensitive_sso_username": False,
},
"user_id": 5,
"user": {
"username": "******",
"first_name": "",
"last_name": "",
"email": "*****@*****.**",
"is_staff": true,
"is_active": true,
"date_joined": "2016-09-01T19:18:26.026495Z"
},
"data_sharing_consent_records": [
{
"username": "******",
"enterprise_customer_uuid": "cf246b88-d5f6-4908-a522-fc307e0b0c59",
"exists": true,
"course_id": "course-v1:edX DemoX Demo_Course",
"consent_provided": true,
"consent_required": false
}
]
}
],
}
Raises:
ConnectionError: requests exception "ConnectionError", raised if if ecommerce is unable to connect
to enterprise api server.
SlumberBaseException: base slumber exception "SlumberBaseException", raised if API response contains
http error status like 4xx, 5xx etc.
Timeout: requests exception "Timeout", raised if enterprise API is taking too long for returning
a response. This exception is raised for both connection timeout and read timeout.
"""
if not user.is_authenticated:
return None
api_resource_name = 'enterprise-learner'
try:
endpoint = getattr(self.client, api_resource_name)
querystring = {'username': user.username}
response = endpoint().get(**querystring)
except (HttpClientError, HttpServerError):
LOGGER.exception(
u'Failed to get enterprise-learner for user [%s] with client user [%s]. Caller: %s, Request PATH: %s',
user.username,
self.user.username,
"".join(traceback.format_stack()),
get_current_request().META['PATH_INFO'],
)
return None
return response
def ShowExceptionTupleClient( etype, value, tb, do_wait = True ):
if etype is None:
etype = HydrusExceptions.UnknownException
if value is None:
value = 'Unknown error'
if tb is None:
trace = 'No error trace--here is the stack:' + os.linesep + ''.join( traceback.format_stack() )
else:
trace = ''.join( traceback.format_exception( etype, value, tb ) )
pretty_value = str( value )
if os.linesep in pretty_value:
( first_line, anything_else ) = pretty_value.split( os.linesep, 1 )
trace = trace + os.linesep + anything_else
else:
first_line = pretty_value
job_key = ClientThreading.JobKey()
if etype == HydrusExceptions.ShutdownException:
return
else:
title = str( getattr( etype, '__name__', etype ) )
job_key.SetStatusTitle( title )
job_key.SetVariable( 'popup_text_1', first_line )
job_key.SetTraceback( trace )
text = job_key.ToString()
HydrusData.Print( 'Exception:' )
HydrusData.DebugPrint( text )
HG.client_controller.pub( 'message', job_key )
if do_wait:
time.sleep( 1 )
def callback(sig, frame):
txt = ''.join(traceback.format_stack(frame))
print()
print(txt)
def fmt():
return traceback.format_stack()
def func_wrapper(*args, **kwargs):
exc_info = sys.exc_info()
try:
return func(*args, **kwargs)
except Exception as e:
exc_type, exc_obj, exc_tb = sys.exc_info()
erStr = ("%s ERROR - Prism_Plugin_Nuke_Integration - Core: %s - Plugin: %s:\n%s\n\n%s" % (time.strftime("%d/%m/%y %X"), args[0].core.version, args[0].plugin.version, ''.join(traceback.format_stack()), traceback.format_exc()))
if hasattr(args[0].core, "writeErrorLog"):
args[0].core.writeErrorLog(erStr)
else:
QMessageBox.warning(args[0].core.messageParent, "Prism Integration", erStr)
def fn_ngettext(a, b, c) -> None: # type: ignore
print("".join(traceback.format_stack()[-2]))
print(
"ngettext global will break in the future; please see anki/lang.py"
)
return b
def fn__(arg) -> None: # type: ignore
print("".join(traceback.format_stack()[-2]))
print("_ global will break in the future; please see anki/lang.py")
return arg
def debug(sig, frame):
logger.critical("Signal received: printing stack trace")
logger.critical(str("").join(format_stack(frame)))
def _signal_handler(self, sig, frame):
self._handle_failure(f"Terminated with signal {sig}\n" +
"".join(traceback.format_stack(frame)))
sys.exit(sig + 128)
def not_to_be_wrapped(self, limit):
return format_stack(limit=limit)
def debug(*args, force=False, love_u=Config.TQDM, end='\n', ex=None):
Tools.pyout(
"DEBUG ->", traceback.format_stack()[-2].split('\n')[0])
Tools.pyout("-------> ", *args, force=force, love_u=love_u, end=end)
if ex is not None:
sys.exit(ex)
def __init__(self, driver, index, description):
self.screenshot_binary = driver.get_screenshot_as_png()
self.description = description
self.index = index
self.exc = traceback.format_exc()
self.stack = traceback.format_stack()
def qt_message_handler(msg_type, context, msg):
"""Qt message handler to redirect qWarning etc. to the logging system.
Args:
QtMsgType msg_type: The level of the message.
QMessageLogContext context: The source code location of the message.
msg: The message text.
"""
# Mapping from Qt logging levels to the matching logging module levels.
# Note we map critical to ERROR as it's actually "just" an error, and fatal
# to critical.
qt_to_logging = {
QtCore.QtDebugMsg: logging.DEBUG,
QtCore.QtWarningMsg: logging.WARNING,
QtCore.QtCriticalMsg: logging.ERROR,
QtCore.QtFatalMsg: logging.CRITICAL,
}
try:
qt_to_logging[QtCore.QtInfoMsg] = logging.INFO
except AttributeError:
# While we don't support Qt < 5.5 anymore, logging still needs to work
pass
# Change levels of some well-known messages to debug so they don't get
# shown to the user.
#
# If a message starts with any text in suppressed_msgs, it's not logged as
# error.
suppressed_msgs = [
# PNGs in Qt with broken color profile
# https://bugreports.qt.io/browse/QTBUG-39788
('libpng warning: iCCP: Not recognizing known sRGB profile that has '
'been edited'),
'libpng warning: iCCP: known incorrect sRGB profile',
# Hopefully harmless warning
'OpenType support missing for script ',
# Error if a QNetworkReply gets two different errors set. Harmless Qt
# bug on some pages.
# https://bugreports.qt.io/browse/QTBUG-30298
('QNetworkReplyImplPrivate::error: Internal problem, this method must '
'only be called once.'),
# Sometimes indicates missing text, but most of the time harmless
'load glyph failed ',
# Harmless, see https://bugreports.qt.io/browse/QTBUG-42479
('content-type missing in HTTP POST, defaulting to '
'application/x-www-form-urlencoded. '
'Use QNetworkRequest::setHeader() to fix this problem.'),
# https://bugreports.qt.io/browse/QTBUG-43118
'Using blocking call!',
# Hopefully harmless
('"Method "GetAll" with signature "s" on interface '
'"org.freedesktop.DBus.Properties" doesn\'t exist'),
('"Method \\"GetAll\\" with signature \\"s\\" on interface '
'\\"org.freedesktop.DBus.Properties\\" doesn\'t exist\\n"'),
'WOFF support requires QtWebKit to be built with zlib support.',
# Weird Enlightment/GTK X extensions
'QXcbWindow: Unhandled client message: "_E_',
'QXcbWindow: Unhandled client message: "_ECORE_',
'QXcbWindow: Unhandled client message: "_GTK_',
# Happens on AppVeyor CI
'SetProcessDpiAwareness failed:',
# https://bugreports.qt.io/browse/QTBUG-49174
('QObject::connect: Cannot connect (null)::stateChanged('
'QNetworkSession::State) to '
'QNetworkReplyHttpImpl::_q_networkSessionStateChanged('
'QNetworkSession::State)'),
# https://bugreports.qt.io/browse/QTBUG-53989
("Image of format '' blocked because it is not considered safe. If "
"you are sure it is safe to do so, you can white-list the format by "
"setting the environment variable QTWEBKIT_IMAGEFORMAT_WHITELIST="),
# Installing Qt from the installer may cause it looking for SSL3 or
# OpenSSL 1.0 which may not be available on the system
"QSslSocket: cannot resolve ",
"QSslSocket: cannot call unresolved function ",
# When enabling debugging with QtWebEngine
("Remote debugging server started successfully. Try pointing a "
"Chromium-based browser to "),
# https://github.com/qutebrowser/qutebrowser/issues/1287
"QXcbClipboard: SelectionRequest too old",
# https://github.com/qutebrowser/qutebrowser/issues/2071
'QXcbWindow: Unhandled client message: ""',
# https://codereview.qt-project.org/176831
"QObject::disconnect: Unexpected null parameter",
]
# not using utils.is_mac here, because we can't be sure we can successfully
# import the utils module here.
if sys.platform == 'darwin':
suppressed_msgs += [
'libpng warning: iCCP: known incorrect sRGB profile',
# https://bugreports.qt.io/browse/QTBUG-47154
('virtual void QSslSocketBackendPrivate::transmit() SSLRead '
'failed with: -9805'),
]
if not msg:
msg = "Logged empty message!"
if any(msg.strip().startswith(pattern) for pattern in suppressed_msgs):
level = logging.DEBUG
else:
level = qt_to_logging[msg_type]
if context.function is None:
func = 'none'
elif ':' in context.function:
func = '"{}"'.format(context.function)
else:
func = context.function
if context.category is None or context.category == 'default':
name = 'qt'
else:
name = 'qt-' + context.category
if msg.splitlines()[0] == ('This application failed to start because it '
'could not find or load the Qt platform plugin '
'"xcb".'):
# Handle this message specially.
msg += ("\n\nOn Archlinux, this should fix the problem:\n"
" pacman -S libxkbcommon-x11")
faulthandler.disable()
if _args.debug:
stack = ''.join(traceback.format_stack())
else:
stack = None
record = qt.makeRecord(name,
level,
context.file,
context.line,
msg,
None,
None,
func,
sinfo=stack)
qt.handle(record)
async def sendat(context):
if not context.parameter:
await context.edit(helpmsg)
return
mem_id = len(mem)
mem.append("[NULL]")
chat = await context.get_chat()
args = " ".join(context.parameter).split("|")
if not imported:
await context.edit("请先安装依赖：`python3 -m pip install dateparser`\n随后，请重启 pagermaid。")
return
await context.edit(f"debug: tz data: {time.timezone} {time.tzname} {sign}{offset}")
if len(args) != 2:
if args[0].find("rm ") == 0:
# clear timer
target_ids = args[0][3:].strip().split(" ")
for target_id in target_ids:
if target_id.isnumeric():
if len(mem) > int(target_id):
mem[int(target_id)] = ""
await context.edit(f"id {target_id} successfully removed.")
else:
await context.edit("id out of range.")
return
else:
await context.edit("id should be a integer.")
return
else:
await context.edit("Invalid argument counts. Expecting: 2")
return
if offset is None:
await context.edit("Failed to get your server's timezone.")
return
try:
if args[0].find("every ") == 0:
# at this point, let's assume args[0] contains relative time
# i.e. -sendat every 3 minutes
time_str = args[0][6:]
if time_str.find(":") != -1:
# then it should be absolute time
target = dateparser.parse(time_str, settings=settings).timestamp() % DAY_SECS
if target >= DAY_SECS - 6:
# 太接近午夜，小概率直接 sleep 过头，特殊处理
target = 0
mem[mem_id] = "|".join(args)
await sendmsg(context, chat, f"{args[0]} -> {target} sec after 00:00:00 UTC+0")
await context.edit(f"Registered: id {mem_id}. You can use this id to cancel the timer.")
last_sent = 0
while mem[mem_id] != "":
if time.time() % DAY_SECS < target:
# 时间没到
await asyncio.sleep(2)
continue
if time.time() % DAY_SECS >= target and time.time() - last_sent < DAY_SECS - 10:
# 时间过了，第二天的没到
await asyncio.sleep(2)
continue
if mem[mem_id] != "":
await sendmsg(context, chat, args[1])
last_sent = time.time()
mem[mem_id] = ""
return
sleep_time = time.time() - dateparser.parse(time_str, settings=settings).timestamp()
if sleep_time < 5:
await context.edit(f"Sleep time too short. Should be longer than 5 seconds. Got {sleep_time}")
return
mem[mem_id] = "|".join(args)
await context.edit(f"Registered: id {mem_id}. You can use this id to cancel the timer.")
while mem[mem_id] != "":
last_time = time.time()
while time.time() < last_time + sleep_time and mem[mem_id] != "":
await asyncio.sleep(2)
if mem[mem_id] != "":
await sendmsg(context, chat, args[1])
mem[mem_id] = ""
return
elif args[0].find("*") == 0:
times = int(args[0][1:].split(" ")[0])
rest = " ".join(args[0][1:].split(" ")[1:])
if rest.find(":") != -1:
# then it should be absolute time
target = dateparser.parse(rest, settings=settings).timestamp() % DAY_SECS
if target >= DAY_SECS - 6:
# 太接近午夜，小概率直接 sleep 过头，特殊处理
target = 0
count = 0
mem[mem_id] = "|".join(args)
await context.edit(f"Registered: id {mem_id}. You can use this id to cancel the timer.")
last_sent = 0
while count <= times and mem[mem_id] != "":
if time.time() % DAY_SECS < target:
# 时间没到
await asyncio.sleep(2)
continue
if time.time() % DAY_SECS >= target and time.time() - last_sent < DAY_SECS - 10:
# 时间过了，第二天的没到
await asyncio.sleep(2)
continue
if mem[mem_id] != "":
await sendmsg(context, chat, args[1])
count += 1
last_sent = time.time()
mem[mem_id] = ""
return
sleep_time = time.time() - dateparser.parse(rest, settings=settings).timestamp()
if sleep_time < 5:
await context.edit(f"Sleep time too short. Should be longer than 5 seconds. got {sleep_time}")
return
count = 0
mem[mem_id] = "|".join(args)
await context.edit(f"Registered: id {mem_id}. You can use this id to cancel the timer.")
while count <= times and mem[mem_id] != "":
last_time = time.time()
while time.time() < last_time + sleep_time and mem[mem_id] != "":
await asyncio.sleep(2)
if mem[mem_id] != "":
await sendmsg(context, chat, args[1])
count += 1
mem[mem_id] = ""
return
if args[0].find(":") == -1:
# relative time
dt = dateparser.parse(args[0])
delta = time.time() - dt.timestamp()
if delta < 3:
await context.edit("Target time before now.")
return
mem[mem_id] = "|".join(args)
await context.edit(f"Registered: id {mem_id}. You can use this id to cancel the timer.")
while dt.timestamp() + 2*delta > time.time() and mem[mem_id] != "":
await asyncio.sleep(2)
if mem[mem_id] != "":
await sendmsg(context, chat, args[1])
mem[mem_id] = ""
return
# absolute time
target_time = dateparser.parse(args[0], settings=settings).timestamp()
if target_time - time.time() < 3:
await context.edit("Target time before now.")
return
mem[mem_id] = "|".join(args)
await context.edit(f"Registered: id {mem_id}. You can use this id to cancel the timer.")
while target_time - time.time() > 0 and mem[mem_id] != "":
await asyncio.sleep(2)
if mem[mem_id] != "":
await sendmsg(context, chat, args[1])
mem[mem_id] = ""
except Exception as e:
await log(str(e))
await log(str(traceback.format_stack()))
return
def func_wrapper(*args, **kwargs):
try:
return func(*args, **kwargs)
except Exception as e:
exc_type, exc_obj, exc_tb = sys.exc_info()
erStr = ("%s ERROR - Pandora PySide2 Setup %s:\n\n%s" % (time.strftime("%d/%m/%y %X"), ''.join(traceback.format_stack()), traceback.format_exc()))
print erStr
QMessageBox.warning(QWidget(), "Pandora", erStr)
def report_exception(self, msg, notify_user=True, level='error',
error_frame=None):
"""
Report details of an exception to the user.
This should only be called within an except: block Details of the
exception are reported eg filename, line number and exception type.
Because stack trace information outside of py3status or it's modules is
not helpful in actually finding and fixing the error, we try to locate
the first place that the exception affected our code.
Alternatively if the error occurs in a module via a Py3 call that
catches and reports the error then we receive an error_frame and use
that as the source of the error.
NOTE: msg should not end in a '.' for consistency.
"""
# Get list of paths that our stack trace should be found in.
py3_paths = [os.path.dirname(__file__)]
user_paths = self.config.get('include_paths', [])
py3_paths += [os.path.abspath(path) + '/' for path in user_paths]
traceback = None
try:
# We need to make sure to delete tb even if things go wrong.
exc_type, exc_obj, tb = sys.exc_info()
stack = extract_tb(tb)
error_str = '{}: {}\n'.format(exc_type.__name__, exc_obj)
traceback = [error_str]
if error_frame:
# The error occurred in a py3status module so the traceback
# should be made to appear correct. We caught the exception
# but make it look as though we did not.
traceback += format_stack(error_frame, 1) + format_tb(tb)
filename = os.path.basename(error_frame.f_code.co_filename)
line_no = error_frame.f_lineno
else:
# This is a none module based error
traceback += format_tb(tb)
# Find first relevant trace in the stack.
# it should be in py3status or one of it's modules.
found = False
for item in reversed(stack):
filename = item[0]
for path in py3_paths:
if filename.startswith(path):
# Found a good trace
filename = os.path.basename(item[0])
line_no = item[1]
found = True
break
if found:
break
# all done! create our message.
msg = '{} ({}) {} line {}.'.format(
msg, exc_type.__name__, filename, line_no)
except:
# something went wrong report what we can.
msg = '{}.'.format(msg)
finally:
# delete tb!
del tb
# log the exception and notify user
self.py3_wrapper.log(msg, 'warning')
if traceback:
# if debug is not in the config then we are at an early stage of
# running py3status and logging is not yet available so output the
# error to STDERR so it can be seen
if 'debug' not in self.config:
print_stderr('\n'.join(traceback))
elif self.config.get('log_file'):
self.py3_wrapper.log(''.join(['Traceback\n'] + traceback))
if notify_user:
self.py3_wrapper.notify_user(msg, level=level)
def print_trace(msg):
print(msg)
for line in traceback.format_stack():
print line.strip()
print("\n\n")
def nlog(self, var, l=None, v=True):
""" new logging, varname and content separate """
if (not v or not self.mainswitch):
return
### traceback check relevant line and match
tracelines = traceback.format_stack()
self.f.write('trace_lnr '+str(self.tr_lnr)+"\n")
s = tracelines[self.tr_lnr]
self.f.write(str("\n".join(tracelines)))
self.f.write("s: "+str(s))
m = self.expr.match( s )
if not m:
line = "dlog:err eval strack expr # "
line += var + "\n"
self.f.write(line)
return
### check which module calls and if logging should be done
fn = m.group(1)
basef = os.path.splitext(fn)[0]
if basef not in self.modules_tolog: return
### variable check
out = ''
try:
if type(var) == type(u''):
out += var.encode('utf8')
out += " - (dlog:to UTF8)"
elif type(var) == type(''):
out += var
out += " - (dlog:string)"
else:
try:
pp = PrettyPrinter()
out += pp.pprint( var )
except:
out += str(var)
except:
out += " dlog:exception "
# prefix with label if given
if l:
out = l +': \t'+out
method = m.group(2)
mth = method.split(" ")
lnr = mth[1][:-1]
mout = mth[3]
tstamp = strftime("%H:%M:%S",localtime())
llen1 = 9+len(fn) #
ltab1 = (6-int( llen1/8+2 ))
# build log line
line1 = "\n%s %s %s %s: %s" %(
tstamp,
fn,
"\t"*ltab1,
lnr,
mout,
)
# tab calculation
llen = len(lnr+mout)+2+ llen1+ 8*(ltab1-1)
ltab =(10-int( llen/8 ))
# for long texts
out_len = len(out)
if out_len < 100:
line1 += "\t"*ltab
line = line1+out
elif out_len <200:
line = "%s\n%s" %(line1, out)
else:
line = "%s\n%s" %(line1, out)
line += "\n"+"_"*90
### WRITE TO FILE
self.f.write( line )
def _TryEndModal(self, value):
if not self.isModal(
): # in some rare cases (including spammy AutoHotkey, looks like), this can be fired before the dialog can clean itself up
return False
if not self._ReadyToClose(value):
return False
if value == QW.QDialog.Rejected:
if not self._CanCancel():
return False
self.SetCancelled(True)
if value == QW.QDialog.Accepted:
if not self._CanOK():
return False
self._SaveOKPosition()
self.CleanBeforeDestroy()
try:
self.done(value)
except Exception as e:
HydrusData.ShowText(
'This dialog seems to have been unable to close for some reason. I am printing the stack to the log. The dialog may have already closed, or may attempt to close now. Please inform hydrus dev of this situation. I recommend you restart the client if you can. If the UI is locked, you will have to kill it via task manager.'
)
HydrusData.PrintException(e)
import traceback
HydrusData.DebugPrint(''.join(traceback.format_stack()))
try:
self.close()
except:
HydrusData.ShowText('The dialog would not close on command.')
try:
self.deleteLater()
except:
HydrusData.ShowText('The dialog would not destroy on command.')
return True
def __call__(self, *args, **kwargs):
stacktrace = "".join(traceback.format_stack())
LOG.error(_LE('No db access allowed in jacket-controller: %s'),
stacktrace)
raise exception.DBNotAllowed('jacket-controller')
def _lazy_call(callable):
if is_initialized():
callable()
else:
# Don't store the actual traceback to avoid memory cycle
_queued_calls.append((callable, traceback.format_stack()))
def _write_integrated_tool_panel_config_file(self):
"""
Write the current in-memory version of the integrated_tool_panel.xml file to disk. Since Galaxy administrators
use this file to manage the tool panel, we'll not use xml_to_string() since it doesn't write XML quite right.
"""
destination = os.path.abspath(self._integrated_tool_panel_config)
tracking_directory = self._integrated_tool_panel_tracking_directory
if tracking_directory:
if not os.path.exists(tracking_directory):
os.makedirs(tracking_directory)
name = "integrated_tool_panel_%.10f.xml" % time.time()
filename = os.path.join(tracking_directory, name)
else:
filename = destination
template = string.Template("""<?xml version="1.0"?>
<toolbox>
<!--
$INTEGRATED_TOOL_PANEL_DESCRIPTION
-->
$INTEGRATED_TOOL_PANEL
</toolbox>
""")
integrated_tool_panel = []
for key, item_type, item in self._integrated_tool_panel.panel_items_iter(
):
if item:
if item_type == panel_item_types.TOOL:
integrated_tool_panel.append(' <tool id="%s" />\n' %
item.id)
elif item_type == panel_item_types.WORKFLOW:
integrated_tool_panel.append(' <workflow id="%s" />\n' %
item.id)
elif item_type == panel_item_types.LABEL:
label_id = item.id or ''
label_text = item.text or ''
label_version = item.version or ''
integrated_tool_panel.append(
' <label id="%s" text="%s" version="%s" />\n' %
(label_id, label_text, label_version))
elif item_type == panel_item_types.SECTION:
section_id = item.id or ''
section_name = item.name or ''
section_version = item.version or ''
integrated_tool_panel.append(
' <section id="%s" name="%s" version="%s">\n' %
(escape(section_id), escape(section_name),
section_version))
for section_key, section_item_type, section_item in item.panel_items_iter(
):
if section_item_type == panel_item_types.TOOL:
if section_item:
integrated_tool_panel.append(
' <tool id="%s" />\n' %
section_item.id)
elif section_item_type == panel_item_types.WORKFLOW:
if section_item:
integrated_tool_panel.append(
' <workflow id="%s" />\n' %
section_item.id)
elif section_item_type == panel_item_types.LABEL:
if section_item:
label_id = section_item.id or ''
label_text = section_item.text or ''
label_version = section_item.version or ''
integrated_tool_panel.append(
' <label id="%s" text="%s" version="%s" />\n'
% (label_id, label_text, label_version))
integrated_tool_panel.append(' </section>\n')
tool_panel_description = '\n '.join(
[l for l in INTEGRATED_TOOL_PANEL_DESCRIPTION.split("\n") if l])
tp_string = template.substitute(
INTEGRATED_TOOL_PANEL_DESCRIPTION=tool_panel_description,
INTEGRATED_TOOL_PANEL='\n'.join(integrated_tool_panel))
with RenamedTemporaryFile(filename, mode='w') as f:
f.write(tp_string)
if tracking_directory:
with open(filename + ".stack", "w") as f:
f.write(''.join(traceback.format_stack()))
shutil.copy(filename, filename + ".copy")
shutil.move(filename + ".copy", destination)
try:
os.chmod(destination, 0o644)
except OSError:
# That can happen if multiple threads are simultaneously moving/chmod'ing this file
# Should be harmless, though this race condition should be avoided.
pass
def update_history(
self,
status_name,
size,
task=None,
tmp_status=None,
fault=None,
deploy_fault_message=None,
deploy_fault_trace=None,
first_update=False):
"""
Given the status name and size, look up the previous history object
If nothing has changed: return (False, last_history)
else: end date previous history object, start new history object.
return (True, new_history)
"""
# FIXME: Move this call so that it happens inside InstanceStatusHistory to avoid circ.dep.
from core.models import InstanceStatusHistory
import traceback
# 1. Get status name
status_name = _get_status_name_for_provider(
self.source.provider,
status_name,
task,
tmp_status)
activity = self.esh_activity()
status = self.esh_status()
extra = InstanceStatusHistory._build_extra(
status_name=status_name,
fault=fault,
deploy_fault_message=deploy_fault_message,
deploy_fault_trace=deploy_fault_trace)
# 2. Get the last history (or Build a new one if no other exists)
has_history = self.instancestatushistory_set.all().count()
if not has_history:
last_history = InstanceStatusHistory.create_history(
status_name, self, size,
start_date=self.start_date,
activity=activity,
extra=extra)
last_history.save()
logger.debug("STATUSUPDATE - FIRST - Instance:%s Old Status: %s - %s New\
Status: %s Tmp Status: %s" % (self.provider_alias,
status,
activity,
status_name,
tmp_status))
logger.debug("STATUSUPDATE - Traceback: %s"
% traceback.format_stack())
last_history = self.get_last_history()
# 2. Size and name must match to continue using last history
if last_history.status.name == status_name \
and last_history.size.id == size.id:
# logger.info("status_name matches last history:%s " %
# last_history.status.name)
return (False, last_history)
logger.debug("STATUSUPDATE - Instance:%s Old Status: %s - %s New Status: %s\
Tmp Status: %s" % (self.provider_alias,
status,
activity,
status_name,
tmp_status))
logger.debug("STATUSUPDATE - Traceback: %s" % traceback.format_stack())
# 3. ASSERT: A new history item is required due to a State or Size
# Change
now_time = timezone.now()
try:
new_history = InstanceStatusHistory.transaction(
status_name, activity, self, size,
extra=extra,
start_time=now_time,
last_history=last_history)
return (True, new_history)
except ValueError:
logger.exception("Bad transaction")
return (False, last_history)
def stack_trace() -> str:
import traceback
return "".join(traceback.format_stack())
