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

    27

    return irker

    28

    29

def apply (options) :

    30

    """

    31

        Return Irker (XXX: target) from options.

    32

    """

    33

    34

    # None -> stdout

    35

    return Irker(options.irker, options.irker_notice)

    36

    37

class Irk (object) :

    38

    """

    39

        Irker JSON connection speaks JSON over a stream.

    40

    41

        TODO: timeouts?

    42

    """

    43

    44

    PORT = 6659

    45

    46

    @classmethod

    47

    def connect (cls, url) :

    48

        """

    49

            Connect to given URL string, or None -> stdout

    50

        """

    51

    52

        if not url :

    53

            # no read

    54

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

    55

    56

        else :

    57

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

    58

    59

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

    60

            sock.setblocking(False)

    61

    62

            return cls(

    63

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

    64

                    pvl.socket.ReadStream(sock)

    65

            )

    66

    67

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

    68

        """

    69

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

    70

        """

    71

    72

        self.send = send

    73

        self.recv = recv

    74

    75

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

    76

    77

    def fileno (self) :

    78

        """

    79

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

    80

    81

            Only valid if self.recv is True.

    82

        """

    83

    84

        return self.recv.fileno()

    85

    86

    def __call__ (self, **opts) :

    87

        """

    88

            Raises IOError on write errors.

    89

        """

    90

    91

        log.debug("%s", opts)

    92

    93

        # write line + flush

    94

        self.send(json.dumps(opts))

    95

    96

        # XXX: self.send.flush()

    97

    98

    def __iter__ (self) :

    99

        """

   100

            Yield JSON inputs from source.

   101

        """

   102

   103

        if not self.recv :

   104

            # never going to be anything

   105

            return

   106

   107

        for line in self.recv :

   108

            # XXX: error handling?

   109

            yield json.loads(line)

   110

   111

class IrkerTarget (object) :

   112

    """

   113

        A channel on an Irk connection.

   114

    """

   115

   116

    def __init__ (self, irker, target, notice=False) :

   117

        self.irker = irker

   118

        self.target = target

   119

   120

        self._notice = notice

   121

   122

    def join (self) :

   123

        log.info("%s", self)

   124

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

   125

   126

    def privmsg (self, *args) :

   127

        for arg in args :

   128

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

   129

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

   130

   131

    def notice (self, *args) :

   132

        for arg in args :

   133

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

   134

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

   135

   136

    def __call__ (self, *args) :

   137

        # default msg policy

   138

        if self._notice :

   139

            return self.notice(*args)

   140

        else :

   141

            return self.privmsg(*args)

   142

   143

    def __str__ (self) :

   144

        return self.target

   145

   146

class Irker (object) :

   147

    """

   148

        Reconnecting Irk.

   149

    """

   150

   151

    def __init__ (self, url=None, notice=False) :

   152

        self.url = url

   153

        self.targets = {}

   154

        self.notice = notice

   155

   156

        self.connect()

   157

   158

    def connect (self) :

   159

        """

   160

            Connect, and fix up our targets.

   161

        """

   162

   163

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

   164

   165

        # rejoin

   166

        for target in self.targets.itervalues() :

   167

            target.join()

   168

   169

    def __call__ (self, **opts) :

   170

        """

   171

            Send on current irker connection.

   172

   173

            TODO: handle errors and reconnect?

   174

        """

   175

   176

        self.irk(**opts)

   177

   178

    def __getitem__ (self, target) :

   179

        """

   180

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

   181

        """

   182

   183

        if target not in self.targets :

   184

            self.targets[target] = IrkerTarget(self, target, notice=self.notice)

   185

            self.targets[target].join()

   186

   187

        return self.targets[target]