Version 1.4

Author: kata198

ChangeLog

@@ -0,0 +1,11 @@
+- 1.4 Sep 18 2015
+ * Cleanup a lot of code
+ * Add additional comments
+ * Support retries when only one worker is configured
+ * Support configurable buffer sizes
+ * Add timestamps to all log messages
+ * Fix usage text
+ * Update README to be nicer format
+ * Add --version support
+ * remove old install.sh script
+ * Other Minor adjustments and cleanups

MANIFEST.in

@@ -0,0 +1,9 @@
+recursive-include pumpkinlb *.py
+include ChangeLog
+include setup.py
+include MANIFEST.in
+include README.md
+include README.rst
+include PumpkinLB.py
+include LICENSE
+include example.cfg

PumpkinLB.py

@@ -1,4 +1,9 @@
 #!/usr/bin/python2
+#
+# PumpkinLB Copyright (c) 2014-2015 Tim Savannah under GPLv3.
+# You should have received a copy of the license as LICENSE 
+#
+# See: https://github.com/kata198/PumpkinLB
 
 import math
 import multiprocessing
@@ -11,9 +16,17 @@
 import traceback
 import time
 
+from pumpkinlb import __version__ as pumpkin_version
+
 from pumpkinlb.config import PumpkinConfig, PumpkinMapping
-from pumpkinlb.usage import printUsage, printConfigHelp
+from pumpkinlb.usage import printUsage, printConfigHelp, getVersionStr
 from pumpkinlb.listener import PumpkinListener
+from pumpkinlb.constants import GRACEFUL_SHUTDOWN_TIME
+
+from pumpkinlb.log import logmsg, logerr
+
+
+
 
 if __name__ == '__main__':
 
@@ -25,6 +38,9 @@
         elif arg == '--help-config':
             printConfigHelp(sys.stdout)
             sys.exit(0)
+        elif arg == '--version':
+            sys.stdout.write(getVersionStr() + '\n')
+            sys.exit(0)
         elif configFilename is not None:
             sys.stderr.write('Too many arguments.\n\n')
             printUsage(sys.stderr)
@@ -45,12 +61,14 @@
         printConfigHelp(sys.stderr)
         sys.exit(1)
 
+    bufferSize = pumpkinConfig.getOptionValue('buffer_size')
+    logmsg('Configured buffer size = %d bytes\n' %(bufferSize,))
+
     mappings = pumpkinConfig.getMappings()
     listeners = []
     for mappingAddr, mapping in mappings.iteritems():
-        listenerArgs = mapping.getListenerArgs()
-        sys.stdout.write('Starting up listener: ' + str(listenerArgs) + '\n')
-        listener = PumpkinListener(*listenerArgs)
+        logmsg('Starting up listener on %s:%d with mappings: %s\n' %(mapping.localAddr, mapping.localPort, str(mapping.workers)))
+        listener = PumpkinListener(mapping.localAddr, mapping.localPort, mapping.workers, bufferSize)
         listener.start()
         listeners.append(listener)
 
@@ -60,42 +78,39 @@
     def handleSigTerm(*args):
         global listeners
         global globalIsTerminating
-        sys.stderr.write('CALLED\n')
+#        sys.stderr.write('CALLED\n')
         if globalIsTerminating is True:
             return # Already terminating
         globalIsTerminating = True
-        sys.stdout.write('Caught signal, shutting down listeners...\n')
+        logerr('Caught signal, shutting down listeners...\n')
         for listener in listeners:
             try:
                 os.kill(listener.pid, signal.SIGTERM)
             except:
                 pass
-        sys.stderr.write('Sent signal to children, waiting up to 4 seconds then trying to clean up\n')
+        logerr('Sent signal to children, waiting up to 4 seconds then trying to clean up\n')
         time.sleep(1)
         startTime = time.time()
         remainingListeners = listeners
         remainingListeners2 = []
         for listener in remainingListeners:
-            sys.stderr.write('Waiting on %d...\n' %(listener.pid,))
-            sys.stderr.flush()
+            logerr('Waiting on %d...\n' %(listener.pid,))
             listener.join(.05)
             if listener.is_alive() is True:
                 remainingListeners2.append(listener)
         remainingListeners = remainingListeners2
-        sys.stderr.write('Remaining (%d) listeners are: %s\n' %(len(remainingListeners), [listener.pid for listener in remainingListeners]))
-        sys.stderr.flush()
+        logerr('Remaining (%d) listeners are: %s\n' %(len(remainingListeners), [listener.pid for listener in remainingListeners]))
 
         afterJoinTime = time.time()
 
         if remainingListeners:
             delta = afterJoinTime - startTime
