first commit

Author: Thane Thomson

AUTHORS

@@ -0,0 +1,4 @@
+Praekelt Foundation
+===================
+* Thane Thomson
+

LICENSE

@@ -0,0 +1,25 @@
+Copyright (c) 2011 Praekelt Foundation
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of Praekelt Foundation nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL PRAEKELT FOUNDATION BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+

MANIFEST.in

@@ -0,0 +1,4 @@
+include AUTHORS
+include LICENSE
+include README.rst
+

README.rst

@@ -0,0 +1,82 @@
+python-sshtail
+==============
+
+A simple set of Python classes to facilitate tailing of one or more files via SSH.
+At the moment it only supports key-based SSH'ing.
+
+Quick installation
+------------------
+Install from PyPI:
+
+::
+
+    > easy_install -U python-sshtail
+
+
+Tailing a single file
+---------------------
+
+::
+
+    from sshtail import SSHTailer
+    from time import sleep
+
+    # "1.2.3.4" is the IP address or host name you want to access
+    tailer = SSHTailer('1.2.3.4', '/var/log/path/to/my/logfile.log')
+
+    try:
+        while 1:
+            for line in tailer.tail():
+                print line
+            
+            # wait a bit
+            time.sleep(1)
+
+    except:
+        tailer.disconnect()
+
+
+Tailing multiple files
+----------------------
+
+::
+
+    from sshtail import SSHMultiTailer
+
+    tailer = SSHMultiTailer({
+        '1.2.3.4': ['/path/to/log1.log', '/path/to/log2.log'],
+        '4.3.2.1': ['/path/to/log3.log'],
+    })
+
+    # will run until it receives SIGINT, after which it will
+    # automatically catch the exception, disconnect from the
+    # remote hosts and perform cleanup
+
+    for host, filename, line in tailer.tail():
+        print "%s:%s - %s" % (host, filename, line)
+
+
+
+Using a custom private key
+--------------------------
+
+::
+
+    from sshtail import SSHMultiTailer, load_dss_key
+
+    # if no path's specified for the private key file name,
+    # it automatically prepends /home/<current_user>/.ssh/
+    # and for RSA keys, import load_rsa_key instead.
+
+    tailer = SSHMultiTailer({
+            '1.2.3.4': ['/path/to/log1.log', '/path/to/log2.log'],
+            '4.3.2.1': ['/path/to/log3.log'],
+        },
+        private_key=load_dss_key('identity'))
+
+    for host, filename, line in tailer.tail():
+        print "%s:%s - %s" % (host, filename, line)
+
+
+
+

setup.py

@@ -0,0 +1,28 @@
+from setuptools import setup, find_packages
+
+setup(
+    name='python-sshtail',
+    version='0.0.1',
+    description='Python classes to allow for tailing of multiple files via SSH.',
+    long_description=open('README.rst', 'rt').read(),
+    author='Praekelt Foundation',
+    author_email='[email protected]',
+    license='BSD',
+    url='https://github.com/praekelt/python-sshtail',
+    packages=find_packages(),
+    install_requires=[
+        'paramiko',
+    ],
+    include_package_data=True,
+    classifiers = [
+        'Programming Language :: Python',
+        'License :: OSI Approved :: BSD License',
+        'Development Status :: 4 - Beta',
+        'Operating System :: OS Independent',
+        'Framework :: Django',
+        'Intended Audience :: Developers',
+        'Topic :: Internet :: WWW/HTTP :: Dynamic Content',
+    ],
+    zip_safe=False,
+)
+

sshtail/__init__.py

@@ -0,0 +1,3 @@
+from tailers import *
+from utils import *
+

sshtail/tailers.py

