frigid

#!/usr/bin/env python

from __future__ import (
        print_function,
        unicode_literals,)
__author__='Dawson Reid'
from pprint import pprint

import sys
import yaml 
import time
import sh
import atexit
import logging
import argparse

from signal import SIGTERM 

from watchdog.observers import Observer
from watchdog.events import FileSystemEventHandler


class Daemon(object):
	'''!
	A generic daemon class.
	
	Usage: subclass the Daemon class and override the run() method
	'''

    @property
    def pidfile(self):
        '''!
        Attains the current process pid.
        '''
        try:
			pf = file(self.pidfile,'r')
			pid = int(pf.read().strip())
			pf.close()
            return pid
		except IOError:
			return None
	

	def __init__(self, pid_file, 
            cmd_file='/etc/frigid/cmd.pipe',
            log_file='/etc/frigid/f.log',
            stdin='/dev/null', stdout='/dev/null', stderr='/dev/null'):
        '''!
        '''
		self.stdin = stdin
		self.stdout = stdout
		self.stderr = stderr
		self.pidfile = pidfile

        # setup logging
        logging.basicConfig(filename=log_file, level=logging.DEBUG)

    
    def _fork(self):
        '''!
        Forks the current process.
        '''
        logging.info('Forking.')

        try: 
			pid = os.fork() 
			if pid > 0:
				# exit first parent
				sys.exit(0) 
		except OSError, e: 
			sys.stderr.write("fork failed: %d (%s)\n" % (e.errno, e.strerror))
			sys.exit(1)
	
    
    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
		"""
        # fork 1
	    self._fork()	
	
		# decouple from parent environment
		os.chdir("/") 
		os.setsid() 
		os.umask(0) 
	
		# fork 2
        self._fork()

		# 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())
	
		# write pidfile
		atexit.register(self.delpid)
		pid = str(os.getpid())
		file(self.pidfile,'w+').write("%s\n" % pid)


	def delpid(self):
		os.remove(self.pidfile)


	def start(self):
		"""
		Start the daemon
		"""
		# Check for a pidfile to see if the daemon already runs
        pid = self.pidfile
        if pid:
			message = "pidfile %s already exist. Daemon already running?\n"
			sys.stderr.write(message % self.pidfile)
			sys.exit(1)
		
		# Start the daemon
		self.daemonize()
		self.run()


	def stop(self):
		"""
		Stop the daemon
		"""
		# Get the pid from the pidfile
        pid = self.pidfile

		if not pid:
			message = "pidfile %s does not exist. Daemon not running?\n"
			sys.stderr.write(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 restart(self):
		"""
		Restart the daemon
		"""
		self.stop()
		self.start()


	def run(self):
		"""
		You should override this method when you subclass Daemon. It will be called after the process has been
		daemonized by start() or restart().
		"""
        pass


class FileModifiedHandler(FileSystemEventHandler):
    '''!
    '''

    def __init__(self, state_file):
        '''!
        '''
        super(FileModifiedHandler, self).__init__()
        self._state_file = state_file

    def on_modified(self, event):
        print("Got it!")


class FrigidDaemon(Daemon):
    '''!
    '''

    def __init__(self, )
        '''!
        '''
        super(FrigidDaemon, self).__init__()

        # load config
        self._config = yaml.load(open('/etc/frigid/config.yml', 'r'))

    def run(self):

        observer = Observer()
        # register all file watcher
        for watch_file, state_file in config['files'].iteritems():
            event_handler = FileModifiedHandler(state_file)
            observer.schedule(
                    event_handler, 
                    path=watch_file,
                    recursive=False)

        observer.start()

        # simple run loop
        while True:
            time.sleep(1)


PARSER = argparse.ArgumentParser(description='''
    Frigid

    This application is used to freeze files at a current state and 
    enforce them at that state. 
    ''')
PARSER.add_argument('cmd', help='')
PARSER.add_argument('arg', help='')
ARGS = PARSER.parse_args()

pprint(ARGS)

def main():
    '''!
    Main method.
    '''
    d = FreezeDaemon(
            pid_file='/tmp/freeze.pid',)
    
    if len(sys.argv) == 2:
        command = sys.argv[1]
        
        if 'start' == command:
            d.run()
        elif 'stop' == command:
            d.stop()
        elif 'restart' == command:
            d.restart()
        else:
            print('Unkown command')
            sys.exit(2)
    
    else:
        print('usage: {0} start|stop|reload'.format(sys.argv[0]))


if __name__ == '__main__':
    sys.exit(main())