-            remainingSleep = int(6 - math.floor(afterJoinTime - startTime))
+            remainingSleep = int(GRACEFUL_SHUTDOWN_TIME - math.floor(afterJoinTime - startTime))
             if remainingSleep > 0:
                 anyAlive = False
                 # If we still have time left, see if we are just done or if there are children to clean up using remaining time allotment
                 if threading.activeCount() > 1 or len(multiprocessing.active_children()) > 0:
-                    sys.stderr.write('Listener closed in %1.2f seconds. Waiting up to %d seconds before terminating.\n' %(delta, remainingSleep))
-                    sys.stderr.flush()
+                    logerr('Listener closed in %1.2f seconds. Waiting up to %d seconds before terminating.\n' %(delta, remainingSleep))
                     thisThread = threading.current_thread()
                     for i in range(remainingSleep):
                         allThreads = threading.enumerate()
@@ -117,18 +132,15 @@ def handleSigTerm(*args):
                         time.sleep(1)
 
                 if anyAlive is True:
-                    sys.stderr.write('Could not kill in time.\n')
+                    logerr('Could not kill in time.\n')
                 else:
-                    sys.stderr.write('Shutdown successful after %1.2f seconds.\n' %( time.time() - startTime))
-                sys.stderr.flush()
+                    logerr('Shutdown successful after %1.2f seconds.\n' %( time.time() - startTime))
 
             else:
-                sys.stderr.write('Listener timed out in closing, exiting uncleanly.\n')
-                sys.stderr.flush()
+                logerr('Listener timed out in closing, exiting uncleanly.\n')
                 time.sleep(.05) # Why not? :P
 
-        sys.stdout.write('exiting...\n')
-        sys.stdout.flush()
+        logmsg('exiting...\n')
         signal.signal(signal.SIGTERM, signal.SIG_DFL)
         signal.signal(signal.SIGINT, signal.SIG_DFL)
         sys.exit(0)

README.md

@@ -1,43 +1,67 @@
-# PumpkinLB
-A simple, fast, pure-python load balancer
+PumpkinLB
+=========
 
-Description
-===========
 
-PumpkinLB is a fast multi-process TCP load balancer, compatible with: Linux, Cygwin, and Windows environments. It listens for requests on local ports, and farms them out to any number of workers. You can use it to very quickly setup a load balancer, e.x. from 1 front point to 5 different apache servers.
+PumpkinLB is a fast multi-process TCP load balancer / port forwarder, compatible with: Linux, Cygwin, and Windows environments.
+
+
+**Processing**
+
+PumpkinLB listens for requests on ports local to the machine on which it is running, and farms them out to any number of workers.
+
+You can use it to very quickly setup a load balancer, e.x. from 1 entry-point to 5 different apache workers on various servers.
 
 Each incoming port is waited-on by a distinct process, and each connection is yet another process, thus it performs very well even under heavy load.
 
-Usage
-=====
+Requests are generally handled round-robin between the various workers. 
+If a request fails on a backend worker, it will be retried on another random worker until it succeeds, and a message will be logged.
+
+**Usage**
+
 
 Execute by running PumpkinLB.py [cfgFile]
 
-Where cfgFile is the path to your config file. There is a sample "example.cfg" included.
+Where [cfgFile] is the path to your config file. There is a sample "example.cfg" included.
 
-Config file is broken up into sections, definable by [$SectionName], followed by variables in format of key=value.
 
-  Sections:
+**Config**
 
-    [options]
-      pre_resolve_workers=0/1                     [Default 1]    Any workers defined with a hostname will be evaluated at the time the config is read.
-                                                                   This is preferable as it saves a DNS trip for every request, and should be enabled
-                                                                   unless your DNS is likely to change and you want the workers to match the change.
+The Config file is broken up into sections, definable by [$SectionName], followed by variables in format of key=value.
 
-    [mapping]
-      localaddr:inport=worker1:port,worker2:port...              Listen on interface defined by "localaddr" on port "inport". Farm out to worker addresses and ports. Ex: 192.168.1.100:80=10.10.0.1:5900,10.10.0.2:5900
-        or
-      inport=worker1:port,worker2:port...                        Listen on all interfaces on port "inport", and farm out to worker addresses with given ports. Ex: 80=10.10.0.1:5900,10.10.0.2:5900
+Sections:
 
 
-So an example to listen on port 80 localhost and farm out to 3 apache servers on your local subnet:
+*[options]*
+
+* pre\_resolve\_workers=0/1 - Default 1
+
+	Any workers defined with a hostname will be evaluated at the time the config is read.
+
+	This is preferable as it saves a DNS trip for every request, and should be enabled 
 
