def main(): parser = argparse.ArgumentParser() parser.add_argument('--testnet', action='store_true') args = parser.parse_args() if args.testnet: d = Daemon(port=17766, cookie_dir='~/.groestlcoin/testnet3') else: d = Daemon(port=1441, cookie_dir='~/.groestlcoin') txids, = d.request('getrawmempool', [[False]]) txids = list(map(lambda a: [a], txids)) entries = d.request('getmempoolentry', txids) entries = [{'fee': e['fee'] * 1e8, 'vsize': e['vsize']} for e in entries] for e in entries: e['rate'] = e['fee'] / e['vsize'] # sat/vbyte entries.sort(key=lambda e: e['rate'], reverse=True) vsize = np.array([e['vsize'] for e in entries]).cumsum() rate = np.array([e['rate'] for e in entries]) plt.semilogy(vsize / 1e6, rate, '-') plt.xlabel('Mempool size (MB)') plt.ylabel('Fee rate (sat/vbyte)') plt.title('{} transactions'.format(len(entries))) plt.grid() plt.show()
def load(cfg): if os.geteuid() !=0: print '>> Please run this service as root.' os._exit(1) if len(sys.argv) == 2: if 'start' == sys.argv[1]: dns = TCPDNS(cfg) dns.start() elif 'stop' == sys.argv[1]: dns = Daemon() dns.stop() elif 'restart' == sys.argv[1]: dns = TCPDNS(cfg) dns.restart() elif 'censor' == sys.argv[1]: dns = UDPDNS(cfg) dns.start() else: print "Unknown command" sys.exit(2) sys.exit(0) else: dns = Daemon() tmp = dns.getstate() print "usage: %s start|stop|restart" % sys.argv[0] print "special usage: %s double-recv" % sys.argv[0] print '-------------------------------------' if tmp: print 'The daemon is running' else: print 'The daemon is stopped' sys.exit(2)
def main(): parser = ap.ArgumentParser() parser.add_argument('-d', '--daemon', action='store_true', help='run in daemon mode') parser.add_argument('-c', '--config', metavar='PATH', type=str) parser.add_argument('-s', '--server-ip', metavar='IP', type=str) parser.add_argument('-p', '--server-port', metavar='PORT', type=int) parser.add_argument('--neighbor-list', metavar='PATH', type=str) parser.add_argument('--repository', metavar='PATH', type=str) args = parser.parse_args() if args.daemon: raise NotImplementedError() cfg = DaemonConfig() if args.config: path = args.config with open(path, 'r') as fp: cfg.__dict__ = json.load(fp) if args.server_ip: cfg.set_ip(args.server_ip) if args.server_port: cfg.set_port(args.server_port) if args.neighbor_list: cfg.set_neig(args.neighbor_list) if args.repository: cfg.set_repo(args.repository) daemon = Daemon(cfg) daemon()
def main(): Daemon(pidfile=os.path.join(os.path.dirname(RRD_PATH), "log/data.pid")).daemon() if os.path.exists(RRD_PATH): datacollect() else: CreateRRD().create() datacollect()
def main(): args = parse_args() db.connectDatabase(process_path(args.db)) if args.daemon: pidfile = process_path(args.daemon) logfile = process_path(args.log) daemon = Daemon(run=app_run, pidfile=pidfile, stderr=logfile) daemon.start() else: app_run(debug=args.debug)
def resmond(): global program_name program_name = os.path.split(sys.argv[0])[1] config_filename = parsing_args() profile = load_config(config_filename) if len(profile.resources) == 0: print_warn( "No resource specified in profile '{}', process is stopped!". format(profile.name)) sys.exit(0) Daemon(profile).start()
def daemonize(self): if self.runAsDaemon(): try: from daemon import Daemon self.daemon = Daemon(self.options.pid_file) self.daemon.daemonize() except SystemExit: raise except: self.log.critical(traceback.format_exc())
def main(): """Handles arguments and starts the daemon.""" args = parser.parse_args() handle_exit_args(args) setup_logging(args.verbose, args.print_mode) python_version = sys.version_info check_python_version(python_version) daemon = Daemon(python_version.major) daemon.start() daemon.close()
def bot(): if not check_num_args(2): return # make daemon inst daemon = Daemon() # start, stop or restart if sys.argv[1] == "start": daemon.start() elif sys.argv[1] == "stop": daemon.stop() elif sys.argv[1] == "restart": daemon.restart()
def bot(): if not check_num_args(2): return # load config config = Config.load_config() # make daemon inst daemon = Daemon(config["pid_path"], config["log_path"]) # start, stop or restart if sys.argv[1] == "start": daemon.start() elif sys.argv[1] == "stop": daemon.stop() elif sys.argv[1] == "restart": daemon.restart()
def run(self, args): if not "dcmd" in args: print("No command specified") return 1 if args.dcmd == Cmd.start: # This is handled a little differently to other commands # since it's not communicating with the daemon - instead # this process will be the daemon return Daemon().run() if args.dcmd == Cmd.stop: ret = self.send({ "cmd": ArchitectDaemonDaemon.cmd_name, "daemon-cmd": Cmd.stop.name, }) return not "error" in ret print("Unknown command {0}".format(args.dcmd)) return 1
def run(self): daemon = Daemon() # draw gui panel self.data_loader.on_reset() while True: infer = daemon.loop() if infer: # clear gui panel self.data_loader.on_reset() time.sleep(0.5) # draw input image self.data_loader.on_input_data_loaded(infer[2]) time.sleep(0.5) # draw feature map images self.data_loader.on_conv_data_loaded(daemon.fmap_dir) time.sleep(0.5) # indicate inference result self.data_loader.on_output_data_loaded(infer[0], infer[1]) daemon.complete() time.sleep(0.1)
def test_19_daemon_updateDetails(self): client = self.app.test_client() rest_data = { "account_id": 1, "car_id": 1, "pickup_time": datetime.utcnow().strftime("%Y-%m-%d %H:%M"), "hours": 12 } resp = client.post("/api/booking", data=rest_data) data = self.getApiResponseData(resp) req_data = { "username": "******", "password": "******", "state": "in-use", "id": 1 } daemon = Daemon() with self.app.app_context(): resp = daemon._updateDetails(req_data) self.assertEqual(resp["rc"], 0) self.assertEqual(resp["account"]["id"], 1) with open("zhou.pickle", "rb") as f: encodings = pickle.loads(f.read()) req_data = { "encodings": encodings, "state": "returned", "id": 1, "location": "Blackburn", "latitude": -37.821106, "longitude": 145.149885 } with self.app.app_context(): resp = daemon._updateDetails(req_data) self.assertEqual(resp["rc"], 0) self.assertEqual(resp["account"]["id"], 1)
self.assertEqual(self.factory.guess_icon(""), self.iconurl + "text-x-generic-template.png") def test_get(self): self.assertEqual(self.factory.get_icon("image-x-generic"), self.iconurl + "image-x-generic.png") self.assertEqual(self.factory.get_icon("doesntexists"), None) class ConfigurationTestCase(unittest.TestCase): def run_test(self): configuration.test() class AutostartTestCase(unittest.TestCase): def run_test(self): from lanshark import autostart autostart.test() class SendfileTestCase(unittest.TestCase): def run_test(self): from lanshark import sendfile sendfile.test() if __name__ == "__main__": from daemon import Daemon try: daemon = Daemon() daemon.start() unittest.main() finally: os.rmdir(config.SHARE_PATH)
#!/usr/bin/python3 import json import os import re from bot import Bot from daemon import Daemon json_file = open("configs/config.json") json_info = json.load(json_file) logger = None b = Bot(logger) d = Daemon() streamer_list = [] # def print_status(streamer): # if b.is_online(streamer): # print("== " + streamer + " is online ==") # else: # print(streamer + " is offline") def print_recording(): command = os.popen('ps -aux | grep chaturbate').read() output_list = command.split() recording_list = [] for output in output_list: if "chaturbate.com" in output: recording_list.append(output) for streamer in recording_list: streamer = re.sub('https://chaturbate.com/', '', streamer)
print '-' * 80 print message print sock.sendall(message) time.sleep(delay) class Daemon(Daemon): def run(self): # Or simply merge your code with MyDaemon. client = Client() client.run() if __name__ == "__main__": daemon = Daemon('/tmp/poller-daemon.pid') if len(sys.argv) == 2: if 'start' == sys.argv[1]: daemon.start() elif 'stop' == sys.argv[1]: daemon.stop() elif 'restart' == sys.argv[1]: daemon.restart() else: print "Unknown command" sys.exit(2) sys.exit(0) else: print "usage: %s start|stop|restart" % sys.argv[0] sys.exit(2)
def main(): # pragma: no cover """ main method """ usage = [ sys.argv[0] + " [option] (--start|--stop) <form_definition.json>", " " + sys.argv[0] + " --generate-pw", ] parser = optparse.OptionParser(version="%%VERSION%%") parser.set_usage('\n'.join(usage)) parser.add_option("-g", "--generate-pw", dest="generate_pw", action="store_true", default=False, help="Generate password") parser.add_option("-p", "--port", dest="port", action="store", type="int", default=8081, help="Port to listen on (default=8081)") parser.add_option("-f", "--foreground", dest="foreground", action="store_true", default=False, help="Run in foreground (debugging)") parser.add_option("-r", "--reload", dest="reload", action="store_true", default=False, help="Reload form config on every request (DEV)") parser.add_option("--pid-file", dest="pid_file", action="store", default=None, help="Pid file") parser.add_option("--log-file", dest="log_file", action="store", default=None, help="Log file") parser.add_option("--start", dest="action_start", action="store_true", default=None, help="Start daemon") parser.add_option("--stop", dest="action_stop", action="store_true", default=None, help="Stop daemon") (options, args) = parser.parse_args() if options.generate_pw: # Generate a password for use in the `users` section import getpass plain_pw = getpass.getpass() if plain_pw != getpass.getpass('Repeat password: '******'\n') sys.exit(0) else: if not options.action_stop and len(args) < 1: parser.error("Insufficient number of arguments") if not options.action_stop and not options.action_start: options.action_start = True # If a form configuration was specified, change to that dir so we can # find the job scripts and such. if args: path = os.path.dirname(args[0]) if path: os.chdir(path) args[0] = os.path.basename(args[0]) daemon = Daemon(options.pid_file, options.log_file, foreground=options.foreground) log = logging.getLogger('MAIN') try: if options.action_start: cache = not options.reload scriptform_instance = ScriptForm(args[0], cache=cache) daemon.register_shutdown_callback(scriptform_instance.shutdown) daemon.start() scriptform_instance.run(listen_port=options.port) elif options.action_stop: daemon.stop() sys.exit(0) except socket.error as err: log.exception(err) sys.stderr.write("Cannot bind to port {0}: {1}\n".format( options.port, str(err))) sys.exit(2) except Exception as err: log.exception(err) raise
print "sending message\n" print '-' * 80 print message print sock.sendall(message) time.sleep(delay) # Daemonize all the things! class Daemon(Daemon): def run(self): client = Client() client.run() if __name__ == "__main__": # Name the pid file something useful daemon = Daemon('/tmp/graphite-client.pid') if len(sys.argv) == 2: # Start daemon if 'start' == sys.argv[1]: daemon.start() # Stop daemon elif 'stop' == sys.argv[1]: daemon.stop() # Restart daemon elif 'restart' == sys.argv[1]: daemon.restart() else: print "Unknown command" sys.exit(2) sys.exit(0) else:
# make it sequential for rename or operation on directory http_request(host, request) else: pool.spawn_n(http_request, host, request) else: #pool.waitall() #time.sleep(.2) eventlet.sleep(.2) daemon = Daemon( user="******", group="detik", stdin="/dev/null", stdout="/var/log/webio/webio-replicate-mata.log", stderr="/var/log/webio/webio-replicate-mata.err", pidfile="/var/log/webio/webio-replicate-mata.pid", port="20203", rootdir=root_dir, readonly=False, ) hosts = {} reject_urls = {} accept_urls = {} if __name__ == "__main__": if daemon.service(): signal.signal(signal.SIGABRT, clean_exit) signal.signal(signal.SIGTERM, clean_exit) signal.signal(signal.SIGQUIT, clean_exit) signal.signal(signal.SIGINT, clean_exit)
'exclude': exc_dirs, 'qtt': qtt, 'mqi': mqi, 'triggermod': triggers } return watch_sections, module_sections mod_instances = {} # instances of module object per section daemon = Daemon( user="******", group="root", stdin="/dev/null", stdout="/var/log/insync/insync.log", stderr="/var/log/insync/insync.err", pidfile="/var/log/insync/insync.pid", conf="./insync.conf", workers=str(max_workers_default), ) if __name__ == "__main__": signal.signal(signal.SIGABRT, clean_exit) signal.signal(signal.SIGTERM, clean_exit) signal.signal(signal.SIGQUIT, clean_exit) signal.signal(signal.SIGINT, clean_exit) watch_sections, module_sections = read_config(daemon.options.conf) if daemon.service(): if not watch_sections: sys.exit()
#!/usr/bin/env python import sys, time from daemon import Daemon if __name__ == "__main__": daemon = Daemon('/tmp/daemon-example.pid', '/tmp/daemon-read.txt', '/tmp/daemon-write.txt') if len(sys.argv) == 2: if 'start' == sys.argv[1]: daemon.start() elif 'stop' == sys.argv[1]: daemon.stop() elif 'restart' == sys.argv[1]: daemon.restart() else: print "Unknown command" sys.exit(2) sys.exit(0) else: print "usage: %s start|stop|restart" % sys.argv[0] sys.exit(2)
def run(self): self.dashboard_ip = None if settings.DASHBOARD_IP_ENV is not None: self.dashboard_ip = os.environ.get(settings.DASHBOARD_IP_ENV) daemon = Daemon(settings.DASHBOARD_TOKEN, settings.OUTPUT_DIR, settings.SCRIPTS_DIR, settings.SPEED, settings.MODELS) jobs = [] max_jobs = settings.NUM_THREADS processes = [] decoded_processes = {} while True: # If there is no process or we have less processes if len(processes) == 0 or \ len(processes) < len(self.alive_jobs(jobs)): new_processes = \ daemon.get_processes_to_decode( self.get_url(settings.DECODE_URLS['PROCESS_LIST'])) # Try to avoid race conditions processes = \ processes + \ [p for p in new_processes if p["id"] not in decoded_processes] if len(processes) == 0: daemon.delete_file_list( self.get_url(settings.DECODE_URLS['FILES_TO_DELETE']), settings.DECODE_URLS['UPDATE']) time.sleep(5) continue # We have nothing to do, kill zombies if len(self.alive_jobs(jobs)) == 0: while multiprocessing.active_children(): time.sleep(1) if len(self.alive_jobs(jobs)) < max_jobs: process = processes[0] decoded_processes[process["id"]] = True processes = processes[1:] p = multiprocessing.Process( target=daemon.decode_process, args=(process, self.get_url(settings.DECODE_URLS['DOWNLOAD']), self.get_url(settings.DECODE_URLS['UPDATE_PROCESS']), self.get_url(settings.DECODE_URLS['UPLOAD']), self.get_url(settings.DECODE_URLS['GET_FILE']))) p.daemon = True jobs.append(p) p.start() else: # We are full, kill zombies (join terminated processes) while multiprocessing.active_children(): time.sleep(1) daemon.delete_file_list( self.get_url(settings.DECODE_URLS['FILES_TO_DELETE']), settings.DECODE_URLS['UPDATE'])
'qtt': qtt, 'mqi': mqi, 'mw': mw, 'triggermod': triggers } return watch_sections, module_sections mod_instances = {} # instances of module object per section daemon = Daemon( user="******", group="detik", stdin="/dev/null", stdout="/var/log/insync/insync.log", stderr="/var/log/insync/insync.err", pidfile="/var/log/insync/insync.pid", conf="./insync.conf", ) if __name__ == "__main__": if daemon.service(): signal.signal(signal.SIGABRT, clean_exit) signal.signal(signal.SIGTERM, clean_exit) signal.signal(signal.SIGQUIT, clean_exit) signal.signal(signal.SIGINT, clean_exit) setproctitle.setproctitle(sys.argv[0]) os.umask(022) os.chdir('/opt/python/app')
desc = "OK" log_request(env.get('REMOTE_ADDR'), \ time.strftime("%d/%m/%Y %H:%M:%S",time.localtime()), \ method, request.path, request.contentlen, desc, time.time() - start_time) return response.data else: start_response('404 Not Found', [('Content-Type', 'text/plain')]) return ['Method is not Implemented !!\r\n'] daemon = Daemon( user="******", group="detik", stdin="/dev/null", stdout="/var/log/webio/webio.log", stderr="/var/log/webio/webio.err", pidfile="/var/log/webio/webio.pid", port="20202", rootdir=root_dir, ) if __name__ == "__main__": if daemon.service(): setproctitle.setproctitle(sys.argv[0]) os.umask(022) port = 20202 if not daemon.options.port.isdigit() else int( daemon.options.port) root_dir = root_dir if root_dir == daemon.options.rootdir else daemon.options.rootdir sys.stdout.write("Using port: %s and root directory: %s\n" % (port, root_dir)) sys.stdout.flush()
tornado.ioloop.IOLoop.instance().start() def main_reload(): if not os.path.exists(options.png_buffer): os.makedirs(options.png_buffer) http_server = tornado.httpserver.HTTPServer(Application()) http_server.listen(options.port) loop = tornado.ioloop.IOLoop.instance() tornado.autoreload.start(loop) loop.start() if __name__ == "__main__": if options.daemon: if not os.path.exists(os.path.dirname(options.pid_file)): os.makedirs(os.path.dirname(options.pid_file)) if not os.path.exists(os.path.dirname(options.log_file)): os.makedirs(so.path.dirname(options.log_file)) d = Daemon(pidfile=options.pid_file, stdout=options.log_file, stderr=options.log_file, chroot=options.root_dir) d.daemon() if options.reload: main_reload() else: main()
import threading import ATRHandler import utils from atr_cmd import AtrCmd from daemon import Daemon if __name__ == '__main__': utils.get_client_id() # creates necessary config before launch server = Daemon(('127.0.0.1', 1234), ATRHandler.ATRHandler) threading.Thread(target=server.serve_forever).start() AtrCmd().cmdloop_with_keyboard_interrupt()
import os.path BASE = os.path.dirname(__file__) import logging logging.basicConfig(level=logging.DEBUG) checker = logging.getLogger("checker") checker_handler = logging.FileHandler(os.path.join(BASE, "checker.log")) checker_handler.setFormatter( logging.Formatter('%(asctime)s %(levelname)s %(message)s')) checker_handler.setLevel(logging.INFO) checker.addHandler(checker_handler) from tools import utcnow, send_controller_mail, find_plant_name from daemon import Daemon if __name__ == "__main__": PLANT = find_plant_name() theDaemon = Daemon(pidfile) pid = theDaemon.status() if pid: checker.debug("PLANT %s is running at pid %s" % (PLANT, pid)) else: now = utcnow() hour = now.hour if 3 <= hour and hour < 14: txt = "PLANT %s is not running but should be" % PLANT checker.error(txt) send_controller_mail(txt) else: checker.debug("PLANT %s is not running, not a problem" % PLANT)
self.stopold() self._couples = newcouples i = 1 else: i = i + 1 time.sleep(self._option['sleep']) self.stopold() if __name__ == '__main__': if len(sys.argv) != 2: print "Usage : python couplemanager.py [start|stop|restart|run]" sys.exit(2) mode = sys.argv[1] runner = CoupleManager('../conf/cpmng.conf') adaemon = Daemon('cpmng', runner) if 'start' == mode: adaemon.start() elif 'stop' == mode: adaemon.stop() elif 'restart' == mode: adaemon.restart() elif 'run' == mode: adaemon.run() else: print "Unknown command" sys.exit(2) sys.exit(0)
def __init__(self): self.daemon = Daemon() super().__init__()
help='Specify alternate port [default: 8000]') parser.add_argument('-x', '--nodirlist', action='store_true', help='never show a directory listing') parser.add_argument( '-e', '--ext', action='append', help='allowed file extensions (without .) May occur more than once') args = parser.parse_args() dm = Daemon(user=args.user, rootdir=args.root_dir, pidfile=args.pid_file, force=args.force, logfile=args.log_file, name=args.name) if args.stop: dm.stop() else: server_address = (args.bind, args.port) RestrictedHTTPRequestHandler.protocol_version = "HTTP/1.0" RestrictedHTTPRequestHandler.logfie = lambda self, msg: dm.log( logging.INFO, msg) RestrictedHTTPRequestHandler.extensions = args.ext if args.ext is not None else None RestrictedHTTPRequestHandler.nodirlist = args.nodirlist with HTTPServer(server_address, RestrictedHTTPRequestHandler) as httpd: sa = httpd.socket.getsockname()