1

"""

     2

    Iterate over input lines in files. 

     3

     4

    Can be read up to eof, on blocking inputs, or polled with a timeout (see: pvl.syslog.syslog.SyslogSource)

     5

"""

     6

     7

import os

     8

     9

import logging; log = logging.getLogger('pvl.syslog.tail')

    10

    11

class Tail (object) :

    12

    """

    13

        Follow a file-like object, reading lines until EOF.

    14

    15

        Works with python file objects that buffer readlines() when using e.g. `tail -f ... | python -u ...`.

    16

    """

    17

    19

        self.file = file

    23

    24

    def readline (self) :

    25

        """

    26

            Reads a line from the file, without trailing \n

    27

    28

            Raises EOF on end-of-file.

    29

        """

    30

    31

        line = self.file.readline()

    32

    33

        log.debug("%s", line)

    34

    35

        if not line :

    36

            raise EOFError()

    37

        else :

    38

            return line.rstrip('\n')

    39

    40

    def readlines (self) :

    41

        """

    42

            Reads any available lines from the file.

    43

        """

    44

    45

        while True :

    46

            try :

    47

                line = self.readline()

    48

    49

            except EOFError :

    50

                log.debug("EOF")

    51

                break

    52

    53

            else :

    54

                yield line

    55

    56

    def skip (self) :

    57

        """

    58

            Skip any available lines.

    59

        """

    60

    61

        for line in self.readlines() :

    62

            pass

    63

    64

    __iter__ = readlines

    65

    66

class TailFile (Tail) :

    67

    """

    68

        Follow a file on the filesystem, reading lines until EOF, and re-opening if replaced.

    69

    """

    70

    74

        self.path = path

    81

    82

    def stat (self) :

    83

        """

    84

            Return a key identifying the file at our path.

    85

        """

    86

    87

        st = os.stat(self.path)

    88

    89

        stat = st.st_dev, st.st_ino

    90

    91

        log.debug("%s: %s", self, stat)

    92

    93

        return stat

    94

    95

    def open (self) :

    96

        log.debug("%s", self)

    97

        return open(self.path, 'r')

    98

    99

    def reopen (self) :

   100

        self.file = self.open()

   101

        self._stat = self.stat()

   102

   103

    def changed (self) :

   104

        """

   105

            Has the underlying file changed?

   106

        """

   107

   108

        return self.stat() != self._stat

   109

   110

    def readlines (self, eof_mark=False) :

   111

        """

   112

            Reads any available lines from the file.

   113

   114

            Reopens the file on EOF if the underlying file changed.

   115

   116

                eof_mark:   yields a special None line when this happens.

   117

        """

   118

   119

        while True :

   120

            try :

   121

                line = self.readline()

   122

   123

            except EOFError :

   124

                if self.changed() :

   125

                    log.debug("EOF: reopen")

   126

                    self.reopen()

   127

   128

                    if eof_mark :

   129

                        yield None # special token

   130

   131

                    # keep going

   132

                    continue

   133

   134

                else :

   135

                    log.debug("EOF")

   136

                    break # wait

   137

   138

            else :

   139

                yield line

   140

   141

    __iter__ = readlines

   142

   143

    def __str__ (self) :

   144

        return self.path

   145