bugifix

etc/ahenk/log.conf

@@ -10,7 +10,7 @@ keys=file
 
 [handler_file]
 class=logging.FileHandler
-level=ERROR
+level=INFO
 formatter=default
 args=("/var/log/ahenk.log", "w")
 

opt/ahenk/ahenkd.py

@@ -3,17 +3,18 @@
 # Author: İsmail BAŞARAN <ismail.basaran@tubitak.gov.tr> <basaran.ismaill@gmail.com>
 
 from base.config.ConfigManager import ConfigManager
-from base.deamon.BaseDeamon import BaseDeamon
+from base.deamon.BaseDeamon import BaseDaemon
-from base.logging.AhenkLogger import Logger
+from base.logger.AhenkLogger import Logger
 from base.Scope import Scope
 #from base.messaging.Messaging import Messaging
 import sys,logging
 
 
-class AhenkDeamon(BaseDeamon):
+class AhenkDeamon(BaseDaemon):
 	"""docstring for AhenkDeamon"""
 
 	def run(self):
+		print "merhaba dunya"
 		globalscope = Scope()
 		globalscope.setInstance(globalscope)
 
@@ -34,17 +35,18 @@ if __name__ == '__main__':
 
 	pidfilePath='/var/run/ahenk.pid'
 
-	ahenkdeamon = AhenkDeamon(pidfilePath)
+	ahenkdaemon = AhenkDeamon(pidfilePath)
 
 	print sys.argv
 	if len(sys.argv) == 2:
 		if sys.argv[1] == "start":
 			print "starting"
-			ahenkdeamon.start()
+			ahenkdaemon.start()
+			print ahenkdaemon.get_pid()
 		elif sys.argv[1] == 'stop':
-			ahenkdeamon.stop()
+			ahenkdaemon.stop()
 		elif sys.argv[1] == 'restart':
-			ahenkdeamon.restart()
+			ahenkdaemon.restart()
 		elif sys.argv[1] == 'status':
 			# print status
 			pass

opt/ahenk/base/deamon/BaseDeamon.py

@@ -1,129 +1,137 @@
 #!/usr/bin/env python
- 
 import sys, os, time, atexit
 from signal import SIGTERM
 
-class BaseDeamon:
+class BaseDaemon(object):
-        """
+	"""
-        A generic daemon class.
+		A generic daemon class.
 
-        Usage: subclass the Daemon class and override the run() method
+		Usage: subclass the Daemon class and override the run() method
-        """
+	"""
-        def __init__(self, pidfile, stdin='/dev/null', stdout='/dev/null', stderr='/dev/null'):
-                self.stdin = stdin
-                self.stdout = stdout
-                self.stderr = stderr
-                self.pidfile = pidfile
 
-        def daemonize(self):
+	startmsg = "started with pid %s"
-                """
-                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
-                """
-                try:
-                        pid = os.fork()
-                        if pid > 0:
-                                # exit first parent
-                                sys.exit(0)
-                except OSError, e:
-                        sys.stderr.write("fork #1 failed: %d (%s)\n" % (e.errno, e.strerror))
-                        sys.exit(1)
 
-                # decouple from parent environment
+	def __init__(self, pidfile, stdin='/dev/null', stdout='/dev/null', stderr='/dev/null'):
-                os.chdir("/")
+			self.stdin = stdin
-                os.setsid()
+			self.stdout = stdout
-                os.umask(0)
+			self.stderr = stderr
+			self.pidfile = pidfile
 
-                # do second fork
+	def daemonize(self):
-                try:
+		"""
-                        pid = os.fork()
+		do the UNIX double-fork magic, see Stevens' "Advanced
-                        if pid > 0:
+		Programming in the UNIX Environment" for details (ISBN 0201563177)
-                                # exit from second parent
+		http://www.erlenstar.demon.co.uk/unix/faq_2.html#SEC16
-                                sys.exit(0)
+		"""
-                except OSError, e:
+		try:
-                        sys.stderr.write("fork #2 failed: %d (%s)\n" % (e.errno, e.strerror))
+				pid = os.fork()
-                        sys.exit(1)
+				if pid > 0:
+						# exit first parent
+						sys.exit(0)
+		except OSError, e:
+				sys.stderr.write("fork #1 failed: %d (%s)\n" % (e.errno, e.strerror))
+				sys.exit(1)
 
-                # redirect standard file descriptors
+		# decouple from parent environment
-                sys.stdout.flush()
+		os.chdir(".")
-                sys.stderr.flush()
+		os.setsid()
-                si = file(self.stdin, 'r')
+		os.umask(0)
-                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
+		# do second fork
-                atexit.register(self.delpid)
+		try:
-                pid = str(os.getpid())
+			pid = os.fork()
-                file(self.pidfile,'w+').write("%s\n" % pid)
+			if pid > 0:
+				# exit from second parent
+				sys.exit(0)
+		except OSError, e:
+			sys.stderr.write("fork #2 failed: %d (%s)\n" % (e.errno, e.strerror))
+			sys.exit(1)
 
-        def delpid(self):
+		# redirect standard file descriptors
-                os.remove(self.pidfile)
+		si = file(self.stdin, 'r')
+		so = file(self.stdout, 'a+')
+		se = file(self.stderr, 'a+', 0)
 
-        def start(self):
+		pid = str(os.getpid())
-                """
-                Start the daemon
-                """
-                # 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:
+		sys.stderr.write("\n%s\n" % self.startmsg % pid)
-                        message = "pidfile %s already exist. Daemon already running?\n"
+		sys.stderr.flush()
-                        sys.stderr.write(message % self.pidfile)
-                        sys.exit(1)
 
-                # Start the daemon
+		if self.pidfile:
-                self.daemonize()
+			file(self.pidfile,'w+').write("%s\n" % pid)
-                self.run()
 
-        def stop(self):
+		atexit.register(self.delpid)
-                """
+		os.dup2(si.fileno(), sys.stdin.fileno())
-                Stop the daemon
+		os.dup2(so.fileno(), sys.stdout.fileno())
-                """
+		os.dup2(se.fileno(), sys.stderr.fileno())
-                # 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?\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):
+	def delpid(self):
-                """
+		os.remove(self.pidfile)
-                You should override this method when you subclass Daemon. It will be called after the process has been
+
-                daemonized by start() or restart().
+	def start(self):
-                """
+		"""
+		Start the daemon
+		"""
+		# 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?\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
+		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?\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().
+		"""

opt/ahenk/base/logger/AhenkLogger.py

@@ -4,14 +4,13 @@
 import sys
 import logging
 import logging.config
-sys.path.insert(0,'/home/ismail/devzone/workspace/lider-ahenk/ahenk/opt/ahenk/')
+from base.Scope import Scope
-#import ahenkd
 
-class AhenkLogger(object):
+class Logger(object):
 	"""docstring for Logger"""
 	def __init__(self):
 		super(Logger, self).__init__()
-		scope = ahenkd.AhenkDeamon.scope()
+		scope = Scope.getInstance()
 		configManager = scope.getConfigurationManager()
 
 		logging.config.fileConfig(configManager.get('BASE','logConfigurationFilePath'))
@@ -31,8 +30,3 @@ class AhenkLogger(object):
 
 	def debug(self,logstring):
 		self.logger.debug(logstring)
-
-
-if __name__ == '__main__':
-	print "hello"
-	print sys.path