-80=192.168.1.100:80,192.168.1.101:80,192.168.1.102:80
+	unless your DNS is likely to change and you want the workers to match the change.
 
 
+*[mapping]*
+
+* localaddr:inport=worker1:port,worker2:port...
+
+	Listen on interface defined by "localaddr" on port "inport". Farm out to worker addresses and ports.
+	Ex: 192.168.1.100:80=10.10.0.1:5900,10.10.0.2:5900
+
+* inport=worker1:port,worker2:port...
+
+	Listen on all interfaces on port "inport", and farm out to worker addresses with given ports.
+	Ex: 80=10.10.0.1:5900,10.10.0.2:5900
+
+
+
+So an example to listen on port 80 localhost and farm out to 3 apache servers on your local subnet:
+
+	80=192.168.1.100:80,192.168.1.101:80,192.168.1.102:80
 
-Sending SIGTERM, SIGINT, or pressing control+c will do a graceful shutdown (it will wait for up to 4 seconds to finish any active requests, and then terminate).
 
+**Graceful Shutdown**
 
-Requests are generally handled round-robin between the various workers. If a request fails on a backend worker, it will be retried on another random worker until it succeeds, and a message will be logged.
+Sending SIGTERM, SIGINT, or pressing control+c will do a graceful shutdown (it will wait for up to 6 seconds to finish any active requests, and then terminate).
 

README.rst

@@ -0,0 +1,69 @@
+PumpkinLB
+=========
+
+
+PumpkinLB is a fast multi-process TCP load balancer / port forwarder, compatible with: Linux, Cygwin, and Windows environments.
+
+
+**Processing**
+
+PumpkinLB listens for requests on ports local to the machine on which it is running, and farms them out to any number of workers.
+
+You can use it to very quickly setup a load balancer, e.x. from 1 entry-point to 5 different apache workers on various servers.
+
+Each incoming port is waited-on by a distinct process, and each connection is yet another process, thus it performs very well even under heavy load.
+
+Requests are generally handled round-robin between the various workers. 
+If a request fails on a backend worker, it will be retried on another random worker until it succeeds, and a message will be logged.
+
+**Usage**
+
+
+Execute by running PumpkinLB.py [cfgFile]
+
+Where [cfgFile] is the path to your config file. There is a sample "example.cfg" included.
+
+
+**Config**
+
+The Config file is broken up into sections, definable by [$SectionName], followed by variables in format of key=value.
+
+Sections:
+
+
+*[options]*
+
+* pre_resolve_workers=0/1 - Default 1
+
+	Any workers defined with a hostname will be evaluated at the time the config is read.
+
+	This is preferable as it saves a DNS trip for every request, and should be enabled 
+
+	unless your DNS is likely to change and you want the workers to match the change.
+
+
+*[mapping]*
+
+* localaddr:inport=worker1:port,worker2:port...
+
+	Listen on interface defined by "localaddr" on port "inport". Farm out to worker addresses and ports.
+
+	Ex: 192.168.1.100:80=10.10.0.1:5900,10.10.0.2:5900
+
+* inport=worker1:port,worker2:port...
+
+	Listen on all interfaces on port "inport", and farm out to worker addresses with given ports.
+
+	Ex: 80=10.10.0.1:5900,10.10.0.2:5900
+
+
+
+So an example to listen on port 80 localhost and farm out to 3 apache servers on your local subnet:
+
+	80=192.168.1.100:80,192.168.1.101:80,192.168.1.102:80
+
+
+**Graceful Shutdown**
+
+Sending SIGTERM, SIGINT, or pressing control+c will do a graceful shutdown (it will wait for up to 6 seconds to finish any active requests, and then terminate).
+

example.cfg

@@ -1,3 +1,6 @@
+[options]
+buffer_size=4096
+
 [mappings]
 24003=192.168.1.100:80,192.168.1.101:80,192.168.1.102:80,192.168.1.103:80
-24004=google.com:80
+24004=example.com:80

install.sh

@@ -0,0 +1,7 @@
+# PumpkinLB Copyright (c) 2014-2015 Tim Savannah under GPLv3.
+# You should have received a copy of the license as LICENSE 
+#
+# See: https://github.com/kata198/PumpkinLB
+
+__version__ = '1.4'
+__version_tuple__ = (1, 4, 0)