5

import optparse, sys

     6

     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

    22

    return irker

    23

    24

def apply (options) :

    25

    """

    26

        Return Irker (XXX: target) from options.

    27

    """

    28

    29

    # None -> stdout

    30

    return Irker(options.irker)

    31

    32

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

    33

    """

    34

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

    35

    36

        TODO: timeout?

    37

    """

    38

    39

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

    40

    41

    if host :

    42

        flags = socket.AI_CANONNAME

    43

    else :

    44

        flags = 0

    45

    46

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

    47

    48

    if not addrinfo :

    49

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

    50

    51

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

    52

        try :

    53

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

    54

    55

        except socket.error as error :

    56

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

    57

            continue

    58

    59

        try :

    60

            s.connect(addr)

    61

    62

        except socket.error as error :

    63

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

    64

            continue

    65

    66

        log.info("%s", name)

    67

    68

        return s

    69

    70

    else :

    71

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

    72

    73

import urlparse

    74

    75

class Irk (object) :

    76

    """

    77

        Irker JSON connection.

    78

    79

        TODO: timeout?

    80

    """

    81

    82

    PORT = 6659

    83

    84

    SCHEME = {

    85

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

    86

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

    87

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

    88

    }

    89

    90

    @classmethod

    91

    def connect (cls, url) :

    92

        """

    93

            Connect to given urllib URL, or None -> stdout

    94

        """

    95

    96

        if not url :

    97

            return cls(sys.stdout)

    98

    99

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

   100

   101

        if family == socket.AF_UNIX :

   102

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

   103

        else :

   104

            # inet

   105

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

   106

   107

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

   108

   109

    def __init__ (self, file) :

   110

        """

   111

            Use given file-like object for output.

   112

        """

   113

   114

        self.file = file

   115

   116

        log.debug("%s", file)

   117

   118

    def send (self, **opts) :

   119

        """

   120

            Raises IOError on write errors.

   121

        """

   122

   123

        log.debug("%s", opts)

   124

   125

        # write line + flush

   126

        json.dump(opts, self.file)

   127

        self.file.write('\n')

   128

        self.file.flush()

   129

   130

class IrkerTarget (object) :

   131

    """

   132

        A channel on an Irk connection.

   133

    """

   134

   135

    def __init__ (self, irker, target) :

   136

        self.irker = irker

   137

        self.target = target

   138

   139

    def join (self) :

   140

        log.info("%s", self)

   141

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

   142

   143

    def privmsg (self, *args) :

   144

        for arg in args :

   145

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

   146

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

   147

   148

    __call__ = privmsg

   149

   150

    def __str__ (self) :

   151

        return self.target

   152

   153

class Irker (object) :

   154

    """

   155

        Reconnecting irker.

   156

    """

   157

   158

    def __init__ (self, url=None) :

   159

        if url :

   160

            self.url = urlparse.urlparse(url)

   161

        else :

   162

            self.url = None

   163

   164

        self.targets = {}

   165

   166

        self.connect()

   167

   168

    def connect (self) :

   169

        """

   170

            Connect, and fix up our targets.

   171

        """

   172

   173

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

   174

   175

        # rejoin

   176

        for target in self.targets.itervalues() :

   177

            target.join()

   178

   179

    def send (self, **opts) :

   180

        """

   181

            Send on current irker connection.

   182

   183

            TODO: handle errors and reconnect?

   184

        """

   185

   186

        self.irk.send(**opts)

   187

   188

    def target (self, target) :

   189

        """

   190

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

   191

        """

   192

   193

        if target not in self.targets :

   194

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

   195

            self.targets[target].join()

   196

   197

        return self.targets[target]

   198

   199

    __getitem__ = target