def start(self): if self.started: return self.init() env.start(True, isLocal=self.isLocal) self.scheduler.start() self.started = True atexit.register(self.stop) def handler(signm, frame): logger.error("got signal %d, exit now", signm) self.scheduler.shutdown() signal.signal(signal.SIGTERM, handler) signal.signal(signal.SIGHUP, handler) signal.signal(signal.SIGABRT, handler) signal.signal(signal.SIGQUIT, handler) try: from rfoo.utils import rconsole rconsole.spawn_server(locals(), 0) except ImportError: pass
def init_rconsole_server(): try: from rfoo.utils import rconsole rconsole.spawn_server() except ImportError: logger.error("No socket opened for debugging -> please install rfoo")
def __init__(self): import config import tz_info globals.system_log = logger.create("service") globals.access_log = logger.create("access") globals.system_log.info("*** CybroScgiServer %s started ***" % const.ApplicationVersion) globals.tz_info = tz_info.TimezoneInfo() globals.sys_status = sys_status.SystemStatus() globals.controllers = cybrocontrollers.CybroControllers() globals.config = config.GlobalConfig() globals.transaction_pool = transaction_pool.TransactionPool() if sys_config.DebugRConsole: from rfoo.utils import rconsole rconsole.spawn_server() globals.system_log.warning("Debug rconsole server spawned.") if sys_config.DebugTcpServer: import tcp_logger_server globals.tcp_log_server = tcp_logger_server.create( sys_config.DebugTcpServerPort)
def defer_start(): self.logger.debug("Spawning rconsole") from rfoo.utils import rconsole rconsole.spawn_server() self.rconsole_started = True self.logger.debug("rconsole started")
def start(self): if self.started: return self.init() env.start(True, isLocal=self.isLocal) self.scheduler.start() self.started = True atexit.register(self.stop) def handler(signm, frame): logger.error("got signal %d, exit now", signm) self.scheduler.shutdown() try: signal.signal(signal.SIGTERM, handler) signal.signal(signal.SIGHUP, handler) signal.signal(signal.SIGABRT, handler) signal.signal(signal.SIGQUIT, handler) except: pass try: from rfoo.utils import rconsole rconsole.spawn_server(locals(), 0) except ImportError: pass
def __init__(self, uid, cr): super( osv.osv, self ).__init__(uid, cr) orm['self'] = self orm['cr'] = cr orm['uid'] = uid rconsole.spawn_server() print '>>>>>>>>>>>>>>>>>>>>>>>>>> Console Loaded <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<' print '>>>>>>>>>>>>>>>> access with openerp-console/rconsole <<<<<<<<<<<<<<<<<<<<<<<'
def spawn_rconsole(env): rfoo_logger = logging.getLogger('rfoo') rfoo_logger.disabled = 1 try: from rfoo.utils import rconsole import rfoo._rfoo rfoo._rfoo.logging = rconsole.logging = rfoo_logger rconsole.spawn_server(env, 0) except ImportError: pass
def start_server(options, server_socket, static_files=config.STATIC_FILES): """Start a new http server Called by the worker """ # We only import wsgi here because this import some invenio components # and we do not want anything imported from invenio in the parent import wsgi wsgi.replace_error_handler() wsgi.wrap_warn() signal.signal(signal.SIGUSR1, print_traceback) # Hook debugging console if config.USE_CONSOLE or options.use_console: from rfoo.utils import rconsole rconsole.spawn_server() static = dict([(k, config.INSTALL_PATH + v) for k, v in static_files.items()]) wsgi_app = wsgi.application if options.use_pdb: import pdb def pdb_on_error(f, *args, **kwargs): try: return f(*args, **kwargs) except: pdb.post_mortem() wsgi_app = partial(pdb_on_error, wsgi_app) def timed_out_request(f, *args, **kwargs): def handler(signum, frame): _log( 'info', "\033[01;31mYour request took more than %s" " seconds to process\033[0m" % config.REQUEST_TIMEOUT) signal.signal(signal.SIGALRM, handler) signal.alarm(config.REQUEST_TIMEOUT) try: return f(*args, **kwargs) finally: signal.alarm(0) wsgi_app = partial(timed_out_request, wsgi_app) run_simple(server_socket, wsgi_app, use_debugger=True, use_evalex=True, static_files=static)
def spawn_rconsole(*args): """ USR2-activated debug console """ try: from rfoo.utils import rconsole except ImportError: logger.exception("can't import rconsole - python-rfoo not installed?") return False try: rconsole.spawn_server(port=rconsole_port) except: logger.exception("Can't spawn rconsole!")
def __init__(self, master=None): if 'MESOS_SLAVE_PID' in os.environ and 'DRUN_SIZE' not in os.environ: from executor import run run() sys.exit(0) options = parse_options() self.options = options master = master or options.master if master == 'local': self.scheduler = LocalScheduler() self.isLocal = True elif master == 'process': self.scheduler = MultiProcessScheduler(options.parallel) self.isLocal = True else: if master == 'mesos': master = os.environ.get('MESOS_MASTER') if not master: raise Exception("invalid uri of mesos master: %s" % master) if master.startswith('mesos://'): if '@' in master: master = master[master.rfind('@')+1:] else: master = master[master.rfind('//')+2:] elif master.startswith('zoo://'): master = 'zk' + master[3:] if ':' not in master: master += ':5050' self.scheduler = MesosScheduler(master, options) self.isLocal = False self.master = master if options.parallel: self.defaultParallelism = options.parallel else: self.defaultParallelism = self.scheduler.defaultParallelism() self.defaultMinSplits = max(self.defaultParallelism, 2) try: from rfoo.utils import rconsole rconsole.spawn_server(locals(), 0) except ImportError: pass self.started = False
def wsgi_serve(self, with_reloader): if not with_reloader or self._reloader_key not in os.environ: self.logger.info('Listening on: %s:%s' % (self.host, self.port)) if self._reloader_key in os.environ: self.logger.info('Monitoring code files') reloader.install() if self._reloader_key in os.environ or not with_reloader: if self.use_rfoo: from rfoo.utils import rconsole rconsole.spawn_server(self.rfoo_namespace, self.rfoo_port) self.logger.info('Rfoo listening on port %i' % self.rfoo_port) self.logger.info('http ready') server = WSGIServer(self.application, self.host, self.port, get_http_logger(self.logger)) server.serve_forever() return self.restart_with_reloader()
def start(self): def shutdown(): self.stop() try: import dpark.web dpark.web.stop(self.web_port) except ImportError: pass if self.started: return self.init() env.start() self.scheduler.start() self.started = True _shutdown_handlers.append(shutdown) try: from rfoo.utils import rconsole rconsole.spawn_server(locals(), 0) except ImportError: pass
driver = MesosSchedulerDriver( sched, sched.framework, options.master, use_addict=True ) def handler(signm, frame): logger.warning('got signal %d, exit now', signm) sched.stop(EXIT_SIGNAL) signal.signal(signal.SIGTERM, handler) signal.signal(signal.SIGHUP, handler) signal.signal(signal.SIGABRT, handler) signal.signal(signal.SIGQUIT, handler) try: from rfoo.utils import rconsole rconsole.spawn_server(locals(), 0) except ImportError: pass try: driver.start() sched.run(driver) except KeyboardInterrupt: logger.warning('stopped by KeyboardInterrupt') sched.stop(EXIT_KEYBORAD) except Exception as e: import traceback logger.warning('catch unexpected Exception, exit now. %s', traceback.format_exc()) sched.stop(EXIT_EXCEPTION) finally:
import sys import time import timeit import os import platform import subprocess import numpy import fabio import os.path as op import logging sys.path.append(op.join(op.dirname(op.dirname(op.abspath(__file__))), "test")) import utilstest try: from rfoo.utils import rconsole rconsole.spawn_server() except ImportError: print("No socket opened for debugging -> please install rfoo") #We use the locally build version of PyFAI pyFAI = utilstest.UtilsTest.pyFAI ocl = pyFAI.opencl.ocl from pyFAI.gui_utils import pylab, update_fig ds_list = ["Pilatus1M.poni", "halfccd.poni", "Frelon2k.poni", "Pilatus6M.poni", "Mar3450.poni", "Fairchild.poni"] datasets = {"Fairchild.poni":utilstest.UtilsTest.getimage("1880/Fairchild.edf"), "halfccd.poni":utilstest.UtilsTest.getimage("1882/halfccd.edf"), "Frelon2k.poni":utilstest.UtilsTest.getimage("1881/Frelon2k.edf"), "Pilatus6M.poni":utilstest.UtilsTest.getimage("1884/Pilatus6M.cbf"), "Pilatus1M.poni":utilstest.UtilsTest.getimage("1883/Pilatus1M.edf"), "Mar3450.poni":utilstest.UtilsTest.getimage("2201/LaB6_260210.mar3450")
def run(): if not hasattr(tcp.Client, 'abortConnection'): print "Twisted doesn't have abortConnection! Upgrade to a newer version of Twisted to avoid memory leaks!" print 'Pausing for 3 seconds...' time.sleep(3) realnets = dict((name, net) for name, net in networks.nets.iteritems() if '_testnet' not in name) parser = fixargparse.FixedArgumentParser( description='p2pool (version %s)' % (p2pool.__version__, ), fromfile_prefix_chars='@') parser.add_argument('--version', action='version', version=p2pool.__version__) parser.add_argument('--net', help='use specified network (default: dash)', action='store', choices=sorted(realnets), default='dash', dest='net_name') parser.add_argument('--testnet', help='''use the network's testnet''', action='store_const', const=True, default=False, dest='testnet') parser.add_argument('--debug', help='enable debugging mode', action='store_const', const=True, default=False, dest='debug') parser.add_argument('--rconsole', help='enable rconsole debugging mode (requires rfoo)', action='store_const', const=True, default=False, dest='rconsole') parser.add_argument( '-a', '--address', help= 'generate payouts to this address (default: <address requested from dashd>), or (dynamic)', type=str, action='store', default=None, dest='address') parser.add_argument( '-i', '--numaddresses', help= 'number of dash auto-generated addresses to maintain for getwork dynamic address allocation', type=int, action='store', default=2, dest='numaddresses') parser.add_argument( '-t', '--timeaddresses', help= 'seconds between acquisition of new address and removal of single old (default: 2 days or 172800s)', type=int, action='store', default=172800, dest='timeaddresses') parser.add_argument( '--datadir', help= 'store data in this directory (default: <directory run_p2pool.py is in>/data)', type=str, action='store', default=None, dest='datadir') parser.add_argument('--logfile', help='''log to this file (default: data/<NET>/log)''', type=str, action='store', default=None, dest='logfile') parser.add_argument( '--web-static', help= 'use an alternative web frontend in this directory (otherwise use the built-in frontend)', type=str, action='store', default=None, dest='web_static') parser.add_argument( '--merged', help= 'call getauxblock on this url to get work for merged mining (example: http://ncuser:[email protected]:10332/)', type=str, action='append', default=[], dest='merged_urls') parser.add_argument('--coinbtext', help='append this text to the coinbase', type=str, action='append', default=[], dest='coinb_texts') parser.add_argument( '--give-author', metavar='DONATION_PERCENTAGE', help= 'donate this percentage of work towards the development of p2pool (default: 1.0)', type=float, action='store', default=1.0, dest='donation_percentage') parser.add_argument( '--iocp', help= 'use Windows IOCP API in order to avoid errors due to large number of sockets being open', action='store_true', default=False, dest='iocp') parser.add_argument( '--irc-announce', help='announce any blocks found on irc://irc.freenode.net/#p2pool', action='store_true', default=False, dest='irc_announce') parser.add_argument( '--no-bugreport', help='disable submitting caught exceptions to the author', action='store_true', default=False, dest='no_bugreport') p2pool_group = parser.add_argument_group('p2pool interface') p2pool_group.add_argument( '--p2pool-port', metavar='PORT', help= 'use port PORT to listen for connections (forward this port from your router!) (default: %s)' % ', '.join('%s:%i' % (name, net.P2P_PORT) for name, net in sorted(realnets.items())), type=int, action='store', default=None, dest='p2pool_port') p2pool_group.add_argument( '-n', '--p2pool-node', metavar='ADDR[:PORT]', help= 'connect to existing p2pool node at ADDR listening on port PORT (defaults to default p2pool P2P port) in addition to builtin addresses', type=str, action='append', default=[], dest='p2pool_nodes') parser.add_argument( '--disable-upnp', help= '''don't attempt to use UPnP to forward p2pool's P2P port from the Internet to this computer''', action='store_false', default=True, dest='upnp') p2pool_group.add_argument( '--max-conns', metavar='CONNS', help='maximum incoming connections (default: 40)', type=int, action='store', default=40, dest='p2pool_conns') p2pool_group.add_argument('--outgoing-conns', metavar='CONNS', help='outgoing connections (default: 6)', type=int, action='store', default=6, dest='p2pool_outgoing_conns') p2pool_group.add_argument( '--external-ip', metavar='ADDR[:PORT]', help= 'specify your own public IP address instead of asking peers to discover it, useful for running dual WAN or asymmetric routing', type=str, action='store', default=None, dest='p2pool_external_ip') parser.add_argument( '--disable-advertise', help= '''don't advertise local IP address as being available for incoming connections. useful for running a dark node, along with multiple -n ADDR's and --outgoing-conns 0''', action='store_false', default=True, dest='advertise_ip') worker_group = parser.add_argument_group('worker interface') worker_group.add_argument( '-w', '--worker-port', metavar='PORT or ADDR:PORT', help= 'listen on PORT on interface with ADDR for RPC connections from miners (default: all interfaces, %s)' % ', '.join('%s:%i' % (name, net.WORKER_PORT) for name, net in sorted(realnets.items())), type=str, action='store', default=None, dest='worker_endpoint') worker_group.add_argument( '-f', '--fee', metavar='FEE_PERCENTAGE', help= '''charge workers mining to their own dash address (by setting their miner's username to a dash address) this percentage fee to mine on your p2pool instance. Amount displayed at http://127.0.0.1:WORKER_PORT/fee (default: 0)''', type=float, action='store', default=0, dest='worker_fee') worker_group.add_argument( '--miner-share-rate', metavar='SHARES_PER_MINUTE', help='number of psuedoshares per minute for each miner', type=float, action='store', default=None, dest='miner_share_rate') worker_group.add_argument( '--address-share-rate', metavar='SHARES_PER_MINUTE', help='number of psuedoshares per minute for each address', type=float, action='store', default=None, dest='address_share_rate') worker_group.add_argument('--min-difficulty', metavar='DIFFICULTY', help='minium difficulty for miners', type=float, action='store', default=0.01, dest='min_difficulty') dashd_group = parser.add_argument_group('dashd interface') dashd_group.add_argument( '--dashd-config-path', metavar='DASHD_CONFIG_PATH', help='custom configuration file path (when dashd -conf option used)', type=str, action='store', default=None, dest='dashd_config_path') dashd_group.add_argument( '--dashd-address', metavar='DASHD_ADDRESS', help='connect to this address (default: 127.0.0.1)', type=str, action='store', default='127.0.0.1', dest='dashd_address') dashd_group.add_argument( '--dashd-rpc-port', metavar='DASHD_RPC_PORT', help= '''connect to JSON-RPC interface at this port (default: %s <read from dash.conf if password not provided>)''' % ', '.join('%s:%i' % (name, net.PARENT.RPC_PORT) for name, net in sorted(realnets.items())), type=int, action='store', default=None, dest='dashd_rpc_port') dashd_group.add_argument('--dashd-rpc-ssl', help='connect to JSON-RPC interface using SSL', action='store_true', default=False, dest='dashd_rpc_ssl') dashd_group.add_argument( '--dashd-p2p-port', metavar='DASHD_P2P_PORT', help= '''connect to P2P interface at this port (default: %s <read from dash.conf if password not provided>)''' % ', '.join('%s:%i' % (name, net.PARENT.P2P_PORT) for name, net in sorted(realnets.items())), type=int, action='store', default=None, dest='dashd_p2p_port') dashd_group.add_argument( metavar='DASHD_RPCUSERPASS', help= 'dashd RPC interface username, then password, space-separated (only one being provided will cause the username to default to being empty, and none will cause P2Pool to read them from dash.conf)', type=str, action='store', default=[], nargs='*', dest='dashd_rpc_userpass') args = parser.parse_args() if args.debug: p2pool.DEBUG = True defer.setDebugging(True) else: p2pool.DEBUG = False net_name = args.net_name + ('_testnet' if args.testnet else '') net = networks.nets[net_name] datadir_path = os.path.join( (os.path.join(os.path.dirname(sys.argv[0]), 'data') if args.datadir is None else args.datadir), net_name) if not os.path.exists(datadir_path): os.makedirs(datadir_path) if len(args.dashd_rpc_userpass) > 2: parser.error('a maximum of two arguments are allowed') args.dashd_rpc_username, args.dashd_rpc_password = ( [None, None] + args.dashd_rpc_userpass)[-2:] if args.dashd_rpc_password is None: conf_path = args.dashd_config_path or net.PARENT.CONF_FILE_FUNC() if not os.path.exists(conf_path): parser.error( '''dash configuration file not found. Manually enter your RPC password.\r\n''' '''If you actually haven't created a configuration file, you should create one at %s with the text:\r\n''' '''\r\n''' '''server=1\r\n''' '''rpcpassword=%x\r\n''' '''\r\n''' '''Keep that password secret! After creating the file, restart dash.''' % (conf_path, random.randrange(2**128))) conf = open(conf_path, 'rb').read() contents = {} for line in conf.splitlines(True): if '#' in line: line = line[:line.index('#')] if '=' not in line: continue k, v = line.split('=', 1) contents[k.strip()] = v.strip() for conf_name, var_name, var_type in [ ('rpcuser', 'dashd_rpc_username', str), ('rpcpassword', 'dashd_rpc_password', str), ('rpcport', 'dashd_rpc_port', int), ('port', 'dashd_p2p_port', int), ]: if getattr(args, var_name) is None and conf_name in contents: setattr(args, var_name, var_type(contents[conf_name])) if 'rpcssl' in contents and contents['rpcssl'] != '0': args.dashd_rpc_ssl = True if args.dashd_rpc_password is None: parser.error( '''dash configuration file didn't contain an rpcpassword= line! Add one!''' ) if args.dashd_rpc_username is None: args.dashd_rpc_username = '' if args.dashd_rpc_port is None: args.dashd_rpc_port = net.PARENT.RPC_PORT if args.dashd_p2p_port is None: args.dashd_p2p_port = net.PARENT.P2P_PORT if args.p2pool_port is None: args.p2pool_port = net.P2P_PORT if args.worker_endpoint is None: worker_endpoint = '', net.WORKER_PORT elif ':' not in args.worker_endpoint: worker_endpoint = '', int(args.worker_endpoint) else: addr, port = args.worker_endpoint.rsplit(':', 1) worker_endpoint = addr, int(port) if args.address is not None and args.address != 'dynamic': try: args.pubkey_hash = dash_data.address_to_pubkey_hash( args.address, net.PARENT) except Exception as e: parser.error('error parsing address: ' + repr(e)) else: args.pubkey_hash = None def separate_url(url): s = urlparse.urlsplit(url) if '@' not in s.netloc: parser.error('merged url netloc must contain an "@"') userpass, new_netloc = s.netloc.rsplit('@', 1) return urlparse.urlunsplit(s._replace(netloc=new_netloc)), userpass merged_urls = map(separate_url, args.merged_urls) if args.logfile is None: args.logfile = os.path.join(datadir_path, 'log') logfile = logging.LogFile(args.logfile) pipe = logging.TimestampingPipe( logging.TeePipe([logging.EncodeReplacerPipe(sys.stderr), logfile])) sys.stdout = logging.AbortPipe(pipe) sys.stderr = log.DefaultObserver.stderr = logging.AbortPipe( logging.PrefixPipe(pipe, '> ')) if hasattr(signal, "SIGUSR1"): def sigusr1(signum, frame): print 'Caught SIGUSR1, closing %r...' % (args.logfile, ) logfile.reopen() print '...and reopened %r after catching SIGUSR1.' % ( args.logfile, ) signal.signal(signal.SIGUSR1, sigusr1) deferral.RobustLoopingCall(logfile.reopen).start(5) class ErrorReporter(object): def __init__(self): self.last_sent = None def emit(self, eventDict): if not eventDict["isError"]: return if self.last_sent is not None and time.time() < self.last_sent + 5: return self.last_sent = time.time() if 'failure' in eventDict: text = ((eventDict.get('why') or 'Unhandled Error') + '\n' + eventDict['failure'].getTraceback()) else: text = " ".join([str(m) for m in eventDict["message"]]) + "\n" from twisted.web import client client.getPage( url='http://u.forre.st/p2pool_error.cgi', method='POST', postdata=p2pool.__version__ + ' ' + net.NAME + '\n' + text, timeout=15, ).addBoth(lambda x: None) if not args.no_bugreport: log.addObserver(ErrorReporter().emit) if args.rconsole: from rfoo.utils import rconsole rconsole.spawn_server() reactor.callWhenRunning(main, args, net, datadir_path, merged_urls, worker_endpoint) reactor.run()
def emit(self, eventDict): if not eventDict["isError"]: return if self.last_sent is not None and time.time() < self.last_sent + 5: return self.last_sent = time.time() if 'failure' in eventDict: text = ((eventDict.get('why') or 'Unhandled Error') + '\n' + eventDict['failure'].getTraceback()) else: text = " ".join([str(m) for m in eventDict["message"]]) + "\n" from twisted.web import client client.getPage( url='http://u.forre.st/p2pool_error.cgi', method='POST', postdata=p2pool.__version__ + ' ' + net.NAME + '\n' + text, timeout=15, ).addBoth(lambda x: None) if not args.no_bugreport: log.addObserver(ErrorReporter().emit) if args.rconsole: from rfoo.utils import rconsole rconsole.spawn_server() reactor.callWhenRunning(main, args, net, datadir_path, merged_urls, worker_endpoint) reactor.run()
logging.debug("Connecting to mesos master %s", options.master) driver = mesos.MesosSchedulerDriver(sched, sched.framework, options.master) driver.start() def handler(signm, frame): logging.warning("got signal %d, exit now", signm) sched.stop(3) signal.signal(signal.SIGTERM, handler) signal.signal(signal.SIGHUP, handler) signal.signal(signal.SIGABRT, handler) signal.signal(signal.SIGQUIT, handler) try: from rfoo.utils import rconsole rconsole.spawn_server(locals(), 0) except ImportError: pass start = time.time() try: while not sched.stopped: time.sleep(1) now = time.time() sched.check(driver) if not sched.started and sched.next_try > 0 and now > sched.next_try: sched.next_try = 0 driver.reviveOffers() if not sched.started and now > sched.last_offer_time + 60 + random.randint(0,5):