1

"""

     2

    IRC client, dispatching irker messages.

     3

"""

     4

     5

from twisted.internet import reactor, interfaces, protocol, defer, error

     6

from twisted.words.protocols import irc

     7

     8

from twisted.internet import endpoints

     9

    10

from twisted.python import log

    11

    12

PORT = 6667

    13

    14

def url2endpoint (reactor, url) :

    15

    """

    16

        Turn given urlparse URL into an endpoint.

    17

    18

        Raises KeyError on unknown scheme.

    19

    """

    20

    21

    SCHEMES = {

    22

            'irc':      lambda : endpoints.TCP4ClientEndpoint(reactor, url.hostname, url.port or PORT),

    23

    }

    24

    25

    return SCHEMES[url.scheme]()

    26

    27

def normalize (name) :

    28

    """

    29

        Normalize a channel/nickname for comparisons in IRC.

    30

    """

    31

    32

    return name.lower()

    33

    34

class IRCError (Exception) :

    35

    """

    36

        A handled protocol error.

    37

    """

    38

    39

    pass

    40

    41

class IRCChannel (object) :

    42

    """

    43

        A joined channel on an IRC server.

    44

    """

    45

    46

    ENCODING = 'utf-8'

    47

    48

    def __init__ (self, client, channel, encoding=ENCODING) :

    49

        self.client = client

    50

        self.channel = channel

    51

    52

        self.encoding = encoding

    53

    54

    def privmsg (self, *msgs) :

    55

        for msg in msgs :

    56

            # XXX: encode

    57

            self.client.msg(self.channel, msg.encode(self.encoding))

    58

    63

    def errback (self, failure) :

    64

        """

    65

            Fail any pending requests.

    66

        """

    67

    68

        log.msg('IRCChannel.errback', self, failure)

    69

    70

    def __str__ (self) :

    71

        return self.client.url(self.channel)

    72

    73

