class TorrentClient(object):
def __init__(self, hostname=None, port=9090):
self.daemon = None
if not hostname:
self.daemon = Daemon(["transmission-daemon", "-f", "-p", str(port)])
self.daemon.start()
hostname = "localhost"
self._connection = TransmissionConnection(hostname, port)
self._session = self._connection.execute(Command("session-get"))
def __del__(self):
if self.daemon:
self.daemon.stop()
def add_torrent(self, auto=None, metadata=None, filename=None, file=None, url=None):
if auto:
if isinstance(auto, str):
if "://" in auto:
data = urllib2.urlopen(auto).read()
else:
data = open(auto, "r").read()
elif hasattr(auto, "read"):
data = auto.read()
elif hasattr(auto, "content"):
data = auto.content
else:
raise AttributeError()
else:
if metadata:
data = metadata
elif filename:
data = open(filename, "r").read()
elif url:
data = urllib2.urlopen(url).read()
elif file:
data = file.read()
data = base64.encodestring(data)
command = Command("torrent-add")
command["metainfo"] = data
command["paused"] = True
torrent = self._connection.execute(command)
return self.get_torrent(torrent["torrent-added"]["id"])
def get_torrent(self, id):
command = TorrentGetCommand(Torrent.static_fields, id)
torrent = self._connection.execute(command)
return Torrent(self, torrent)
def _get_torrents(self):
command = TorrentGetListCommand(Torrent.static_fields)
list = self._connection.execute(command)
torrent_list = map(lambda t: Torrent(self, t), list)
return torrent_list
download_dir = session_property("download-dir")
torrents = property(_get_torrents)
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 main():
args = parse_args()
core.set_root_dir(args.root_dir)
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 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 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 daemon_main():
configure_logging()
daemon = None
logger = logging.getLogger("daemon.main")
try:
daemon = Daemon('http://illuminant:11311')
daemon.start()
while daemon.ok():
time.sleep(.1)
except KeyboardInterrupt:
if daemon is not None:
daemon.stop()
except Exception as e:
logger.error("error occurred, {}".format(e))
def main():
doers = _get_doers(shell)
doers.update(_get_doers(utils))
possible_actions = doers.keys() + ['start', 'stop', 'status']
args = arguments.get_args(possible_actions)
if args.action is None:
print "No action"
sys.exit(1)
apiclient = None
if args.no_api is False:
os_options = arguments.OpenstackOptions(args, os.environ)
if args.debug:
print os_options
apiclient = client.Client(username=os_options.username,
password=os_options.password,
tenant_name=os_options.tenant_name,
endpoint=os_options.endpoint,
auth_url=os_options.auth_url)
if args.client_id:
apiclient.client_id = args.client_id
if args.action in doers:
try:
return doers[args.action](apiclient, args)
except Exception as e:
print ('ERROR {0}'.format(e))
return 1
create_dir(args.jobs_dir, do_log=False)
freezer_scheduler = FreezerScheduler(apiclient=apiclient,
interval=int(args.interval),
job_path=args.jobs_dir)
daemon = Daemon(daemonizable=freezer_scheduler)
if args.action == 'start':
daemon.start(log_file=args.log_file)
elif args.action == 'stop':
daemon.stop()
elif args.action == 'reload':
daemon.reload()
elif args.action == 'status':
daemon.status()
return os.EX_OK
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 main():
parse_arguments()
init_logging()
models.initialize_database(settings["database"])
command = settings.get("command", None)
if command:
run_command(command)
return
if settings.get("daemon", False):
daemon = Daemon("/tmp/cachebrowser.pid", run_cachebrowser)
daemon.start()
else:
run_cachebrowser()
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 main():
pidfile = None
d = None
for i in range(1, len(sys.argv)):
arg = sys.argv[i]
if arg.startswith('--auth='):
auth_error = auth_file_load(arg[len('--auth='):])
if not auth_error is None:
print('Bad auth file: ' + auth_error)
sys.exit(1)
if len(sys.argv) > 2:
if sys.argv[1] == 'daemonize':
pidfile = sys.argv[2]
# Reloader will spawn new process with args
del(sys.argv[2])
del(sys.argv[1])
d = Daemon(pidfile)
d.start(run)
elif sys.argv[1] == 'stop':
pidfile = sys.argv[2]
d = Daemon(pidfile)
d.stop(24)
if d is None:
run()
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
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/env python
import sys
sys.path.append("settings")
import logging
import settings
from daemon import Daemon
logging.basicConfig(level=logging.INFO,
format='%(asctime)s %(name)-12s %(levelname)-8s %(message)s',
datefmt='%Y-%m-%d %H:%M:%S',
filename=settings.RKN_LOG,
filemode='a')
rkn = Daemon(settings.RKN_PID)
rkn.start()
def start(self):
Daemon.start(self)
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)
Spawns the listener
"""
try:
eventlet.serve(eventlet.listen((HOST, PORT)), handle,
concurrency=CONCURRENCY)
except socket.error as e:
log.warn(e)
eventlet.StopServe()
sys.exit(0)
if __name__ == "__main__":
d = Daemon("/tmp/simplemta.pid")
if sys.argv[1] == "start":
log.info("Starting SimpleMTA %s:%s..." % (HOST, PORT))
d.start()
elif sys.argv[1] == "restart":
log.info("Restarting SimpleMTA %s:%s..." % (HOST, PORT))
eventlet.StopServe()
d.restart()
else:
log.info("Stopping SimpleMTA...")
eventlet.StopServe()
d.stop()
sys.exit(0)
try:
main()
except (SystemExit, KeyboardInterrupt):
log.info("Stopping SimpleMTA...")
eventlet.StopServe()
d.stop()
def start(self):
Daemon.start(self)
class AtrCmd(cmd.Cmd):
daemon = None
def __init__(self):
self.daemon = Daemon()
super().__init__()
def do_add(self, line):
line = line.split(' ')
if len(line) > 1:
self.daemon.add_streamer(line[0], line[1])
else:
self.daemon.add_streamer(line[0])
def help_add(self):
print('\n'.join([
'add streamer [quality]',
'Adds streamer to watchlist with (optional) selected quality.',
'Default quality: best',
]))
def do_remove(self, line):
self.daemon.remove_streamer(line)
def help_remove(self):
print('\n'.join([
'remove streamer',
'Removes streamer from watchlist, also stops recording if currently recording streamer.',
]))
def do_list(self, line):
live, offline = self.daemon.get_streamers()
print('Live: ' + str(live))
print('Offline: ' + str(offline))
def help_list(self):
print('\n'.join([
'list',
'List all watched streamers, seperated in offline and live sets.',
]))
def do_start(self, line):
self.daemon.start()
def help_start(self):
print('\n'.join([
'start',
'Starts the configured daemon. You may still configure it further while it is running.',
]))
def do_time(self, line):
try:
self.daemon.check_interval = int(line)
print('Changed check interval to: ' + line + ' seconds.')
except ValueError:
print('\'' + line + '\' is not valid.')
def help_time(self):
print('\n'.join([
'time seconds',
'Configures the check interval in seconds.',
'Please do not make it too low and stay above 10 seconds.',
'Default check interval: 30 seconds.',
]))
def do_EOF(self, line):
self.do_exit(line)
return True
def do_exit(self, line):
print('exiting')
self.daemon.exit()
sys.exit()
def help_exit(self):
print('\n'.join([
'exit',
'Exits the application, stopping all running recording tasks.',
]))
def cmdloop_with_keyboard_interrupt(self):
try:
self.cmdloop()
except KeyboardInterrupt:
self.do_exit('')
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=80, help="Port to listen on (default=80)")
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 not 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 len(args) > 0:
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
