1

"""

     2

    Syslog handling.

     3

"""

     4

     5

import select

     6

     7

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

     8

     9

class SyslogSource (object) :

    10

    """

    11

        A source of syslog items.

    12

    """

    13

    14

    def __init__ (self, source, parser, filter=None, poll=None) :

    15

        """

    16

            Using given underlying line source.

    17

    18

                source          - file-like object with poll() and iter()

    19

                parser          - process() bytes -> items

    20

                filter          - filter items

    21

                poll            - using given polling style:

    22

                    True            - select() source

    23

                    float           - given interval

    24

                    None/False      - single-shot

    25

        """

    26

    27

        self.source = source

    28

        self.parser = parser

    29

        self.filter = filter

    30

    33

        self._poll = poll

    34

    35

    def __iter__ (self) :

    36

        """

    37

            Read syslog messages from source.

    38

        """

    39

    40

        # directly iter across source

    41

        iter = self.source

    42

    43

        # parse

    44

        iter = self.parser(iter)

    45

    46

        # filter ?

    47

        if self.filter :

    48

            iter = self.filter(iter)

    49

    50

        return iter

    51

    52

    def poll (self, timeout=None) :

    53

        """

    54

            Poll source for input, with given timeout in seconds (float).

    55

    56

            A timeout of None indicates to block forever, False indicates to never block.

    57

    58

            Returns True if we have input waiting, False on timeout with no input. None on indeterminate.

    59

        """

    60

    61

        read = write = ()

    62

    63

        if timeout is True :

    64

            timeout = None

    65

            read += (self.source, )

    66

    67

        elif timeout is False :

    68

            timeout = 0.0

    69

    71

    72

        # select

    73

        read, write, ex = select.select(read, write, [], timeout)

    74

    75

        if read :

    76

            return True

    77

    78

        else :

    79

            # timeout

    80

            return False

    81

    82

    def loop (self) :

    83

        """

    84

            Continuously read items from syslog source, blocking as suitable.

    85

    86

            Returns once no more lines are available.

    87

    88

            XXX: reconnect?

    89

        """

    90

    91

        # mainloop

    92

        while True :

    95

            # pull in messages

    96

            for item in self :

    98

                yield item

    99

   100

            # poll

   101

            if self._poll :

   102

                # wait

   103

                self.poll(self._poll)

   104

            else :

   105

                # done

   106

                break

   107

   108

        log.debug("exit")

   109

   110

    def stop (self) :

   111

        """

   112

            Stop loop after current iteration.

   113

        """

   114

   115

        self._poll = False

   116

   117

    def main (self) :

   118

        """

   119

            Mainloop.

   120

        """

   121

   122

        # TODO: SIGINT -> stop()

   123

        return loop()