class IRCClient (irc.IRCClient) :

    74

    """

    75

        A connection to an IRC server with a specific, requested nickname.

    76

    77

        Joins to channels.

    78

    """

    79

    80

    performLogin = False

    81

    82

    def __init__ (self, factory) :

    83

        self.factory = factory

    84

    85

        self.nickname = None

    86

        self.hostname = None

    87

    88

        self._registering = None

    89

        self._channels = { }

    90

    91

    def connectionMade (self) :

    92

        self.hostname = self.transport.getPeer().host

    93

        self.transport.logPrefix = self.logPrefix

    94

    95

        log.msg("connectionMade", self, self.transport)

    96

        irc.IRCClient.connectionMade(self)

    97

    98

    def sendLine (self, line) :

    99

        irc.IRCClient.sendLine(self, line)

   100

   101

        log.msg(">>>", line)

   102

   103

    def lineReceived (self, line) :

   104

        log.msg("<<<", line)

   105

   106

        irc.IRCClient.lineReceived(self, line)

   107

   108

    ## Register

   109

    def register (self, nickname, username=None, password=None) :

   110

        """

   111

            Register to the server, choosing a nickname based on the given nickname.

   112

   113

            Returns a Deferred that callbacks with our actual nickname once we have registered, or errbacks with an IRCError.

   114

        """

   115

   116

        if self._registering :

   117

            raise Exception("register: already registering")

   118

   119

        self.username = username

   120

        self.password = password

   121

   122

        log.msg("register", nickname)

   123

        irc.IRCClient.register(self, nickname)

   124

   125

        # defer

   126

        d = self._registering = defer.Deferred()

   127

   128

        return d

   129

   130

    # irc_ERR_NICKNAMEINUSE

   131

    # alterCollidedNick

   132

    # irc_ERR_ERRONEUSNICKNAME

   133

   134

    def irc_ERR_PASSWDMISMATCH (self, prefix, params) :

   135

        err = IRCError('ERR_PASSWDMISMATCH')

   136

        log.err(err)

   137

        self._registering.errback(err)

   138

   139

    def irc_RPL_WELCOME (self, prefix, params) :

   140

        self.hostname = prefix

   141

        irc.IRCClient.irc_RPL_WELCOME(self, prefix, params)

   142

   143

    def signedOn (self) :

   144

        log.msg("signedOn", self.nickname)

   145

        irc.IRCClient.signedOn(self)

   146

   147

        # defer

   148

        d = self._registering

   149

   150

        if not d :

   151

            raise Exception("signedOn: not registering?")

   152

   153

        self._registering = None

   154

   155

        d.callback(self.nickname)

   156

   157

    ## Channels

   158

    def join (self, channel, key=None) :

   159

        """

   160

            Join the given channel.

   161

   162

            Returns a deferred that callbacks with the IRCChannel once joined, or errbacks.

   163

        """

   164

   165

        irc.IRCClient.join(self, channel, key=key)

   166

   167

        d = self._channels[normalize(channel)] = defer.Deferred()

   168

   169

        return d

   170

   171

    # ERR_CHANNELISFULL

   172

    # ERR_INVITEONLYCHAN

   173

    # ERR_BANNEDFROMCHAN

   174

    # ERR_BADCHANNELKEY

   175

   176

    def joined (self, channel) :

   177

        """

   178

            Have joined given channel.

   179

        """

   180

   181

        lookup = normalize(channel)

   182

   183

        d = self._channels[lookup]

   184

        channel = self._channels[lookup] = IRCChannel(self, channel)

   185

        d.callback(channel)

   186

   187

    @defer.inlineCallbacks

   188

    def channel (self, channel, key=None) :

   189

        """

   190

            Defer a joined IRCChannel.

   191

        """

   192

   193

        lookup = normalize(channel)

   194

   195

        log.msg('IRCClient.channel', lookup, channel)

   196

   197

        if lookup not in self._channels :

   198

            channel = yield self.join(channel, key)

   199

        else :

   200

            # wait or get

   201

            yield self._channels[lookup]

   202

   203

        channel = self._channels[lookup]

   204

   205

        log.msg('IRCClient.channel', lookup, channel)

   206

   207

        defer.returnValue(channel)

   208

   209

    ## 

   210

    def irc_ERR_CANNOTSENDTOCHAN (self, prefix, params) :

   211

        nick, channel, error = params

   212

   213

        log.err(IRCError(channel, error))

   214

   215

    ## Quit

   216

    def irc_ERROR (self, prefix, params) :

   217

        msg, = params

   218

   219

        log.err(IRCError(None, msg))

   220

   221

    def connectionLost (self, reason) :

   222

        irc.IRCClient.connectionLost(self, reason)

   223

        log.err(reason)

   224

   225

        if self._registering :

   226

            self._registering.errback(reason)

   227

            self._registering = None

   228

   229

        # unregister channels

   230

        for channel in self._channels :

   231

            # errback Deferred or IRCChannel

   232

            self._channels[channel].errback(reason)

   233

   234

        self._channels = { }

   235

   236

        # unregister client

   237

        self.factory.clientLost(self)

   238

   239

    ## Logging

   240

    def url (self, target=None) :

   241

        """

   242

            Format as URL.

   243

        """

   244

   245

        # XXX: no isinstance() support

   246

        if interfaces.ITCPTransport.providedBy(self.transport) :

   247

            scheme = 'irc'

   248

        else :

   249

            # TODO: ssl?

   250

            scheme = None

   251

   252

        peer = self.transport.getPeer()

   253

   254

        if peer.port == PORT :

   255

            peer = "{irc.hostname}".format(irc=self, peer=peer)

   256

        else :

   257

            peer = "{irc.hostname}:{peer.port}".format(irc=self, peer=peer)

   258

   259

        if target :

   260

            path = str(target)

   261

        else :

   262

            path = None

   263

   264

        return ''.join(part for part in (

   265

            scheme, '://' if scheme else None,

   266

            self.nickname, '@' if self.nickname else None,

   267

            peer,

   268

            '/' if path else None, path

   269

        ) if part)

   270

   271

    __str__ = url

   272

    logPrefix = url

   273

   274

