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

    60

    def privmsg (self, *msgs) :

    61

        for msg in msgs :

    62

            # XXX: encode

    64

    65

    def notice (self, *msgs) :

    66

        for msg in msgs :

    75

    76

    def errback (self, failure) :

    77

        """

    78

            Fail any pending requests.

    79

        """

    80

    81

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

    82

    83

    def __str__ (self) :

    84

        return self.client.url(self.channel)

    85

    86

class IRCClient (irc.IRCClient) :

    87

    """

    88

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

    89

    90

        Joins to channels.

    91

    """

    92

    93

    performLogin = False

    94

    95

    def __init__ (self, factory) :

    96

        self.factory = factory

    97

    98

        self.nickname = None

    99

        self.hostname = None

   100

   101

        self._registering = None

   102

        self._channels = { }

   103

   104

        # TODO: smarter/configurable queueing?

   105

        self.lineRate = 1.0

   106

   107

    def connectionMade (self) :

   108

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

   109

        self.transport.logPrefix = self.logPrefix

   110

   111

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

   112

        irc.IRCClient.connectionMade(self)

   113

   114

    def sendLine (self, line) :

   115

        irc.IRCClient.sendLine(self, line)

   116

   117

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

   118

   119

    def lineReceived (self, line) :

   120

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

   121

   122

        irc.IRCClient.lineReceived(self, line)

   123

   124

    ## Register

   125

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

   126

        """

   127

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

   128

   129

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

   130

        """

   131

   132

        if self._registering :

   133

            raise Exception("register: already registering")

   134

   135

        self.username = username

   136

        self.password = password

   137

   138

        log.msg("register", nickname)

   139

        irc.IRCClient.register(self, nickname)

   140

   141

        # defer

   142

        d = self._registering = defer.Deferred()

   143

   144

        return d

   145

   146

    # irc_ERR_NICKNAMEINUSE

   147

    # alterCollidedNick

   148

    # irc_ERR_ERRONEUSNICKNAME

   149

   150

    def irc_ERR_PASSWDMISMATCH (self, prefix, params) :

   151

        err = IRCError('ERR_PASSWDMISMATCH')

   152

        log.err(err)

   153

        self._registering.errback(err)

   154

   155

    def irc_RPL_WELCOME (self, prefix, params) :

   156

        self.hostname = prefix

   157

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

   158

   159

    def signedOn (self) :

   160

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

   161

        irc.IRCClient.signedOn(self)

   162

   163

        # defer

   164

        d = self._registering

   165

   166

        if not d :

   167

            raise Exception("signedOn: not registering?")

   168

   169

        self._registering = None

   170

   171

        d.callback(self.nickname)

   172

   173

    ## Channels

   174

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

   175

        """

   176

            Join the given channel.

   177

   178

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

   179

        """

   180

   181

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

   182

   183

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

   184

   185

        return d

   186

   187

    # ERR_CHANNELISFULL

   188

    # ERR_INVITEONLYCHAN

   189

    # ERR_BANNEDFROMCHAN

   190

    # ERR_BADCHANNELKEY

   191

   192

    def _close_channel (self, channel) :

   193

        """

   194

            Remove channel from our list of channels.

   195

   196

            TODO: purge queued messages for channel?

   197

        """

   198

   199

        del self._channels[normalize(channel)]

   200

   201

    def left (self, channel) :

   202

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

   203

   204

        self._close_channel(channel)

   205

   206

    def kickedFrom (self, channel, kicker, message) :

   207

        log.msg('IRCClient.kicked', channel, kicker, message)

   208

   209

        self._close_channel(channel)

   210

   211

    def joined (self, channel) :

   212

        """

   213

            Have joined given channel.

   214

        """

   215

   216

        lookup = normalize(channel)

   217

   218

        d = self._channels[lookup]

   219

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

   220

        d.callback(channel)

   221

   222

    @defer.inlineCallbacks

   223

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

   224

        """

   225

            Defer a joined IRCChannel.

   226

        """

   227

   228

        lookup = normalize(channel)

   229

   230

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

   231

   232

        if lookup not in self._channels :

   233

            channel = yield self.join(channel, key)

   234

        else :

   235

            # wait or get

   236

            yield self._channels[lookup]

   237

   238

        channel = self._channels[lookup]

   239

   240

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

   241

   242

        defer.returnValue(channel)

   243

   244

    ## 

   245

    def irc_ERR_CANNOTSENDTOCHAN (self, prefix, params) :

   246

        nick, channel, error = params

   247

   248

        log.err(IRCError(channel, error))

   249

   250

    ## Quit

   251

    def irc_ERROR (self, prefix, params) :

   252

        msg, = params

   253

        error = IRCError(None, msg)

   254

   255

        log.err(error)

   256

   257

        if self._registering :

   258

            self._registering.errback(error)

   259

            self._registering = None

   260

   261

    def connectionLost (self, reason) :

   262

        irc.IRCClient.connectionLost(self, reason)

   263

        log.err(reason)

   264

   265

        if self._registering :

   266

            self._registering.errback(reason)

   267

            self._registering = None

   268

   269

        # unregister channels

   270

        for channel in self._channels :

   271

            # errback Deferred or IRCChannel

   272

            self._channels[channel].errback(reason)

   273

   274

        self._channels = { }

   275

   276

        # unregister client

   277

        self.factory.clientLost(self)

   278

   279

    ## Logging

   280

    def url (self, target=None) :

   281

        """

   282

            Format as URL.

   283

        """

   284

   285

        if not self.transport : return 'IRC'

   286

   287

        # XXX: no isinstance() support

   288

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

   289

            scheme = 'irc'

   290

        else :

   291

            # TODO: ssl?

   292

            scheme = None

   293

   294

        peer = self.transport.getPeer()

   295

   296

        if peer.port == PORT :

   297

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

   298

        else :

   299

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

   300

   301

        if target :

   302

            path = str(target)

   303

        else :

   304

            path = None

   305

   306

        return ''.join(part for part in (

   307

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

   308

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

   309

            peer,

   310

            '/' if path else None, path

   311

        ) if part)

   312

   313

    __str__ = url

   314

    logPrefix = url

   315

   316

