1

import optparse, sys

     2

     3

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

     4

     5

# proto

     6

import socket, json

     7

     8

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

     9

    """

    10

        Optparse option group.

    11

    """

    12

    13

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

    14

    15

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

    16

            help="Irker daemon URL")

    17

    18

    irker.add_option('--irker-target', metavar='IRC',   default=target,

    19

            help="Irker target URL")

    20

    21

    return irker

    22

    23

def apply (options, target=None) :

    24

    """

    25

        Return Irker (XXX: target) from options.

    26

    """

    27

    28

    # XXX: None -> stdout

    29

    irk = Irker(options.irker_connect)

    30

    31

    if options.irker_target :

    32

        target = options.irker_target

    33

    34

    if target :

    35

        target = irk.target(target)

    36

    37

    return irk, target

    38

    39

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

    40

    for af, st, proto, name, addr in socket.getaddrinfo(host, port, family, socktype) :

    41

        try :

    42

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

    43

    44

        except socket.error as error :

    45

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

    46

    47

        log.info("%s", name)

    48

    49

        try :

    50

            s.connect(addr)

    51

    52

        except socket.error as error :

    53

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

    54

    55

        return s

    56

    57

    else :

    58

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

    59

    60

class Irk (object) :

    61

    """

    62

        Irker connection.

    63

    """

    64

    65

    PORT = 6659

    66

    67

    @classmethod

    68

    def socket (cls, socket) :

    69

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

    70

    71

    def __init__ (self, file) :

    72

        self.file = file

    73

    74

        log.debug("%s", file)

    75

    76

    def send (self, **opts) :

    79

        json.dump(opts, self.file)

    80

        self.file.write('\n')

    81

        self.file.flush()

    82

    83

    def join (self, to) :

    85

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

    86

    87

    def privmsg (self, to, *args) :

    88

        for arg in args :

    90

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

    91

    92

import urlparse

    93

import functools

    94

    95

class Irker (object) :

    96

    """

    97

        Reconnecting irker.

    98

    99

        XXX: reconnect with state, or just crash and burn to be restarted?

   100

    """

   101

   102

    SCHEME = {

   103

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

   104

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

   105

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

   106

    }

   107

   108

    def __init__ (self, url=None) :

   109

        if url :

   110

            self.url = urlparse.urlparse(url)

   111

        else :

   112

            self.url = None

   113

   114

        self.targets = {}

   115

   116

        self.irk = self.connect()

   117

   118

    def connect (self) :

   119

        if not self.url :

   120

            # XXX: not here, do this in apply()?

   121

            return Irk(sys.stdout)

   122

   123

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

   124

   125

        if family == socket.AF_UNIX :

   126

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

   127

        else :

   128

            # inet

   129

            s = connect(self.url.hostname, self.url.port or Irk.PORT, family=family, socktype=socktype)

   130

   131

        irk = Irk.socket(s)

   132

   133

        # rejoin

   134

        for target in self.targets :

   135

            irk.join(target)

   136

   137

        return irk

   138

   139

    def _target (self, target, *args) :

   140

        try :

   141

            for msg in args :

   142

                self.irk.send(to=target, privmsg=msg)

   143

        except IOError as ex :

   144

            log.warning("lost irk: %s", ex)

   145

   146

            # XXX: reconnect?

   147

            self.irk = self.connect()

   148

   149

    def target (self, target) :

   150

        """

   151

            Bind to given target URL, returning a callable for sending messages.

   152

        """

   153

   154

        if target in self.targets :

   155

            _target = self.targets[target]

   156

        else :

   157

            self.irk.join(target)

   158

            _target = self.targets[target] = functools.partial(self._target, target)

   159

   160

        return _target

   161

   162