class IRCFactory (protocol.ClientFactory) :

   275

    """

   276

        Manage Clients and Targets

   277

    """

   278

   279

    NICKNAME = 'irker'

   280

   281

    def __init__ (self, nickname=NICKNAME) :

   282

        # default nickname

   283

        self.nickname = nickname

   284

   285

        # (scheme, host, port, nick) -> IRCClient

   286

        self.clients = {}

   287

   288

    def buildProtocol (self, addr) :

   289

        return IRCClient(self)

   290

   291

    def clientLost (self, client) :

   292

        """

   293

            Given IRCClient is no more.

   294

        """

   295

   296

        log.msg("IRCFactory.clientLost", client)

   297

   298

        # remove from our clients

   299

        self.clients = dict((k, c) for k, c in self.clients.iteritems() if c != client)

   300

   301

    @defer.inlineCallbacks

   302

    def connect (self, url) :

   303

        """

   304

            Defer a connected, registered Client for given URL.

   305

        """

   306

   307

        endpoint = url2endpoint(reactor, url)

   308

   309

        log.msg('IRCFactory.connect', url, ':', endpoint)

   310

   311

        # connect

   312

        try :

   313

            client = yield endpoint.connect(self)

   314

   315

        except error.ConnectError as ex :

   316

            log.err(ex, ': '.join(str(x) for x in ('IRCFactory.connect', url, endpoint)))

   317

            raise

   318

   319

        else :

   320

            log.msg('IRCFactory.connect', url, ':', endpoint, ':', client)

   321

   322

        # register

   323

        try :

   324

            nickname = yield client.register(url.username or self.nickname, url.password)

   325

   326

        except Exception as ex :

   327

            log.err("register", ex)

   328

            raise

   329

   330

        log.msg('IRCFactory.connect', url, ':', endpoint, ':', client, ':', nickname)

   331

   332

        # okay!

   333

        defer.returnValue(client)

   334

   335

    @defer.inlineCallbacks

   336

    def client (self, url) :

   337

        """

   338

            Return IRCClient for given URL.

   339

        """

   340

   341

        lookup = (url.scheme, url.hostname, url.port, url.username)

   342

   343

        if lookup not in self.clients :

   344

            # deferred for connect

   345

            connect = self.clients[lookup] = self.connect(url)

   346

   347

            try :

   348

                # wait on deferred, and then store IRCClient

   349

                self.clients[lookup] = yield connect

   350

   351

            except Exception as ex :

   352

                # failed, remove the attempted connect

   353

                del self.clients[lookup]

   354

                raise

   355

   356

        else :

   357

            # wait for result, if deferred

   358

            # XXX: this yields None, since the first inlineCallbacks yielding on the deferred returns None in its callback

   359

            yield self.clients[lookup]

   360

   361

        # connected client

   362

        client = self.clients[lookup]

   363

   364

        log.msg('IRCFactory.client', url, ":", client)

   365

   366

        defer.returnValue(client)

   367

   368

    @defer.inlineCallbacks

   369

    def target (self, url) :

   370

        """

   371

            Return IRCChannel for given URL.

   372

        """

   373

   374

        client = yield self.client(url)

   375

   376

        channel = '#' + url.path.lstrip('/')

   377

        channel = yield client.channel(channel)

   378

   379

        log.msg('IRCFactory.target', url, ":", channel)

   380

   381

        defer.returnValue(channel)

   382

   383

    @defer.inlineCallbacks

   384

    def privmsg (self, url, *msg) :

   385

        """

   386

            Dispatch given messages to given target.

   387

        """

   388

   389

        target = yield self.target(url)

   390

   391

        log.msg('IRCFactory.privmsg', url, ":", target, ':', *msg)

   392

   393

        target.privmsg(*msg)