1

"""

     2

    Irker client.

     3

"""

     4

     5

import pvl.syslog.file # for stdin

     6

import pvl.socket # for tcp

     7

     8

import optparse, sys

     9

    10

import logging; log = logging.getLogger('pvl.irk')

    11

    12

import json

    13

    14

def parser (parser, connect='tcp://localhost/', target=None) :

    15

    """

    16

        Optparse option group.

    17

    """

    18

    19

    irker = optparse.OptionGroup(parser, 'Irker output')

    20

    21

    irker.add_option('--irker', metavar='URL',  default=connect,

    22

            help="Irker daemon URL")

    23

    24

    irker.add_option('--irker-notice',          action='store_true',

    25

            help="Use irker NOTICE")

    26

    30

    return irker

    31

    32

def apply (options) :

    33

    """

    34

        Return Irker (XXX: target) from options.

    35

    """

    36

    37

    # None -> stdout

    39

    40

class Irk (object) :

    41

    """

    42

        Irker JSON connection speaks JSON over a stream.

    43

    44

        TODO: timeouts?

    45

    """

    46

    47

    PORT = 6659

    48

    49

    @classmethod

    50

    def connect (cls, url) :

    51

        """

    52

            Connect to given URL string, or None -> stdout

    53

        """

    54

    55

        if not url :

    56

            # no read

    57

            return cls(pvl.syslog.file.File(sys.stdout), recv=False)

    58

    59

        else :

    60

            sock = pvl.socket.connect(url, port=cls.PORT)

    61

    62

            # just to make things a bit more exciting... and we really don't want to be blocking on our output..

    63

            sock.setblocking(False)

    64

    65

            return cls(

    66

                    pvl.socket.WriteStream(sock, buffer=None),

    67

                    pvl.socket.ReadStream(sock)

    68

            )

    69

    70

    def __init__ (self, send, recv=None) :

    71

        """

    72

            Use given file-like object (write, flush, fileno) for output.

    73

        """

    74

    75

        self.send = send

    76

        self.recv = recv

    77

    78

        log.debug("%s <-> %s", send, recv)

    79

    80

    def fileno (self) :

    81

        """

    82

            Return fd. Useful for detecting error conditions (connection lost).

    83

    84

            Only valid if self.recv is True.

    85

        """

    86

    87

        return self.recv.fileno()

    88

    89

    def __call__ (self, **opts) :

    90

        """

    91

            Raises IOError on write errors.

    92

        """

    93

    94

        log.debug("%s", opts)

    95

    96

        # write line + flush

    97

        self.send(json.dumps(opts))

    98

    99

        # XXX: self.send.flush()

   100

   101

    def __iter__ (self) :

   102

        """

   103

            Yield JSON inputs from source.

   104

        """

   105

   106

        if not self.recv :

   107

            # never going to be anything

   108

            return

   109

   110

        for line in self.recv :

   111

            # XXX: error handling?

   112

            yield json.loads(line)

   113

   114

class IrkerTarget (object) :

   115

    """

   116

        A channel on an Irk connection.

   117

    """

   118

   120

        self.irker = irker

   121

        self.target = target

   122

   123

        self._notice = notice

   125

   126

    def join (self) :

   127

        log.info("%s", self)

   128

        self.irker(to=str(self), privmsg='')

   129

   130

    def privmsg (self, *args) :

   131

        for arg in args :

   132

            log.info("%s: %s", self, arg)

   133

            self.irker(to=str(self), privmsg=arg)

   134

   135

    def notice (self, *args) :

   136

        for arg in args :

   137

            log.info("%s: %s", self, arg)

   138

            self.irker(to=str(self), notice=arg)

   139

   148

    def __call__ (self, *args) :

   149

        # default msg policy

   150

        if self._notice :

   151

            return self.notice(*args)

   152

        else :

   153

            return self.privmsg(*args)

   154

   155

    def __str__ (self) :

   156

        return self.target

   157

   158

class Irker (object) :

   159

    """

   160

        Reconnecting Irk.

   161

    """

   162

   169

        self.url = url

   170

        self.targets = {}

   172

   173

        self.connect()

   174

   175

    def connect (self) :

   176

        """

   177

            Connect, and fix up our targets.

   178

        """

   179

   180

        self.irk = Irk.connect(self.url)

   181

   182

        # rejoin

   183

        for target in self.targets.itervalues() :

   184

            target.join()

   185

   186

    def __call__ (self, **opts) :

   187

        """

   188

            Send on current irker connection.

   189

   190

            TODO: handle errors and reconnect?

   191

        """

   192

   193

        self.irk(**opts)

   194

   195

    def __getitem__ (self, target) :

   196

        """

   197

            Bind to given target URL, returning an IrkerTarget for sending messages.

   198

        """

   199

   200

        if target not in self.targets :

   205

            self.targets[target].join()

   206

   207

        return self.targets[target]