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

    17

        self.path = path

    18

        self._file = None

    19

        self._id = None

    20

    21

        self._open()

    26

    27

    @property

    28

    def file (self) :

    29

        """

    30

            The underlying file objct, if opened.

    31

        """

    32

    33

        if self._file is None :

    34

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

    35

    36

        return self._file

    37

    38

    @property

    39

    def fd (self) :

    40

        return self.file.fileno()

    41

    42

    def fileno (self) :

    43

        """

    44

            The underlying OS fd.

    45

        """

    46

    47

        return self.fd

    48

    49

    def _stat (self) :

    50

        """

    51

            Return a key identifying the file at our path.

    52

        """

    53

    54

        st = os.stat(self.path)

    55

    56

        return st.st_dev, st.st_ino

    57

    58

    def _open (self) :

    59

        assert self._file is None

    60

    61

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

    62

        self._id = self._stat()

    63

    64

    def _close (self) :

    65

        assert self._file is not None

    66

    67

        self._file.close()

    68

        self._file = None

    69

    70

    def _reopen (self) :

    71

        """

    72

            Re-open, in case the file changed..

    73

        """

    74

    75

        self._close()

    76

        self._open()

    77

    78

    def _changed (self) :

    79

        """

    80

            Has the underlying file changed?

    81

        """

    82

    83

        return self._stat() != self._id

    84

    85

    def poll (self, timeout) :

    86

        """

    87

            XXX: not really implemented...

    88

        """

    89

    90

        import time

    91

    92

        time.sleep(timeout)

    93

    94

    def readline (self) :

    95

        """

    96

            Reads a line from the file.

    97

    98

            Raises EOF on end-of-file.

    99

        """

   100

   101

        line = self.file.readline()

   102

   103

        # eof?

   104

        if not line :

   105

            raise EOFError()

   106

   107

        return line

   108

   109

    def readlines (self, eof_mark=False) :

   110

        """

   111

            Reads any available lines from the file.

   112

   113

            Reopens the file on EOF if the underlying file changed.

   114

   115

                eof_mark:   yields a special None line when this happens.

   116

        """

   117

   118

        while True :

   119

            try :

   120

                line = self.readline()

   121

   122

            except EOFError :

   123

                if self._changed() :

   124

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

   125

                    self._reopen()

   126

   127

                    if eof_mark :

   128

                        # special token

   129

                        yield None

   130

   131

                else :

   132

                    log.debug("EOF: wait")

   133

                    # done reading

   134

                    return

   135

   136

            else :

   137

                yield line.strip()

   138

   139

    __iter__ = readlines

   140

   141

    def close (self) :

   142

        """

   143

            Close the fifo.

   144

        """

   145

   146

        if self._file is None :

   147

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

   148

   149

        self._close()

   150

   151

    def __del__ (self) :

   152

        """

   153

            Cleanup

   154

        """

   155

   156

        if self._file is not None :

   157

            self._close()

   158