tail.py

#!/usr/bin/env python

'''
Python-Tail - Unix tail follow implementation in Python. 

python-tail can be used to monitor changes to a file.

Example:
    import tail

    # Create a tail instance
    t = self.Tail('file-to-be-followed')

    # Register a callback function to be called when a new line is found in the followed file. 
    # If no callback function is registerd, new lines would be printed to standard out.
    t.register_callback(callback_function)

    # Follow the file with 5 seconds as sleep time between iterations. 
    # If sleep time is not provided 1 second is used as the default time.
    t.follow(s=5) '''

# Author - Alexis Okuwa <alexisokuwa at gmail.com>
# Source - https://github.com/wojons/python-tail
# Forked - https://github.com/kasun/python-tail

import os
import sys
import time

class Tail(object):
    ''' Represents a tail command. '''
    follow_filename = False
    follows = dict()
    
    def __init__(self):
        ''' Initiate a Tail instance.
            Check for file validity, assigns callback function to standard out.
            
            Arguments:
                tailed_file - File to be followed. '''
    
    def tail(self, files, callback=None):
        if type(files).__name__ == 'str': #we allow strings we will just handle the converstion
            files = [files]
        
        for filename in files: #make sure we have good files all around
            try:
                self.check_file_validity(filename)
            except TailError as e:
                sys.stderr.write(str(e))
            
            if filename not in self.follows: #make sure we dont have the file already
                self.new_follow(filename)
                self.set_callback(filename, callback)
        
        #self.callback = sys.stdout.write
    
    def set_follow_filename(self, boolean):
        """
        Set true or false if you want program to follow file even if inode changes like when logrotate runes see gnu tail --folow=name
        """
        self.follow_filename = boolean
    
    def follow(self, s=1, max_time=None, loop_max=True):
        ''' Do a tail follow. If a callback function is registered it is called with every new line. 
        Else printed to standard out.

        Arguments:
            s - Number of seconds to wait between each iteration; Defaults to 1.
            max_time - the appoxment number of seocnds the loop should run for
            loop_max - the max number of times the loop should run over
        '''
        
        for filename in self.follows:
            
            if self.get_filename_fd(filename) is None:
                self.open_file(filename) #get all the file points
                
                if self.get_filename_fd(filename) != None:
                    self.follows[filename]['fd'].seek(0, os.SEEK_END) #handle all the seeking
        
        follow_t = time.time()
        
        while loop_max != 0 and (max_time == None or time.time() <= max_time+follow_t):
            start_t  = time.time() #gotta keep track of how long we been in this
            
            for filename, file_ in self.follows.iteritems():
                if file_['fd'] != None:
                    file_ = self.read_2_EOF(filename, file_['fd'])
                else:
                    self.open_file(filename)
                
                if self.follow_filename == True: #check to see if inode has changed
                    self.check_inode(filename)
                    
            if loop_max != True:
                loop_max -= 1
                
                if loop_max == 0: continue
            
            time_lap = time.time()-start_t
            if(time_lap < s):  time.sleep(s - time_lap)
            
    def read_2_EOF(self, filename, file_):
        if file_ == None: return None
            
        line = True #reset line value
        while line:
            curr_position = file_.tell() #get current postion
            line = file_.readline() #read the next line we use readline() and not readlines because we may read a line that is still being written to.
            if not line:
                file_.seek(curr_position) #reset the seek point so we can try from the same point again
            else:
                self.exec_callback(line, filename)
        return file_
    
    def exec_callback(self, line, filename):
        if filename in self.follows and self.follows[filename].get('callback') is not None:
            self.follows[filename]['callback']({'line':line, 'filename':filename})
        else:
            print ({'line':line, 'filename':filename})
        
    def get_inode(self, filename):
        try:
            return os.stat(filename).st_ino
        except OSError as e:
            return None
            
    def get_filename_inode(self, filename):
        if filename in self.follows: return self.follows[filename].get('inode')
            
    def get_file_num(self, filename):
        try:
            return self.tailed_files.index(filename)
        except:
            return None
            
    def set_callback(self, filename, callback):
        self.follows[filename]['callback'] = callback
            
    def open_file(self, filename):
        try:
            if not os.access(filename, os.F_OK): return None
            if not os.access(filename, os.R_OK): return None
            if os.path.isdir(filename):  return None
                
            self.follows[filename]['fd'] = open(filename)
            self.follows[filename]['inode'] = self.get_inode(filename)
            
        except (IOError, OSError) as e:
            pass
    
    def get_filename_fd(self, filename):
        if filename in self.follows: return self.follows[filename].get('fd')
        
    def check_inode(self, filename):
        try:
            if self.get_inode(filename) != self.get_filename_inode(filename): #check if the inode has changed
                self.read_2_EOF(filename, self.get_filename_fd(filename)) #read the current but old file to EOF
                self.open_file(filename) # reopen the file pointer to the replacment file
                
        except OSError as e:
            pass
            
    def new_follow(self, filename, overwrite=False):
        if filename not in self.follows or overwrite is True:
            self.follows[filename] = {'fd': None, 'callback': None, 'inode': None}
            return True
            
        return True

    def check_file_validity(self, file_):
        ''' Check whether the a given file exists, readable and is a file '''
        if not os.access(file_, os.F_OK):
            raise TailError("File '%s' does not exist" % (file_))
        if not os.access(file_, os.R_OK):
            raise TailError("File '%s' not readable" % (file_))
        if os.path.isdir(file_):
            raise TailError("File '%s' is a directory" % (file_))

class TailError(Exception):
    def __init__(self, msg):
        self.message = msg
    def __str__(self):
        return self.message