1

"""

     2

    `tail -f` style continuous file reads.

     3

     4

    Checks if the file was renamed on EOF, and reopens if so.

     5

"""

     6

     7

import os

     8

     9

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

    10

    11

class TailFile (object) :

    12

    """

    13

        A file on the filesystem, that is appended to.

    14

    """

    15

    16

    def __init__ (self, path) :

    17

        self.path = path

    18

        self._file = None

    19

        self._id = None

    20

    21

        self._open()

    22

    23

    @property

    24

    def file (self) :

    25

        """

    26

            The underlying file objct, if opened.

    27

        """

    28

    29

        if self._file is None :

    30

            raise ValueError("I/O operation on closed file: {0}".format(self.path))

    31

    32

        return self._file

    33

    34

    @property

    35

    def fd (self) :

    36

        return self.file.fileno()

    37

    38

    def fileno (self) :

    39

        """

    40

            The underlying OS fd.

    41

        """

    42

    43

        return self.fd

    44

    45

    def _stat (self) :

    46

        """

    47

            Return a key identifying the file at our path.

    48

        """

    49

    50

        st = os.stat(self.path)

    51

    52

        return st.st_dev, st.st_ino

    53

    54

    def _open (self) :

    55

        assert self._file is None

    56

    57

        self._file = open(self.path, 'r')

    58

        self._id = self._stat()

    59

    60

    def _close (self) :

    61

        assert self._file is not None

    62

    63

        self._file.close()

    64

        self._file = None

    65

    66

    def _reopen (self) :

    67

        """

    68

            Re-open, in case the file changed..

    69

        """

    70

    71

        self._close()

    72

        self._open()

    73

    74

    def _changed (self) :

    75

        """

    76

            Has the underlying file changed?

    77

        """

    78

    79

        return self._stat() != self._id

    80

    81

    def poll (self, timeout) :

    82

        """

    83

            XXX: not really implemented...

    84

        """

    85

    86

        import time

    87

    88

        time.sleep(timeout)

    89

    90

    def readline (self) :

    91

        """

    92

            Reads a line from the file.

    93

    94

            Raises EOF on end-of-file.

    95

        """

    96

    97

        line = self.file.readline()

    98

    99

        # eof?

   100

        if not line :

   101

            raise EOFError()

   102

   103

        return line

   104

   105

    def readlines (self, eof_mark=False) :

   106

        """

   107

            Reads any available lines from the file.

   108

   109

            Reopens the file on EOF if the underlying file changed.

   110

   111

                eof_mark:   yields a special None line when this happens.

   112

        """

   113

   114

        while True :

   115

            try :

   116

                line = self.readline()

   117

   118

            except EOFError :

   119

                if self._changed() :

   120

                    log.debug("EOF: file changed: reopen")

   121

                    self._reopen()

   122

   123

                    if eof_mark :

   124

                        # special token

   125

                        yield None

   126

   127

                else :

   128

                    log.debug("EOF: wait")

   129

                    # done reading

   130

                    return

   131

   132

            else :

   133

                yield line.strip()

   134

   135

    __iter__ = readlines

   136

   137

    def close (self) :

   138

        """

   139

            Close the fifo.

   140

        """

   141

   142

        if self._file is None :

   143

            raise ValueError("File already closed: {0}".format(self.path))

   144

   145

        self._close()

   146

   147

    def __del__ (self) :

   148

        """

   149

            Cleanup

   150

        """

   151

   152

        if self._file is not None :

   153

            self._close()

   154