1

"""

     2

    Irker client.

     3

"""

     4

     5

import optparse, sys

     6

     7

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

     8

     9

# proto

    10

import socket, json

    11

    12

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

    13

    """

    14

        Optparse option group.

    15

    """

    16

    17

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

    18

    19

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

    20

            help="Irker daemon URL")

    21

    25

    return irker

    26

    27

def apply (options) :

    28

    """

    29

        Return Irker (XXX: target) from options.

    30

    """

    31

    32

    # None -> stdout

    34

    35

def connect (host=None, port=None, family=socket.AF_UNSPEC, socktype=socket.SOCK_STREAM) :

    36

    """

    37

        Return a TCP/UDP socket connected to the given host/port using getaddrinfo.

    38

    39

        TODO: timeout?

    40

    """

    41

    42

    log.debug("%s:%s: %s/%s", host, port, family, socktype)

    43

    44

    if host :

    45

        flags = socket.AI_CANONNAME

    46

    else :

    47

        flags = 0

    48

    49

    addrinfo = socket.getaddrinfo(host, port, family, socktype, 0, flags)

    50

    51

    if not addrinfo :

    52

        raise Exception("getaddrinfo: %s:%s: no results" % (host, port))

    53

    54

    for af, st, proto, name, addr in addrinfo :

    55

        try :

    56

            s = socket.socket(af, st, proto)

    57

    58

        except socket.error as error :

    59

            log.warning("%s:%s: socket: %s", host, port, error)

    60

            continue

    61

    62

        try :

    63

            s.connect(addr)

    64

    65

        except socket.error as error :

    66

            log.warning("%s:%s: connect: %s", host, port, error)

    67

            continue

    68

    69

        log.info("%s", name)

    70

    71

        return s

    72

    73

    else :

    74

        raise Exception("Unable to connect: %s:%s: %s" % (host, port, error))

    75

    76

import urlparse

    77

    78

class Irk (object) :

    79

    """

    80

        Irker JSON connection.

    81

    82

        TODO: timeout?

    83

    """

    84

    85

    PORT = 6659

    86

    87

    SCHEME = {

    88

        'tcp':  (socket.AF_INET, socket.SOCK_STREAM),

    89

        'udp':  (socket.AF_INET, socket.SOCK_DGRAM),

    90

        'unix': (socket.AF_UNIX, socket.SOCK_DGRAM),

    91

    }

    92

    93

    @classmethod

    94

    def connect (cls, url) :

    95

        """

    96

            Connect to given urllib URL, or None -> stdout

    97

        """

    98

    99

        if not url :

   100

            return cls(sys.stdout)

   101

   102

        family, socktype = cls.SCHEME[url.scheme]

   103

   104

        if family == socket.AF_UNIX :

   105

            raise Exception("unix:// is not supported")

   106

        else :

   107

            # inet

   108

            sock = connect(url.hostname, url.port or cls.PORT, family=family, socktype=socktype)

   109

   110

        return cls(sock.makefile('w'))

   111

   112

    def __init__ (self, file) :

   113

        """

   114

            Use given file-like object for output.

   115

        """

   116

   117

        self.file = file

   118

   119

        log.debug("%s", file)

   120

   121

    def send (self, **opts) :

   122

        """

   123

            Raises IOError on write errors.

   124

        """

   125

   126

        log.debug("%s", opts)

   127

   128

        # write line + flush

   129

        json.dump(opts, self.file)

   130

        self.file.write('\n')

   131

        self.file.flush()

   132

   133

class IrkerTarget (object) :

   134

    """

   135

        A channel on an Irk connection.

   136

    """

   137

   139

        self.irker = irker

   140

        self.target = target

   141

   144

    def join (self) :

   145

        log.info("%s", self)

   146

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

   147

   148

    def privmsg (self, *args) :

   149

        for arg in args :

   150

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

   151

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

   152

   164

   165

    def __str__ (self) :

   166

        return self.target

   167

   168

class Irker (object) :

   169

    """

   170

        Reconnecting irker.

   171

    """

   172

   174

        if url :

   175

            self.url = urlparse.urlparse(url)

   176

        else :

   177

            self.url = None

   178

   179

        self.targets = {}

   181

   182

        self.connect()

   183

   184

    def connect (self) :

   185

        """

   186

            Connect, and fix up our targets.

   187

        """

   188

   189

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

   190

   191

        # rejoin

   192

        for target in self.targets.itervalues() :

   193

            target.join()

   194

   195

    def send (self, **opts) :

   196

        """

   197

            Send on current irker connection.

   198

   199

            TODO: handle errors and reconnect?

   200

        """

   201

   202

        self.irk.send(**opts)

   203

   204

    def target (self, target) :

   205

        """

   206

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

   207

        """

   208

   209

        if target not in self.targets :

   211

            self.targets[target].join()

   212

   213

        return self.targets[target]

   214

   215

    __getitem__ = target