renamed utils to pymutils to avoid potential confusion in the global namespace; added verbosity options

Author: baliame

README.rst

@@ -27,7 +27,7 @@ Below is the expected structure of a pymanager file.
 
     {
       "modules": {
-        "http_verifier": {
+        "pymutils.http_verifier": {
           "verifiers": ["HttpOkVerifier"]
         }
       },
@@ -44,7 +44,7 @@ Below is the expected structure of a pymanager file.
             "suppress_output": false
           },
           "verifier": {
-            "type": "http_verifier.HttpOkVerifier",
+            "type": "pymutils.http_verifier.HttpOkVerifier",
             "arguments": {
               "url": "http://google.com"
             }
@@ -98,6 +98,14 @@ Optionally, options may be passed to the process launcher. Currently recognized
 
 A process may also include a verifier. If the verifier key is present, the type must be provided. The type of the verifier must be loaded in the modules section and takes the form of 'module.classname'. Optionally, you may provide a dictionary of arguments to pass to the keyword arguments of the initializer function of the verifier.
 
+messages
+^^^^^^^^
+Optionally, a list of message types (strings) may appear in the configuration under the key 'messages'. This controls the verbosity of the output from the application. By default, no additional output is displayed. Currently, the following options are available:
+
+* process.exit - display message when a controlled process exits, along with the return code.
+* verifier.fail - display messages about verifier attempts failing.
+* verifier.verbose - display all (debug) messages from verifier, implies all other verifier options.
+
 Signal response
 ===============
 The application will respond to SIGINT, SIGTERM and SIGQUIT the same way as if a DELETE / request was issued to its HTTP endpoint.

pymanager-example.json

@@ -1,6 +1,6 @@
 {
 	"modules": {
-		"utils.http_verifier": {
+		"pymutils.http_verifier": {
 			"verifiers": ["HttpOkVerifier"]
 		}
 	},
@@ -9,10 +9,10 @@
 			"executable": "python3",
 			"arguments": ["test.py"],
 			"options": {
-				"suppress_output": true
+				"suppress_output": false
 			},
 			"verifier": {
-				"type": "utils.http_verifier.HttpOkVerifier",
+				"type": "pymutils.http_verifier.HttpOkVerifier",
 				"arguments": {
 					"url": "http://google.com"
 				}
@@ -23,5 +23,9 @@
 		"enabled": true,
 		"port": 5001
 	},
-	"keep_alive": true
-}
+	"keep_alive": true,
+	"messages": [
+		"process.exit",
+		"verifier.verbose"
+	]
+}

pymanager.py

@@ -1,15 +1,16 @@
 import traceback
-from utils.process import Process
-import utils.verifier as verifier
+from pymutils.process import Process
+import pymutils.verifier as verifier
 from optparse import OptionParser
-import utils.http_service as http_service
+import pymutils.http_service as http_service
+import collections
 import os
 import json
 import inspect
 import signal
 import sys
 import time
-from utils.global_storage import Globals
+from pymutils.global_storage import Globals
 
 def parse(filename):
 	try:
@@ -22,18 +23,29 @@ def parse(filename):
 		print("Error while loading file {0}: {1}.".format(filename, e))
 		exit(2)
 	try:
-		jdata = json.loads(config_data)
+		jdata = json.JSONDecoder(object_pairs_hook=collections.OrderedDict).decode(config_data)
 	except ValueError:
 		print("{0} is not a valid JSON file.".format(filename))
 		exit(3)
 
 	return jdata
 
 def graceful_shutdown(signum, frame):
+	if Globals.in_force_quit:
+		return
 	if Globals.shutdown:
+		if signum == signal.SIGINT:
+			Globals.in_force_quit = True
+			for proc in Process.processes:
+				if proc.poll() is None:
+					proc.kill()
+			Globals.may_terminate = True
 		return
+	print("Shutting down gracefully (SIGINT again to terminate immediately)...")
 	Globals.shutdown = True
 	for proc in Process.processes:
+		if Globals.in_force_quit:
+			return
 		try:
 			if proc.poll() is None:
 				proc.force_terminate(Globals.terminate_time_allowed)
@@ -77,6 +89,9 @@ def main():
 	signal.signal(signal.SIGTERM, graceful_shutdown)
 	signal.signal(signal.SIGQUIT, graceful_shutdown)
 
+	if "messages" in config:
+		Globals.messages = config["messages"]
+
 	try:
 		for key, procdef in config["processes"].items():
 			if "executable" not in procdef or "arguments" not in procdef:

utils/__init__.py pymutils/__init__.pyutils/__init__.py renamed to pymutils/__init__.py

@@ -2,5 +2,4 @@
 from .http_verifier import HttpOkVerifier
 from .verifier import Verifier
 
-
 __all__ = ["exited_verifier", "http_verifier", "verifier"]

utils/exited_verifier.py pymutils/exited_verifier.pyutils/exited_verifier.py renamed to pymutils/exited_verifier.py

@@ -16,5 +16,8 @@ def run(self, proc):
 		try:
 			proc.wait(self.timeout)
 		except subprocess.TimeoutExpired:
+			self.log_fail("Process did not exit in given timeframe {0}s".format(self.timeout))
 			return False
+		if proc.returncode != self.expect_code:
+			self.log_fail("Expected exit code {0}, got {1}".format(proc.returncode, self.expect_code))
 		return proc.returncode == self.expect_code

pymutils/global_storage.py

@@ -0,0 +1,7 @@
+class Globals:
+	shutdown = False
+	in_force_quit = False
+	may_terminate = False
+	terminate_time_allowed = 10
+
+	messages = []

utils/http_service.py pymutils/http_service.pyutils/http_service.py renamed to pymutils/http_service.py

@@ -2,6 +2,7 @@
 import requests
 from requests import exceptions as reqexcept
 from .verifier import Verifier
+from .global_storage import Globals
 
 class HttpOkVerifier(Verifier):
 	def __init__(self, **kwargs):
@@ -27,9 +28,15 @@ def run(self, proc):
 		timeout_at = time.time() + self.timeout
 		while not passed and time.time() < timeout_at:
 			try:
+				self.log_verbose("Attempting connection to {0} with a timeout of {1}s".format(self.url, self.interval))
 				resp = requests.get(self.url, headers=self.headers, timeout=self.interval)
 				if resp.status_code >= 200 and resp.status_code < 300:
 					passed = True
-			except reqexcept.ConnectionError:
+				else:
+					self.log_fail("Got status {0} from server.".format(resp.status_code))
+			except reqexcept.ConnectionError as e:
+				self.log_fail("Connection error: {0}".format(e))
 				pass
+			if Globals.shutdown:
+				return False
 		return passed

utils/http_verifier.py pymutils/http_verifier.pyutils/http_verifier.py renamed to pymutils/http_verifier.py

@@ -1,5 +1,6 @@
 import shlex
 import subprocess
+from .global_storage import Globals
 
 class UninitializedException(Exception):
 	def __init__(self, process):
@@ -61,7 +62,6 @@ def init(self, commandLine, verifier=None, **kwargs):
 		if verifier is not None:
 			if not verifier.run(self):
 				raise VerificationFailedException(self)
-		self.rcode = None
 
 	def __del__(self):
 		if hasattr(self, "proc") and self.proc is not None:
@@ -81,8 +81,14 @@ def restart(self, timeout=10):
 
 	def wait(self, timeout=None):
 		if hasattr(self, "proc") and self.proc is not None:
+			notify = False
+			if self.proc.returncode is None:
+				notify = True
+			else:
+				return self.proc.returncode
 			code = self.proc.wait(timeout)
-			self.rcode = code
+			if self.proc.returncode is not None and notify and "process.exit" in Globals.messages:
+				print("Process {0} exited with code {1}".format(self.cmdString, self.proc.returncode))
 			return code
 		else:
 			raise UninitializedException(self)
@@ -102,16 +108,19 @@ def code(self, blocking=True, timeout=None):
 				except subprocess.TimeoutExpired:
 					return None
 			else:
-				self.rcode = code
 				return code
 		else:
 			raise UninitializedException(self)
 
 	def poll(self):
 		if not hasattr(self, "proc") or self.proc is None:
 			raise UninitializedException(self)
+		notify = False
+		if self.proc.returncode is None:
+			notify = True
 		self.proc.poll()
-		self.rcode = self.proc.returncode
+		if self.proc.returncode is not None and notify and "process.exit" in Globals.messages:
+			print("Process {0} exited with code {1}".format(self.cmdString, self.proc.returncode))
 		return self.proc.returncode
 
 	def signal(self, signal):
@@ -131,21 +140,25 @@ def pid(self):
 
 	def terminate(self):
 		if hasattr(self, "proc") and self.proc is not None:
-			self.proc.terminate()
+			if self.proc.poll() is None:
+				self.proc.terminate()
+				self.proc.poll()
 		else:
 			raise UninitializedException(self)
 
 	def kill(self):
 		if hasattr(self, "proc") and self.proc is not None:
-			self.proc.kill()
+			if self.proc.poll() is None:
+				self.proc.kill()
+				self.proc.poll()
 		else:
 			raise UninitializedException(self)
 
 	def force_terminate(self, timeout=10):
 		if hasattr(self, "proc") and self.proc is not None:
 			self.terminate()
 			try:
-				self.wait()
+				self.wait(timeout)
 			except subprocess.TimeoutExpired:
 				self.kill()
 		else:

utils/process.py pymutils/process.pyutils/process.py renamed to pymutils/process.py

@@ -0,0 +1,14 @@
+from .global_storage import Globals
+
+class Verifier:
+	def run(self, proc):
+		return True
+
+	def log_fail(self, message):
+		print("pi")
+		if "verifier.fail" in Globals.messages or "verifier.verbose" in Globals.messages:
+			print("Verifier fail: {0}".format(message))
+
+	def log_verbose(self, message):
+		if "verifier.verbose" in Globals.messages:
+			print("Verifier: {0}".format(message))