def handle():
db = basing.Baser(name='kli-serving', temp=False)
klis = koming.Komer(db=db, schema=KLIRecord, subkey='klis.')
klis.rem(('kli-serving', ))
daemon = daemonocle.Daemon(pid_file='/tmp/klid.pid', )
daemon.do_action('stop')
def status(pidfile):
daemon = daemonocle.Daemon(
pidfile=pidfile,
)
try:
daemon.do_action('status')
except (daemonocle.exceptions.DaemonError, FileNotFoundError) as err:
print(err)
def main():
def cb_shutdown():
print('Daemon is stopping')
def main_loop():
app.run(host=args.host, port=args.port)
args = parse_args()
daemon = daemonocle.Daemon(worker=main_loop,
shutdown_callback=cb_shutdown,
pidfile='/tmp/gpioapi.pid')
daemon.do_action(args.command)
def daemon_controller():
if len(sys.argv) < 2:
usage()
elif sys.argv[1] in daemonocle.Daemon.list_actions():
config = ServerConfig(file_name="server", cli=False)
daemon = daemonocle.Daemon(detach=False,
worker=notification_daemon,
pidfile=config.server.pid_file)
daemon.do_action(sys.argv[1])
elif sys.argv[1] == "--generate-config":
config = ServerConfig(file_name="server")
else:
usage()
def main():
args = create_args()
config_logging(args)
if args.action != 'cli':
daemon = daemonocle.Daemon(
worker=bootstrap,
shutdown_callback=cb_shutdown,
pidfile=args.pid_file,
workdir='.'
)
daemon.do_action(args.action)
else:
bootstrap()
def __init__(self, logfile, name="TestDaemon", foreground=True):
threading.Thread.__init__(self, name=name)
self.foreground = foreground
self.logfile = logfile
self.daemon = daemonocle.Daemon(detach=False, pidfile="./fakepidfile")
self.keep_running = True
self.protector = MagicMock()
self.config = ObjectView({"foreground": self.foreground,
"logfile": self.logfile,
"host": "localhost",
"port": 12340,
"backend_host": "backend_host",
"backend_port": "backend_port",
"rules": []})
def start_proxy(config):
"""
Start the http proxy
:param config:
:return:
"""
protector = Protector(config.rules, config.whitelist)
protector_daemon = ProtectorDaemon(config=config, protector=protector)
daemon = daemonocle.Daemon(pidfile=config.pidfile,
detach=(not config.foreground),
shutdown_callback=shutdown,
worker=protector_daemon.run)
daemon.do_action(config.command)
def start(workdir, pidfile, user, group, detach, file, channel, nick, server, port, ipv6, username, password, trigger,
secret, logfile, loglevel):
if file is not None:
cf = configparser.ConfigParser()
try:
cf.read(file)
if server is None: server = 'default'
if server not in cf:
click.secho('Server %s not found in %s.' % (server, file), bold=True)
exit(1)
section = cf[server]
channel = section.get('Channel', channel)
nick = nick or section.get('Nick', nick)
server = section.get('Address', server)
port = section.getint("Port", port)
ipv6 = section.getboolean('IPv6', False)
username = username or section.get('Username', username)
password = password or section.get('Password', password)
except configparser.ParsingError as err:
click.echo(err)
exit(1)
if user is not None:
user = getpwnam(user).pw_uid
if group is not None:
group = getpwnam(group).pw_gid
daemon = daemonocle.Daemon(
workdir=workdir,
pidfile=pidfile,
detach=detach,
close_open_files=True,
uid=user,
gid=group,
)
if not (channel and server and nick):
if channel is None: click.secho('A channel name is required.', bold=True)
if server is None: click.secho('A server address is required.', bold=True)
if nick is None: click.secho('A nick is required.', bold=True)
exit(1)
click.echo('Connecting to server %s (%s) as %s...' % (server, port, nick))
app = App(channel, nick, server, port, ipv6, username, password, trigger, secret, logfile, loglevel)
daemon.worker = app.run
daemon.shutdown_callback = app.shutdown
try:
daemon.do_action('start')
except (daemonocle.exceptions.DaemonError, FileNotFoundError, PermissionError) as err:
print(err)
def __init__(self, debug=False):
dameon_worker = worker.DELLveWorker(config.get('http-port'))
if not os.path.exists(dameon_worker.workdir):
os.makedirs(dameon_worker.workdir)
dameon_config = {
'worker': dameon_worker.start,
'shutdown_callback': dameon_worker.stop,
'pidfile': dameon_worker.pidfile,
'workdir': dameon_worker.workdir,
'detach': debug == False,
}
self._daemon = daemon.Daemon(**dameon_config)
def main(argv=sys.argv):
parser = argparse.ArgumentParser()
parser.add_argument('-c', '--config', help='config file (default: %(default)s)', metavar='filename',
dest='config_file', default=DEFAULT_CONFIG_FILE)
subparsers = parser.add_subparsers(dest='action')
subparser_start = subparsers.add_parser('start')
subparser_start.add_argument('--no-daemon', action='store_true')
subparsers.add_parser('stop')
subparsers.add_parser('restart')
subparsers.add_parser('status')
args = parser.parse_args(argv[1:])
handler_stderr = logging.StreamHandler()
handler_stderr.setLevel(logging.INFO)
handler_stderr.setFormatter(BRIEF_LOG_FORMATTER)
logger = logging.getLogger('noipclient')
logger.setLevel(logging.DEBUG)
logger.addHandler(handler_stderr)
logger.debug("args: %s", args)
if args.action == 'start' and not os.path.exists(args.config_file):
if not prompt_yes_no("Config file %s not found. Create one now?" % args.config_file):
return
elif not Config.create(args.config_file):
return
config = Config.from_file(args.config_file)
handler_file = logging.FileHandler(config.log_file)
handler_file.setLevel(logging.DEBUG)
handler_file.setFormatter(VERBOSE_LOG_FORMATTER)
logger.addHandler(handler_file)
app = NoIpClient(config, logger)
if args.action == 'start' and args.no_daemon:
app.run()
else:
daemon = daemonocle.Daemon(
worker=app.run,
shutdown_callback=app.stop,
pidfile=config.pid_file,
)
daemon.do_action(args.action)
def start_proxy(config):
"""
Start the http proxy
:param config:
:return:
"""
cleanflux = Cleanflux(
config.backend_host, config.backend_port, config.backend_user,
config.backend_password, config.rules,
config.auto_retrieve_retention_policies, config.retention_policies,
config.aggregation_properties, config.counter_overflows,
config.max_nb_points_per_query, config.max_nb_points_per_series)
http_proxy_daemon = HttpDaemon(config=config, cleanflux=cleanflux)
daemon = daemonocle.Daemon(pidfile=config.pidfile,
detach=(not config.foreground),
shutdown_callback=shutdown,
worker=http_proxy_daemon.run)
daemon.do_action(config.command)
def run(self,
daemonize=False,
daemonize_stdout=None,
daemonize_stderr=None):
def is_null(val):
if val is None:
return True
return val.lower() in ("/dev/null", "null")
if not daemonize:
return self._run()
d = daemonocle.Daemon(
name="alwaysup/run_forever",
worker=self._run,
detach=True,
stdout_file=daemonize_stdout
if is_null(daemonize_stdout) else None,
stderr_file=daemonize_stderr
if is_null(daemonize_stderr) else None,
)
d.do_action("start")
def handle(args):
print(args)
hab = habbing.Habitat(name='kli', temp=False)
tock = 0.03125
host = '127.0.0.1'
port = args.port
klis = koming.Komer(db=hab.db, schema=KLIRecord, subkey='kli.')
klis.put((hab.pre, ), KLIRecord(
host=host,
port=port,
))
# doist = doing.Doist(tock=tock, real=True)
# print("client", host, port)
# client = clienting.Client(host=host, port=port, tymth=doist.tymen())
# clientDoer = clienting.ClientDoer(client=client)
# initDoer = InitDoer(client=client, tymth=doist.tymen())
#
# doist.doers = [clientDoer, initDoer]
# doist.do()
doist = doing.Doist(tock=tock, real=True)
server = serving.Server(host='127.0.0.1', port=5678)
serverDoer = serving.ServerDoer(server=server)
servingDoDoer = Serving(server=server, doers=doist.doers)
doist.extend([serverDoer, servingDoDoer])
daemon = daemonocle.Daemon(
worker=doist.do,
# update to use pidPath serving.getPIDPath()
pid_file='/tmp/klid.pid',
# detach=detach,
)
daemon.do_action('start')
def main(argv=None):
pid = os.path.join(appdirs.user_data_dir(), 'monitor.pid')
log = os.path.join(appdirs.user_log_dir(), 'monitor.log')
parser = argparse.ArgumentParser()
parser.add_argument('--detach', dest='detach', action='store_true')
parser.add_argument('--no-detach', dest='detach', action='store_false')
parser.add_argument('--pid', default=pid)
parser.add_argument('--log', default=log)
parser.set_defaults(detach=True)
subparsers = parser.add_subparsers(dest='subcommand')
subparsers.add_parser('start')
subparsers.add_parser('stop')
subparsers.add_parser('status')
subparsers.add_parser('restart')
parser.add_argument('--loglevel', default='ERROR', required=False)
if argv is None:
argv = parser.parse_args()
try:
os.mkdir(appdirs.user_log_dir())
except OSError as exc:
if exc.errno != errno.EEXIST:
raise exc
pass
# set debugging level
numeric_level = getattr(logging, argv.loglevel.upper(), None)
if not isinstance(numeric_level, int):
raise ValueError('Invalid log level: %s' % argv.loglevel)
# logging to root logger, why not?
logger = logging.getLogger()
logger.setLevel(numeric_level)
formatter = logging.Formatter('%(asctime)s [%(levelname)s] %(message)s')
rh = logging.handlers.TimedRotatingFileHandler(
argv.log,
when='midnight',
)
rh.setLevel(numeric_level)
formatter = logging.Formatter('%(asctime)s [%(levelname)s] %(message)s')
rh.setFormatter(formatter)
logger.addHandler(rh)
logging.info('Daemon is starting')
if len(sys.argv) == 1: # http://stackoverflow.com/a/4042861/1763984
parser.print_help()
sys.exit(1)
daemon = daemonocle.Daemon(
worker=check_loop,
workdir=os.getcwd(),
pidfile=argv.pid,
detach=argv.detach,
)
logging.info(argv.subcommand)
daemon.do_action(argv.subcommand)
def main():
# daemon mode is optional if OS is not windows and daemonocle is found
if os.name == 'nt':
daemonocle = None
else:
try:
import daemonocle
except ImportError:
daemonocle = None
daemon = None
# base parser
parser = argparse.ArgumentParser()
parser.add_argument('--config', default=CONFIG_FILENAME)
parser.add_argument('--logging',
dest='level',
choices=[
v for k, v in logging._levelToName.items()
if isinstance(k, int) and k != 0
])
subparsers = parser.add_subparsers()
# start and daemon related command
cmd = subparsers.add_parser('start')
cmd.add_argument('--debug', default=False, action='store_true')
cmd.set_defaults(cmd='start')
if daemonocle is not None:
cmd.add_argument('--foreground',
'-f',
default=False,
action='store_true')
cmd = subparsers.add_parser('stop')
cmd.set_defaults(cmd='stop')
cmd = subparsers.add_parser('restart')
cmd.set_defaults(cmd='restart')
cmd = subparsers.add_parser('stop')
cmd.set_defaults(cmd='stop')
cmd = subparsers.add_parser('status')
cmd.set_defaults(cmd='status')
# configuration setup
cmd = subparsers.add_parser('setup')
cmd.add_argument('--replace', default=False, action='store_true')
cmd.set_defaults(cmd='setup')
cmd = subparsers.add_parser('calculate')
cmd.set_defaults(cmd='calculate')
# parse
args = parser.parse_args()
# default command is start if not specify
if 'cmd' not in args:
args.cmd = 'start'
args.foreground = False
args.debug = False
# stop here if this ask for setup
if args.cmd == 'setup':
setup(args)
return
# load configuration
try:
cfg = load_config(args.config)
except Exception as e:
parser.error(e)
raise
# if daemonocle is found setup daemon mode
if daemonocle is not None:
try:
pidfile = Path(cfg['daemon']['pid'])
if not pidfile.is_absolute():
pidfile = (cfg['path']['base'] / pidfile)
except Exception as e:
parser.error(e)
raise
daemon = daemonocle.Daemon(
pidfile=str(pidfile),
close_open_files=True,
)
# execute command
if args.cmd == 'calculate':
setup_logging(cfg)
hash_pkg(args, cfg)
elif not execute(args, cfg, daemon):
parser.error('unable to create daemon')
access_url += ':' + str(config.settings['server']['http_port'])
access_url += '/'
print('Listening on', access_url)
print()
while True:
# print('main loop')
time.sleep(60)
# fixes for windows
if __name__ == "__main__":
main()
if 'Windows' != platform.system():
import daemonocle
def cb_shutdown(message, code):
logging.info('Daemon is stopping')
logging.debug(message)
if __name__ == '__main__':
daemon = daemonocle.Daemon(
worker=main,
shutdown_callback=cb_shutdown,
pidfile=os.path.join(config.runtime_dir, config.app_name + '.pid'),
)
if (len(sys.argv) > 1):
daemon.do_action(sys.argv[1])
import time
import daemonocle
def cb_shutdown(message, code):
logging.info('Daemon is stopping')
logging.debug(message)
def main():
logging.basicConfig(
filename=os.getcwd() + '/log/daemonocle_example.log',
level=logging.DEBUG,
format='%(asctime)s [%(levelname)s] %(message)s',
)
logging.info('Daemon is starting')
while True:
logging.debug('Still running')
time.sleep(10)
if __name__ == '__main__':
print(os.getcwd() + '/log/daemonocle_example.log')
daemon = daemonocle.Daemon(
worker=main,
# shutdown_callback=cb_shutdown,
pidfile=os.getcwd() + '/daemonocle_example.pid',
)
daemon.do_action(sys.argv[1])
t_ifstat.daemon = True
t_fping.daemon = True
t_ifstat.start()
t_fping.start()
def main():
config = ConfigParser.RawConfigParser()
config.read(config_path)
ifstat_count = config.get('ifstat', 'count')
fping_count = config.get('fping', 'count')
fping_ips = config.get('fping', 'ip').split(';')
start_workers()
# Wait indefinitely in main thread
while threading.active_count() > 0:
time.sleep(0.1)
if __name__ == '__main__':
#main()
daemon = daemonocle.Daemon(
worker=main,
pidfile='/var/run/runstats.pid',
)
daemon.do_action(sys.argv[1])
####################
# CONNESSIONE DB #
###################
###############
# PROGRAMMA #
###############
if __name__ == '__main__':
# Server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
#Server.settimeout(5.0)
# Host = socket.gethostname()
# WelcomeMsg = "220 " + Host + " ObjMail server ready\r\n"
# HeloMsg = "250 Hello "
# MailFromMsg = "250 Sender OK\r\n"
# RcptToMsg = "250 Recipient OK\r\n"
# DataMsg = "354 Start mail input; end with <CRLF>.<CRLF>\r\n"
# QuitMsg = "221 Goodbye\r\n"
# TooErrorMsg = "Troppi errori. Bye!\r\n"
#ServerOpen()
Servizio = daemonocle.Daemon(
worker=ServerStart,
shutdown_callback=ServerStop,
pidfile='/var/run/ObjMail.pid',
)
Servizio.do_action(sys.argv[1])
#Client.send(TooErrorMsg.encode())
#Server.close()
#self.logger.debug(message, code)
self.sched.stopScheduler()
if __name__ == '__main__':
myDaemonCmdList = ['start','stop','status','restart']
print(sys.argv)
myDaemonCmd = sys.argv[1]
myDaemonName = sys.argv[2]
if (len(sys.argv) < 3) or (myDaemonCmd not in myDaemonCmdList):
print('usage: <python executable>(3) {file} cmd <{cmd}> <daemon_name>'.format(file = os.path.basename(__file__), cmd = myDaemonCmdList))
sys.exit(-1)
daemon = daemonocle.Daemon()
myDaemon = DaemonP8(myDaemonName, daemon)
daemon.pidfile = myDaemon.myPidFile
daemon.detach = myDaemon.detach
daemon.worker = myDaemon.startDaemon
daemon.shutdwon_callback = myDaemon.stopDaemon
daemon.prog = myDaemon.prog_name
daemon.stop_timeout = myDaemon.stop_timeout
print('\n')
myDaemon.DaemonLogger.debug('executing {cmd} on daemon {daemon}'.format(cmd = sys.argv[1], daemon = sys.argv[2]))
daemon.do_action(sys.argv[1])
# remaining 2 columns as NaN to prevent multiple calculations
# of the same entry in reports
new_data = top_cpu.append([top_memory, top_io])
rearanged_new_data = new_data[columns]
rearanged_new_data.to_csv(f'{folder_path}/database.csv',
mode='a',
header=False,
index=False,
na_rep=np.nan)
# using sleep to prevent cases in which the script
# would perform slower than the time period set in configuration
time.sleep(cfg.main_X)
def main():
create_database()
if cfg.main_N == 0:
collect_data_default()
else:
collect_data_top_N(cfg.main_N)
if __name__ == '__main__':
daemon = daemonocle.Daemon(worker=main, pid_file="/tmp/main.pid")
try:
daemon.do_action(sys.argv[1])
except IndexError:
print('Please run the script with one of the arguments:'
'start/stop/restart/status, e.g. python3 main.py start')
import os
import sys
import time
import daemonocle
# This is your daemon. It sleeps, and then sleeps again.
def main():
while True:
print("------")
time.sleep(10)
if __name__ == '__main__':
daemon = daemonocle.Daemon(
worker=main,
pidfile=os.getcwd() + '/daemonocle_example.pid',
)
daemon.do_action(sys.argv[1])
def listen(command):
daemon = daemonocle.Daemon(worker=subscribe_topic, pidfile='listener.pid')
daemon.do_action(command)
def err_check_too_close(left_current):
return 20 - left_current >= 1.5
def err_check_too_far(left_current):
return left_current - 20 >= 2
def check_new_wall(left_current):
# Check if the current reading is a new wall, and repeats to be sure
return left_current - 20 >= left_corner_threshold and getLeftDistance(
) - 20 >= left_corner_threshold
def is_close(num_1, num_2, threshold):
return abs(num_1 - num_2) <= threshold
if __name__ == "__main__":
# print("Starting")
# path_loop_demo()
# path_loop_2()
daemon = daemonocle.Daemon(worker=path_loop_2,
pidfile='/var/run/daemonocle_example.pid')
if len(sys.argv) < 2:
print("\nadd start/stop/restart at the end of command\n")
else:
daemon.do_action(sys.argv[1])
