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

    59

    def notice (self, *msgs) :

    60

        for msg in msgs :

    61

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

    62

    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

    94

    def connectionMade (self) :

    95

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

    96

        self.transport.logPrefix = self.logPrefix

    97

    98

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

    99

        irc.IRCClient.connectionMade(self)

   100

   101

    def sendLine (self, line) :

   102

        irc.IRCClient.sendLine(self, line)

   103

   104

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

   105

   106

    def lineReceived (self, line) :

   107

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

   108

   109

        irc.IRCClient.lineReceived(self, line)

   110

   111

    ## Register

   112

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

   113

        """

   114

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

   115

   116

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

   117

        """

   118

   119

        if self._registering :

   120

            raise Exception("register: already registering")

   121

   122

        self.username = username

   123

        self.password = password

   124

   125

        log.msg("register", nickname)

   126

        irc.IRCClient.register(self, nickname)

   127

   128

        # defer

   129

        d = self._registering = defer.Deferred()

   130

   131

        return d

   132

   133

    # irc_ERR_NICKNAMEINUSE

   134

    # alterCollidedNick

   135

    # irc_ERR_ERRONEUSNICKNAME

   136

   137

    def irc_ERR_PASSWDMISMATCH (self, prefix, params) :

   138

        err = IRCError('ERR_PASSWDMISMATCH')

   139

        log.err(err)

   140

        self._registering.errback(err)

   141

   142

    def irc_RPL_WELCOME (self, prefix, params) :

   143

        self.hostname = prefix

   144

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

   145

   146

    def signedOn (self) :

   147

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

   148

        irc.IRCClient.signedOn(self)

   149

   150

        # defer

   151

        d = self._registering

   152

   153

        if not d :

   154

            raise Exception("signedOn: not registering?")

   155

   156

        self._registering = None

   157

   158

        d.callback(self.nickname)

   159

   160

    ## Channels

   161

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

   162

        """

   163

            Join the given channel.

   164

   165

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

   166

        """

   167

   168

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

   169

   170

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

   171

   172

        return d

   173

   174

    # ERR_CHANNELISFULL

   175

    # ERR_INVITEONLYCHAN

   176

    # ERR_BANNEDFROMCHAN

   177

    # ERR_BADCHANNELKEY

   197

   198

    def joined (self, channel) :

   199

        """

   200

            Have joined given channel.

   201

        """

   202

   203

        lookup = normalize(channel)

   204

   205

        d = self._channels[lookup]

   206

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

   207

        d.callback(channel)

   208

   209

    @defer.inlineCallbacks

   210

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

   211

        """

   212

            Defer a joined IRCChannel.

   213

        """

   214

   215

        lookup = normalize(channel)

   216

   217

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

   218

   219

        if lookup not in self._channels :

   220

            channel = yield self.join(channel, key)

   221

        else :

   222

            # wait or get

   223

            yield self._channels[lookup]

   224

   225

        channel = self._channels[lookup]

   226

   227

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

   228

   229

        defer.returnValue(channel)

   230

   231

    ## 

   232

    def irc_ERR_CANNOTSENDTOCHAN (self, prefix, params) :

   233

        nick, channel, error = params

   234

   235

        log.err(IRCError(channel, error))

   236

   237

    ## Quit

   238

    def irc_ERROR (self, prefix, params) :

   239

        msg, = params

   240

   241

        log.err(IRCError(None, msg))

   242

   243

    def connectionLost (self, reason) :

   244

        irc.IRCClient.connectionLost(self, reason)

   245

        log.err(reason)

   246

   247

        if self._registering :

   248

            self._registering.errback(reason)

   249

            self._registering = None

   250

   251

        # unregister channels

   252

        for channel in self._channels :

   253

            # errback Deferred or IRCChannel

   254

            self._channels[channel].errback(reason)

   255

   256

        self._channels = { }

   257

   258

        # unregister client

   259

        self.factory.clientLost(self)

   260

   261

    ## Logging

   262

    def url (self, target=None) :

   263

        """

   264

            Format as URL.

   265

        """

   266

   267

        # XXX: no isinstance() support

   268

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

   269

            scheme = 'irc'

   270

        else :

   271

            # TODO: ssl?

   272

            scheme = None

   273

   274

        peer = self.transport.getPeer()

   275

   276

        if peer.port == PORT :

   277

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

   278

        else :

   279

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

   280

   281

        if target :

   282

            path = str(target)

   283

        else :

   284

            path = None

   285

   286

        return ''.join(part for part in (

   287

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

   288

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

   289

            peer,

   290

            '/' if path else None, path

   291

        ) if part)

   292

   293

    __str__ = url

   294

    logPrefix = url

   295

   296

class IRCFactory (protocol.ClientFactory) :

   297

    """

   298

        Manage Clients and Targets

   299

    """

   300

   301

    NICKNAME = 'irker'

   302

   303

    def __init__ (self, nickname=NICKNAME) :

   304

        # default nickname

   305

        self.nickname = nickname

   306

   307

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

   308

        self.clients = {}

   309

   310

    def buildProtocol (self, addr) :

   311

        return IRCClient(self)

   312

   313

    def clientLost (self, client) :

   314

        """

   315

            Given IRCClient is no more.

   316

        """

   317

   318

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

   319

   320

        # remove from our clients

   321

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

   322

   323

    @defer.inlineCallbacks

   324

    def connect (self, url) :

   325

        """

   326

            Defer a connected, registered Client for given URL.

   327

        """

   328

   329

        endpoint = url2endpoint(reactor, url)

   330

   331

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

   332

   333

        # connect

   334

        try :

   335

            client = yield endpoint.connect(self)

   336

   337

        except error.ConnectError as ex :

   338

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

   339

            raise

   340

   341

        else :

   342

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

   343

   344

        # register

   345

        try :

   346

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

   347

   348

        except Exception as ex :

   349

            log.err("register", ex)

   350

            raise

   351

   352

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

   353

   354

        # okay!

   355

        defer.returnValue(client)

   356

   357

    @defer.inlineCallbacks

   358

    def client (self, url) :

   359

        """

   360

            Return IRCClient for given URL.

   361

        """

   362

   363

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

   364

   365

        if lookup not in self.clients :

   366

            # deferred for connect

   367

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

   368

   369

            try :

   370

                # wait on deferred, and then store IRCClient

   371

                self.clients[lookup] = yield connect

   372

   373

            except Exception as ex :

   374

                # failed, remove the attempted connect

   375

                del self.clients[lookup]

   376

                raise

   377

   378

        else :

   379

            # wait for result, if deferred

   380

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

   381

            yield self.clients[lookup]

   382

   383

        # connected client

   384

        client = self.clients[lookup]

   385

   386

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

   387

   388

        defer.returnValue(client)

   389

   390

    @defer.inlineCallbacks

   391

    def target (self, url) :

   392

        """

   393

            Return IRCChannel for given URL.

   394

        """

   395

   396

        client = yield self.client(url)

   397

   398

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

   399

        channel = yield client.channel(channel)

   400

   401

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

   402

   403

        defer.returnValue(channel)

   404

   405

    @defer.inlineCallbacks

   406

    def privmsg (self, url, *msg) :

   407

        """

   408

            Dispatch given messages to given target.

   409

        """

   410

   411

        target = yield self.target(url)

   412

   413

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

   414

   415

        target.privmsg(*msg)