1

"""

     2

    Syslog handling.

     3

     4

    XXX: this belongs in pvl.syslog.source (apart from __iter__?)

     5

"""

     6

     7

import select

     8

     9

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

    10

    11

class SyslogSource (object) :

    12

    """

    13

        Process syslog input from a given source.

    14

    15

        Implements an iterable mainloop doing continuous polling on the source, using either a timeout or

    16

        select():able source.

    17

    """

    18

    19

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

    20

        """

    21

            Using given underlying line source.

    22

    23

                source      - source to select() if poll=True

    24

                poll        - polling behaviour for source

    25

        """

    26

    27

        self.source = source

    28

        self.parser = parser

    29

        self.filter = filter

    30

    31

        self.poll = poll

    32

    33

    def __iter__ (self) :

    34

        """

    35

            Yield available input.

    36

    37

            Raises EOFError if source has been closed.

    38

        """

    39

    40

        return self.filter(self.parser(self.source))

    41

    42

    def fileno (self) :

    43

        return self.source.fileno()

    44

    45

    def select (self, poll=None, reading=(), writing=()) :

    46

        """

    47

            Poll our source for input, with given polling behaviour:

    48

                True    - select() on source

    49

                False   - peek on source

    50

                float   - timeout in seconds

    51

    52

            Returns None on unknown, empty sequence on timeout, list of readables on select.

    53

        """

    54

    55

        if poll is True :

    56

            timeout = None # block

    57

            reading += (self, ) # source.fileno()

    58

    59

        elif not poll :

    60

            timeout = 0.0 # do not block

    61

    62

        else :

    63

            timeout = float(poll)

    64

    65

        log.debug("%s (%s)", reading, timeout)

    66

    67

        # select

    68

        readable, writeable, ex = select.select(reading, writing, [], timeout)

    69

    70

        log.debug("select: %s", readable)

    71

    72

        if readable :

    73

            return readable

    74

    75

        elif reading :

    76

            # timeout

    77

            # XXX: this is the same as readable

    78

            return ()

    79

    80

        else :

    81

            # unknown

    82

            return None

    83

    84

    def main (self, poll=None) :

    85

        """

    86

            Yield active syslog sources, polling as given.

    87

    88

            Returns once no more lines are available.

    89

    90

            XXX: reconnect? or source takes care of that..

    91

            TODO: SIGINT -> finish iteration and return?

    92

        """

    93

    94

        # from __init__

    95

        # note that we must interpret poll here, since False -> never poll

    96

        if poll is None :

    97

            poll = self.poll

    98

    99

        # mainloop

   100

        while True :

   101

            # caller is responsible for reading them!

   102

            yield self

   103

   104

            # poll

   105

            if poll :

   106

                # wait

   107

                self.select(poll)

   108

   109

            else :

   110

                # done

   111

                break

   112

   113

        log.debug("exit")

   114

   115

    def close (self) :

   116

        """

   117

            Close the syslog source, if possible.

   118

   119

        """

   120

   121

        # XXX: do all sources support close?

   122

        self.source.close()

   123

   124

    def __str__ (self) :

   125

        return ' | '.join((str(self.source), str(self.parser), str(self.filter)))

   126