class IRCFactory (protocol.ClientFactory) :

   317

    """

   318

        Manage Clients and Targets

   319

    """

   320

   321

    NICKNAME = 'irker'

   322

   323

    def __init__ (self, nickname=NICKNAME, username=None) :

   324

        # default nickname

   325

        self.nickname = nickname

   326

        self.username = username

   327

   328

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

   329

        self.clients = {}

   330

   331

    def buildProtocol (self, addr) :

   332

        return IRCClient(self)

   333

   334

    def clientLost (self, client) :

   335

        """

   336

            Given IRCClient is no more.

   337

        """

   338

   339

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

   340

   341

        # remove from our clients

   342

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

   343

   344

    @defer.inlineCallbacks

   345

    def connect (self, url) :

   346

        """

   347

            Defer a connected, registered Client for given URL.

   348

        """

   349

   350

        endpoint = url2endpoint(reactor, url)

   351

   352

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

   353

   354

        # connect

   355

        try :

   356

            client = yield endpoint.connect(self)

   357

   358

        except error.ConnectError as ex :

   359

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

   360

            raise

   361

   362

        else :

   363

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

   364

   365

        # register

   366

        try :

   367

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

   368

                    username    = self.username,

   369

                    password    = url.password, 

   370

            )

   371

   372

        except Exception as ex :

   373

            log.err("register", ex)

   374

            raise

   375

   376

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

   377

   378

        # okay!

   379

        defer.returnValue(client)

   380

   381

    @defer.inlineCallbacks

   382

    def client (self, url) :

   383

        """

   384

            Return IRCClient for given URL.

   385

        """

   386

   387

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

   388

   389

        if lookup not in self.clients :

   390

            # deferred for connect

   391

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

   392

   393

            try :

   394

                # wait on deferred, and then store IRCClient

   395

                self.clients[lookup] = yield connect

   396

   397

            except Exception as ex :

   398

                # failed, remove the attempted connect

   399

                del self.clients[lookup]

   400

                raise

   401

   402

        else :

   403

            # wait for result, if deferred

   404

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

   405

            yield self.clients[lookup]

   406

   407

        # connected client

   408

        client = self.clients.get(lookup)

   409

   410

        if client :

   411

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

   412

   413

            defer.returnValue(client)

   414

        else :

   415

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

   416

   417

            # XXX: get failure from first yield's errback... except inlineCallbacks drops it and goes to callback with None <_<

   418

            raise Exception("Client connect failed")

   419

   420

    @defer.inlineCallbacks

   421

    def target (self, url) :

   422

        """

   423

            Return IRCChannel for given URL.

   424

        """

   425

   426

        client = yield self.client(url)

   427

   428

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

   429

        channel = yield client.channel(channel)

   430

   431

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

   432

   433

        defer.returnValue(channel)

   434

   435

    @defer.inlineCallbacks

   436

    def privmsg (self, url, *msg) :

   437

        """

   438

            Dispatch given messages to given target.

   439

        """

   440

   441

        target = yield self.target(url)

   442

   443

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

   444

   445

        target.privmsg(*msg)