@@ -0,0 +1,177 @@
+#
+# Library to handle tailing of files via SSH.
+#
+# [email protected]
+#
+
+import os
+import time
+import paramiko
+
+
+class SSHTailer(object):
+    """
+    Class to handle the tailing of a single file via SSH.
+    """
+
+    def __init__(self, host, remote_filename, private_key=None):
+        self.host = host
+        self.remote_filename = remote_filename
+        self.private_key = private_key
+        self.client = None
+        self.sftp_client = None
+        self.remote_file_size = None
+        self.line_terminators = ['\r', '\n', '\r\n']
+        self.line_terminators_joined = '\r\n'
+
+
+    def connect(self):
+        print "Connecting to %s..." % self.host
+        # connect to the host
+        self.client = paramiko.SSHClient()
+        self.client.load_system_host_keys()
+        self.client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
+        if self.private_key:
+            self.client.connect(self.host, pkey=self.private_key)
+        else:
+            self.client.connect(self.host)
+
+        print "Opening remote file %s..." % self.remote_filename
+        # open a connection to the remote file via SFTP
+        self.sftp_client = self.client.open_sftp()
+        
+
+
+    def tail(self):
+        # make sure there's a connection
+        if not self.sftp_client:
+            self.connect()
+
+        fstat = self.sftp_client.stat(self.remote_filename)
+
+        # check if we have the file size
+        if self.remote_file_size is not None:
+            # if the file's grown
+            if self.remote_file_size < fstat.st_size:
+                for line in self.get_new_lines():
+                    yield line
+
+        self.remote_file_size = fstat.st_size
+ 
+
+
+    def get_new_lines(self):
+        """
+        Opens the file and reads any new data from it.
+        """
+
+        remote_file = self.sftp_client.open(self.remote_filename, 'r')
+        # seek to the latest read point in the file
+        remote_file.seek(self.remote_file_size, 0)
+        # read any new lines from the file
+        line = remote_file.readline()
+        while line:
+            yield line.strip(self.line_terminators_joined)
+            line = remote_file.readline()
+
+        remote_file.close()
+
+
+
+    def disconnect(self):
+        if self.sftp_client:
+            print "Closing SFTP connection..."
+            self.sftp_client.close()
+            self.sftp_client = None
+        if self.client:
+            print "Closing SSH connection..."
+            self.client.close()
+            self.client = None
+
+
+            
+
+class SSHMultiTailer(object):
+    """
+    Class to handle tailing of multiple files.
+    """
+
+    def __init__(self, host_files, poll_interval=2.0, private_key=None):
+        """
+        host_files is a dictionary whose keys must correspond to unique
+        remote hosts to which this machine has access (ideally via SSH key).
+        The values of the host_files dictionary must be arrays of file names
+        that must be tailed.
+        """
+
+        self.host_files = host_files
+        self.poll_interval = poll_interval
+        self.private_key = private_key
+        self.tailers = {}
+
+
+    def connect(self):
+        """
+        Connects to all of the host machines.
+        """
+
+        print "Connecting to multiple hosts..."
+
+        for host, files in self.host_files.iteritems():
+            self.tailers[host] = {}
+            for f in files:
+                self.tailers[host][f] = SSHTailer(host, f, private_key=self.private_key)
+
+
+
+    def tail(self, report_sleep=False):
+        """
+        Tails all of the requested files across all of the hosts.
+        """
+
+        # make sure we're connected
+        if not self.tailers:
+            self.connect()
+
+        try:
+            # assuming this script is to run until someone kills it (Ctrl+C)
+            while 1:
+                lines_read = 0
+
+                for host, tailers in self.tailers.iteritems():
+                    for filename, tailer in tailers.iteritems():
+                        # read as much data as we can from the file
+                        for line in tailer.tail():
+                            yield host, filename, line
+                            lines_read += 1
+
+                if not lines_read:
+                    if report_sleep:
+                        yield None, None, None
+                    self.sleep()
+
+        finally:
+            self.disconnect()
+
+
+    
+    def sleep(self):
+        time.sleep(self.poll_interval)
+
+
+
+    def disconnect(self):
+        """
+        Disconnects all active connections.
+        """
+
+        for host, tailers in self.tailers.iteritems():
+            for filename, tailer in tailers.iteritems():
+                tailer.disconnect()
+
+        self.tailers = {}
+
+        print "Disconnected from hosts."
+
+
+

sshtail/utils.py

@@ -0,0 +1,28 @@
+import os
+import paramiko
+
+
+def prepend_home_dir(filename):
+    """
+    Prepends the home directory to the given filename if it doesn't
+    already contain some kind of directory path.
+    """
+    return os.path.join(os.environ['HOME'], '.ssh', filename) if '/' not in filename else filename
+
+
+
+def load_rsa_key(filename):
+    """
+    Function to get an RSA key from the specified file for Paramiko.
+    """ 
+
+    return paramiko.RSAKey.from_private_key_file(prepend_home_dir(filename))
+
+
+
+def load_dss_key(filename):
+    """
+    Function to get a DSS key from the specified file for Paramiko.
+    """
+
+    return paramiko.DSSKey.from_private_key_file(prepend_home_dir(filename))