25

    # None -> stdout

    26

    return Irker(options.irker)

    29

    """

    30

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

    31

    32

        TODO: timeout?

    33

    """

    34

    35

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

    36

    37

    if host :

    38

        flags = socket.AI_CANONNAME

    39

    else :

    40

        flags = 0

    41

    42

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

    43

    44

    if not addrinfo :

    45

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

    46

    47

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

    53

            continue

    60

            continue

    61

    62

        log.info("%s", name)

    67

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

    68

    69

import urlparse

    73

        Irker JSON connection.

    74

    75

        TODO: timeout?

    86

    @classmethod

    87

    def connect (cls, url) :

    88

        """

    89

            Connect to given urllib URL, or None -> stdout

    90

        """

    91

    92

        if not url :

    93

            return cls(sys.stdout)

    94

    95

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

    96

    97

        if family == socket.AF_UNIX :

    98

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

    99

        else :

   100

            # inet

   101

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

   102

   103

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

   104

   105

    def __init__ (self, file) :

   106

        """

   107

            Use given file-like object for output.

   108

        """

   109

   110

        self.file = file

   111

   112

        log.debug("%s", file)

   113

   114

    def send (self, **opts) :

   115

        """

   116

            Raises IOError on write errors.

   117

        """

   118

   119

        log.debug("%s", opts)

   120

   121

        # write line + flush

   122

        json.dump(opts, self.file)

   123

        self.file.write('\n')

   124

        self.file.flush()

   125

   126

class IrkerTarget (object) :

   127

    """

   128

        A channel on an Irk connection.

   129

    """

   130

   131

    def __init__ (self, irker, target) :

   132

        self.irker = irker

   133

        self.target = target

   134

   135

    def join (self) :

   136

        log.info("%s", self)

   137

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

   138

   139

    def privmsg (self, *args) :

   140

        for arg in args :

   141

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

   142

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

   143

   144

    __call__ = privmsg

   145

   146

    def __str__ (self) :

   147

        return self.target

   148

   149

class Irker (object) :

   150

    """

   151

        Reconnecting irker.

   152

    """

   153

   162

        self.connect()

   165

        """

   166

            Connect, and fix up our targets.

   167

        """

   169

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

   172

        for target in self.targets.itervalues() :

   173

            target.join()

   175

    def send (self, **opts) :

   176

        """

   177

            Send on current irker connection.

   179

            TODO: handle errors and reconnect?

   180

        """

   181

   182

        self.irk.send(**opts)

   186

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

   189

        if target not in self.targets :

   190

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

   191

            self.targets[target].join()

   192

   193

        return self.targets[target]

   195

    __getitem__ = target