def stop(self):
"""Stop the daemon."""
log("info", "Enter stop")
# Get the pid from the pidfile
try:
pf = file(self.pidfile, 'r')
pid = int(pf.read().strip())
pf.close()
except IOError:
pid = None
if not pid:
message = "pidfile %s does not exist. Daemon not running?"
# sys.stderr.write(message % self.pidfile)
log("fail", message % self.pidfile)
return # not an error in a restart
# Try killing the daemon process
try:
while 1:
os.kill(pid, SIGTERM)
time.sleep(0.1)
except OSError, err:
err = str(err)
if err.find("No such process") > 0:
if os.path.exists(self.pidfile):
os.remove(self.pidfile)
else:
print str(err)
sys.exit(1)
def __init__(
self,
pidfile,
stdin='/dev/null',
stdout='/dev/null',
stderr='/dev/null'):
"""Save settings."""
log("info", "Enter init")
self.stdin = stdin
self.stdout = stdout
self.stderr = stderr
self.pidfile = pidfile
log("info", "Exit init")
def set_assignment(self, assignment):
"""Fetch the actual assignment data."""
assignment_list = []
if assignment == "wl-english":
# make assignment out of english wordlist
pass
elif assignment == "wl-dutch":
# make assignment out of dutch wordlist
pass
elif assignment.startswith("file-"):
# fetch assignment from file
pass
else:
# unknown assignment
log("error", "AssignmentSelection: unknown assignment.")
self.return_assignment(assignment_list)
def serve():
"""Open ssh tunnel and start listening."""
try:
subprocess.check_call([
"ssh",
"-fN",
"-R",
str(port)+":localhost:"+str(port),
"-i",
key,
username+"@"+clientip])
except (OSError, subprocess.CalledProcessError) as error:
log("warn", "Failed to open ssh tunnel: %s" % error)
try:
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
except socket.error, msg:
log("fail", "Failed to create socket:" + msg)
sys.exit()
def daemonize(self):
"""
Do the UNIX double-fork magic.
See Stevens' "Advanced Programming in the UNIX Environment"
for details (ISBN 0201563177)
http://www.erlenstar.demon.co.uk/unix/faq_2.html#SEC16
"""
log("info", "Enter daemonize")
try:
pid = os.fork()
if pid > 0:
# exit first parent
sys.exit(0)
except OSError, e:
# sys.stderr.write("fork #1 failed: %d (%s)" % (e.errno, e.strerror))
log(
"fail",
"fork #1 failed: %d (%s)" % (e.errno, e.strerror))
sys.exit(1)
def execute_command(cmd):
"""Fetch key combos from config and execute them."""
# see if exists in one-press, other wise look at sequence
# if it's not there at all, throw error!
# TODO: consider if it's not simpeler to see all commands as sequenses
keys = []
try:
keys.append(config.get('one-press', cmd))
except ConfigParser.NoOptionError as error:
try:
keys.append(config.get('sequence', cmd))
except ConfigParser.NoOptionError as error:
log("fail", "Command not found: %s : %s" % (cmd, error))
else:
# this is a sequence, so we must fetch the other parts
i = 2
while True:
sequence_cmd = cmd + "-p%d" % i
try:
keys.append(config.get('sequence', sequence_cmd))
except ConfigParser.NoOptionError as error:
break
else:
i += 1
# Now keys is a list of all key combinations that have to be pressed
for combo in keys:
try:
subprocess.check_call([
"xdotool",
"key",
"--clearmodifiers",
"--delay",
"25",
combo])
except (OSError, subprocess.CalledProcessError) as error:
log("fail", "Failed to execute command %s: %s" % (cmd, error))
def start(self):
"""Start the daemon."""
log("info", "Enter start")
# Check for a pidfile to see if the daemon already runs
try:
pf = file(self.pidfile, 'r')
pid = int(pf.read().strip())
pf.close()
except IOError:
pid = None
if pid:
message = "pidfile %s already exist. Daemon already running?"
# sys.stderr.write(message % self.pidfile)
log("fail", message % self.pidfile)
sys.exit(1)
# Start the daemon
self.daemonize()
self.run()
log("info", "Exit start")
def quit(self):
"""Exit application."""
log("info", "Exit application.")
self.active_tab.destroy()
self.master.quit()
os.setsid()
os.umask(0)
# do second fork
try:
pid = os.fork()
if pid > 0:
# exit from second parent
sys.exit(0)
except OSError, e:
# sys.stderr.write("fork #2 failed: %d (%s)" % (e.errno, e.strerror))
log(
"fail",
"fork #2 failed: %d (%s)" % (e.errno, e.strerror))
sys.exit(1)
log("info", "split off second fork")
# if not self.debug:
# # redirect standard file descriptors
# sys.stdout.flush()
# sys.stderr.flush()
# si = file(self.stdin, 'r')
# so = file(self.stdout, 'a+')
# se = file(self.stderr, 'a+', 0)
# os.dup2(si.fileno(), sys.stdin.fileno())
# os.dup2(so.fileno(), sys.stdout.fileno())
# os.dup2(se.fileno(), sys.stderr.fileno())
log("info", "write pidfile")
# write pidfile
atexit.register(self.delpid)
def settings(self):
"""Switch to settings tab."""
log("info", "Switch to settings tab.")
self.active_tab.destroy()
self.active_tab = Settings(self.master)
def stats(self):
"""Switch to stats tab."""
log("info", "Switch to stats tab.")
self.active_tab.destroy()
self.active_tab = Stats(self.master)
def review(self):
"""Switch to review tab."""
log("info", "Switch to review tab.")
self.active_tab.destroy()
self.active_tab = Review(self.master)
subprocess.check_call([
"ssh",
"-fN",
"-R",
str(port)+":localhost:"+str(port),
"-i",
key,
username+"@"+clientip])
except (OSError, subprocess.CalledProcessError) as error:
log("warn", "Failed to open ssh tunnel: %s" % error)
try:
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
except socket.error, msg:
log("fail", "Failed to create socket:" + msg)
sys.exit()
log("info", "Created socket")
s.bind(("127.0.0.1", int(port)))
log("info", "Now listening on port"+str(port))
s.listen(10)
while True:
client, _ = s.accept()
data = client.recv(4096)
execute_command(data)
client.close()
class MyDaemon(daemon.Daemon):
"""Daemonize RemoteControl."""
def run(self):
def restart(self):
"""Restart the daemon."""
log("info", "Enter restart")
self.stop()
self.start()
log("info", "Exit restart")
def help_(self):
"""Switch to help tab."""
log("info", "Switch to help tab.")
self.active_tab.destroy()
self.active_tab = Help(self.master)
def destroy(self):
"""Remove frame."""
log("info", "Destroying review frame")
self.frame.grid_remove()
self.frame.grid_forget()
self.frame.destroy()
def run(self):
"""Start the actual process."""
log("info", "running!")
serve()
def home(self):
"""Switch to home tab."""
log("info", "Switch to home tab.")
self.active_tab.destroy()
self.active_tab = Home(self.master)
def learn(self):
"""Switch to learn tab."""
log("info", "Switch to learn tab.")
self.active_tab.destroy()
self.active_tab = Learn(self.master)
def delpid(self):
"""Delete pid file."""
log("info", "Enter delpid")
os.remove(self.pidfile)
log("info", "Exit delpid")
class MyDaemon(daemon.Daemon):
"""Daemonize RemoteControl."""
def run(self):
"""Start the actual process."""
log("info", "running!")
serve()
if __name__ == "__main__":
daemon = MyDaemon(
pidfile,
stdin=stdin,
stdout=stdout,
stderr=stderr)
if len(sys.argv) == 2:
if sys.argv[1] == 'start':
log("info", "Starting...")
daemon.start()
log("info", "Started!")
elif sys.argv[1] == 'stop':
daemon.stop()
elif sys.argv[1] == 'restart':
daemon.restart()
else:
log("fail", "Unknown command")
sys.exit(2)
sys.exit(0)
else:
log("info", "usage: %s start|stop|restart" % sys.argv[0])
sys.exit(2)
