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