wirtz
/
scriptform
mirror of https://github.com/fboender/scriptform.git
1
0
Fork 0
Code Issues Releases Wiki Activity

Ability to run as daemon.

Browse Source
pull/7/head
Ferry Boender 10 years ago
parent 336dd0c541
commit f28fd0aa34
1 changed files with 170 additions and 16 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 186
      src/scriptform.py

186
src/scriptform.py
Unescape View File

@ -24,6 +24,11 @@ import base64
import tempfile import tempfile
import hashlib import hashlib
import urlparse import urlparse
import atexit
import signal
import time
import errno
import logging
html_header = '''<html> html_header = '''<html>
@ -159,6 +164,7 @@ class ScriptForm:
else: else:
self.callbacks = {} self.callbacks = {}
self.basepath = os.path.realpath(os.path.dirname(config_file)) self.basepath = os.path.realpath(os.path.dirname(config_file))
self.log = logging.getLogger('SCRIPTFORM')
def get_form_config(self): def get_form_config(self):
""" """
@ -498,7 +504,9 @@ class WebSrv:
Very basic web server. Very basic web server.
""" """
def __init__(self, request_handler, listen_addr='', listen_port=80): def __init__(self, request_handler, listen_addr='', listen_port=80):
self.log = logging.getLogger('WEBSRV')
httpd = ThreadedHTTPServer((listen_addr, listen_port), request_handler) httpd = ThreadedHTTPServer((listen_addr, listen_port), request_handler)
self.log.info("Listening on {0}:{1}".format(listen_addr, listen_port))
httpd.serve_forever() httpd.serve_forever()
@ -839,25 +847,141 @@ class ScriptFormWebApp(WebAppHandler):
os.unlink(file_name) os.unlink(file_name)
def main_generate_pw(parser, options, args): class DaemonError(BaseException):
import getpass pass
plain_pw = getpass.getpass()
if not plain_pw == getpass.getpass('Repeat password: '):
sys.stderr.write("Passwords do not match.\n")
sys.exit(1)
print hashlib.sha256(plain_pw).hexdigest()
sys.exit(0)
def main_serve(parser, options, args):
if len(args) < 1:
parser.error("Insufficient number of arguments")
sf = ScriptForm(args[0]) class Daemon:
sf.run(listen_port=options.port) """
Daemonize the current process (detach it from the console).
"""
def __init__(self, pid_file, log_file=None, log_level=logging.INFO, foreground=False):
if pid_file is None:
self.pid_file = '{0}.pid'.format(os.path.basename(sys.argv[0]))
else:
self.pid_file = pid_file
if log_file is None:
self.log_file = '{0}.log'.format(os.path.basename(sys.argv[0]))
else:
self.log_file = log_file
self.foreground = foreground
logging.basicConfig(level=log_level,
format='%(asctime)s:%(name)s:%(levelname)s:%(message)s',
filename=self.log_file,
filemode='a')
self.log = logging.getLogger('DAEMON')
def start(self):
self.log.info("Starting")
if self.is_running():
self.log.error('Already running')
raise DaemonError("Already running")
if not self.foreground:
self._fork()
def stop(self):
if not self.is_running():
raise DaemonError("Not running")
pid = self.get_pid()
# Kill the daemon and wait until the process is gone
os.kill(pid, signal.SIGTERM)
for timeout in range(25): # 5 seconds
time.sleep(0.2)
if not self._pid_running(pid):
break
else:
self.log.error("Couldn't stop the daemon.")
def is_running(self):
"""
Check if the daemon is already running by looking at the PID file
"""
if self.get_pid() is None:
return False
else:
return True
def get_pid(self):
"""
Returns the PID of this daemon. If the daemon is not running (the PID
file does not exist or the PID in the PID file does not exist), returns
None.
"""
if not os.path.exists(self.pid_file):
return None
try:
pid = int(file(self.pid_file, 'r').read().strip())
except ValueError:
return None
if os.path.isdir('/proc/{0}/'.format(pid)):
return pid
else:
os.unlink(self.pid_file)
return None
def _pid_running(self, pid):
"""
Returns True if the PID is running, False otherwise
"""
try:
os.kill(pid, 0)
except OSError as err:
if err.errno == errno.ESRCH:
return False
return True
def _fork(self):
# Fork a child and end the parent (detach from parent)
pid = os.fork()
if pid > 0:
sys.exit(0) # End parent
# Change some defaults so the daemon doesn't tie up dirs, etc.
os.setsid()
os.umask(0)
# Fork a child and end parent (so init now owns process)
pid = os.fork()
if pid > 0:
self.log.info("PID = {0}".format(pid))
f = file(self.pid_file, 'w')
f.write(str(pid))
f.close()
sys.exit(0) # End parent
atexit.register(self._cleanup)
signal.signal(signal.SIGTERM, self._cleanup)
# Close STDIN, STDOUT and STDERR so we don't tie up the controlling
# terminal
for fd in (0, 1, 2):
try:
os.close(fd)
except OSError:
pass
# Reopen the closed file descriptors so other os.open() calls don't
# accidentally get tied to the stdin etc.
os.open("/dev/null", os.O_RDWR) # standard input (0)
os.dup2(0, 1) # standard output (1)
os.dup2(0, 2) # standard error (2)
return pid
def _cleanup(self, signal=None, frame=None):
self.log.info("Received signal {0}".format(signal))
if os.path.exists(self.pid_file):
os.unlink(self.pid_file)
if __name__ == "__main__": if __name__ == "__main__":
usage = [ usage = [
sys.argv[0] + " [option] <form_definition.json>", sys.argv[0] + " [option] (--start|--stop) <form_definition.json>",
" " + sys.argv[0] + " --generate-pw", " " + sys.argv[0] + " --generate-pw",
] ]
parser = optparse.OptionParser() parser = optparse.OptionParser()
@ -865,9 +989,39 @@ if __name__ == "__main__":
parser.add_option("-g", "--generate-pw", dest="generate_pw", action="store_true", default=False, help="Generate password") 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") parser.add_option("-p", "--port", dest="port", action="store", type="int", default=80, help="Port to listen on")
parser.add_option("-f", "--foreground", dest="foreground", action="store_true", default=False, help="Run in foreground (debugging)")
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() (options, args) = parser.parse_args()
if options.generate_pw: if options.generate_pw:
main_generate_pw(parser, options, args) # Generate a password for use in the `users` section
import getpass
plain_pw = getpass.getpass()
if not plain_pw == getpass.getpass('Repeat password: '):
sys.stderr.write("Passwords do not match.\n")
sys.exit(1)
print hashlib.sha256(plain_pw).hexdigest()
sys.exit(0)
else: else:
main_serve(parser, options, args) 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
daemon = Daemon(options.pid_file, options.log_file, foreground=options.foreground)
log = logging.getLogger('MAIN')
try:
if options.action_start:
sf = ScriptForm(args[0])
daemon.start()
#sf.run(listen_port=options.port)
time.sleep(10000)
elif options.action_stop:
daemon.stop()
sys.exit(0)
except Exception, e:
log.exception(e)
raise

Write Preview
Loading…
Cancel
Save