1

"""

     2

    Iterate over input lines in filesystem files. 

     3

"""

     4

     5

import os

     6

     7

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

     8

     9

class Tail (object) :

    10

    """

    11

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

    12

    13

        Never blocks, no fileno() to poll. Just poll(timeout=POLL).

    14

    15

        Not writable.

    16

    """

    17

    18

    POLL = 2.0 

    19

    20

    def __init__ (self, path, skip=None, **opts) :

    21

        log.debug("%s", path)

    22

    23

        self.path = path

    24

        self.file = self.stat = None # closed

    25

    26

        self.open()

    27

    28

        if skip :

    29

            self.skip()

    30

    31

    def _stat (self) :

    32

        """

    33

            Return a key identifying the file at our path.

    34

        """

    35

    36

        st = os.stat(self.path)

    37

    38

        stat = st.st_dev, st.st_ino

    39

    40

        return stat

    41

    42

    def _open (self) :

    43

        """

    44

            Return the opened file.

    45

        """

    46

    47

        return open(self.path, 'r')

    48

    49

    def open (self) :

    50

        """

    51

            Re-opens our file when closed.

    52

    53

            Raises ValueError if already open.

    54

        """

    55

    56

        if self.file is None :

    57

            # XXX: use fstat for "atomic" open+stat?

    58

            self.file = self._open()

    59

            self.stat = self._stat()

    60

    61

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

    62

    63

        else :

    64

            raise ValueError("%s: open already open tail" % (self, ))

    65

    66

    def changed (self) :

    67

        """

    68

            Has the underlying file changed?

    69

        """

    70

    71

        return self._stat() != self.stat

    72

    73

    def readline (self) :

    74

        """

    75

            Reads a line from the file, without trailing \n.

    76

    77

            Returns None on EOF.

    78

        """

    79

    80

        line = self.file.readline()

    81

    82

        if not line :

    83

            line = None

    84

        else : 

    85

            line = line.rstrip('\r\n')

    86

    87

        log.debug("%s", line)

    88

    89

        return line

    90

    91

    def readlines (self, eof_mark=False) :

    92

        """

    93

            Reads any available lines from the file.

    94

    95

            Reopens the file on EOF if the underlying file changed.

    96

    97

                eof_mark:   yields a special None line when this happens.

    98

        """

    99

   100

        while True :

   101

            line = self.readline()

   102

   103

            if line is not None :

   104

                yield line

   105

   106

            elif self.changed() :

   107

                log.debug("EOF: reopen")

   108

   109

                self.close()

   110

                self.open()

   111

   112

                if eof_mark :

   113

                    yield None # special token

   114

   115

                # keep going

   116

                continue

   117

   118

            else :

   119

                log.debug("EOF: wait")

   120

                break

   121

   122

    __iter__ = readlines

   123

   124

    def skip (self) :

   125

        """

   126

            Skip any available lines.

   127

        """

   128

   129

        log.debug("%s", self)

   130

   131

        for line in self.readlines() :

   132

            pass

   133

   134

    def close (self) :

   135

        """

   136

            Close our file, if open. Further operations raise ValueError.

   137

   138

            log.warn's if already closed.

   139

        """

   140

   141

        if self.file :

   142

            log.debug("%s", self)

   143

            self.file.close()

   145

        else :

   146

            log.warn("%s: close on already closed tail", self)

   147

   148

    def __str__ (self) :

   149

        return self.path

   150