使用Python的Twisted框架编写简单的网络客户端

from twisted.internet.protocol import Protocol
from sys import stdout

class Echo(Protocol):
 def dataReceived(self, data):
 stdout.write(data)

from twisted.internet.protocol import Protocol

class WelcomeMessage(Protocol):
 def connectionMade(self):
 self.transport.write("Hello server, I am the client!/r/n")
 self.transport.loseConnection()

from twisted.internet import reactor
from twisted.internet.protocol import Protocol, ClientCreator

class Greeter(Protocol):
 def sendMessage(self, msg):
 self.transport.write("MESSAGE %s/n" % msg)

def gotProtocol(p):
 p.sendMessage("Hello")
 reactor.callLater(1, p.sendMessage, "This is sent in a second")
 reactor.callLater(2, p.transport.loseConnection)

c = ClientCreator(reactor, Greeter)
c.connectTCP("localhost", 1234).addCallback(gotProtocol)

from twisted.internet.protocol import Protocol, ClientFactory
from sys import stdout

class Echo(Protocol):
 def dataReceived(self, data):
 stdout.write(data)

class EchoClientFactory(ClientFactory):
 def startedConnecting(self, connector):
 print 'Started to connect.'
 
 def buildProtocol(self, addr):
 print 'Connected.'
 return Echo()
 
 def clientConnectionLost(self, connector, reason):
 print 'Lost connection. Reason:', reason
 
 def clientConnectionFailed(self, connector, reason):
 print 'Connection failed. Reason:', reason

from twisted.internet import reactor
reactor.connectTCP(host, port, EchoClientFactory())
reactor.run()

from twisted.internet.protocol import ClientFactory

class EchoClientFactory(ClientFactory):
 def clientConnectionLost(self, connector, reason):
 connector.connect()

from twisted.internet.protocol import Protocol, ReconnectingClientFactory
from sys import stdout

class Echo(Protocol):
 def dataReceived(self, data):
 stdout.write(data)

class EchoClientFactory(ReconnectingClientFactory):
 def startedConnecting(self, connector):
 print 'Started to connect.'

 def buildProtocol(self, addr):
 print 'Connected.'
 print 'Resetting reconnection delay'
 self.resetDelay()
 return Echo()

 def clientConnectionLost(self, connector, reason):
 print 'Lost connection. Reason:', reason
 ReconnectingClientFactory.clientConnectionLost(self, connector, reason)

 def clientConnectionFailed(self, connector, reason):
 print 'Connection failed. Reason:', reason
 ReconnectingClientFactory.clientConnectionFailed(self, connector,reason)

# twisted imports
from twisted.words.protocols import irc
from twisted.internet import reactor, protocol
from twisted.python import log

# system imports
import time, sys


class MessageLogger:
 """
 An independent logger class (because separation of application
 and protocol logic is a good thing).
 """
 def __init__(self, file):
 self.file = file

 def log(self, message):
 """Write a message to the file."""
 timestamp = time.strftime("[%H:%M:%S]", time.localtime(time.time()))
 self.file.write('%s %s/n' % (timestamp, message))
 self.file.flush()

 def close(self):
 self.file.close()


class LogBot(irc.IRCClient):
 """A logging IRC bot."""

 nickname = "twistedbot"

 def connectionMade(self):
 irc.IRCClient.connectionMade(self)
 self.logger = MessageLogger(open(self.factory.filename, "a"))
 self.logger.log("[connected at %s]" %
 time.asctime(time.localtime(time.time())))

 def connectionLost(self, reason):
 irc.IRCClient.connectionLost(self, reason)
 self.logger.log("[disconnected at %s]" %
 time.asctime(time.localtime(time.time())))
 self.logger.close()


 # callbacks for events

 def signedOn(self):
 """Called when bot has succesfully signed on to server."""
 self.join(self.factory.channel)

 def joined(self, channel):
 """This will get called when the bot joins the channel."""
 self.logger.log("[I have joined %s]" % channel)

 def privmsg(self, user, channel, msg):
 """This will get called when the bot receives a message."""
 user = user.split('!', 1)[0]
 self.logger.log("<%s> %s" % (user, msg))

 # Check to see if they're sending me a private message
 if channel == self.nickname:
 msg = "It isn't nice to whisper! Play nice with the group."
 self.msg(user, msg)
 return

 # Otherwise check to see if it is a message directed at me
 if msg.startswith(self.nickname + ":"):
 msg = "%s: I am a log bot" % user
 self.msg(channel, msg)
 self.logger.log("<%s> %s" % (self.nickname, msg))

 def action(self, user, channel, msg):
 """This will get called when the bot sees someone do an action."""
 user = user.split('!', 1)[0]
 self.logger.log("* %s %s" % (user, msg))

 # irc callbacks

 def irc_NICK(self, prefix, params):
 """Called when an IRC user changes their nickname."""
 old_nick = prefix.split('!')[0]
 new_nick = params[0]
 self.logger.log("%s is now known as %s" % (old_nick, new_nick))


class LogBotFactory(protocol.ClientFactory):
 """A factory for LogBots.

 A new protocol instance will be created each time we connect to the server.
 """

 # the class of the protocol to build when new connection is made
 protocol = LogBot

 def __init__(self, channel, filename):
 self.channel = channel
 self.filename = filename

 def clientConnectionLost(self, connector, reason):
 """If we get disconnected, reconnect to server."""
 connector.connect()

 def clientConnectionFailed(self, connector, reason):
 print "connection failed:", reason
 reactor.stop()


if __name__ == '__main__':
 # initialize logging
 log.startLogging(sys.stdout)

 # create factory protocol and application
 f = LogBotFactory(sys.argv[1], sys.argv[2])

 # connect factory to this host and port
 reactor.connectTCP("irc.freenode.net", 6667, f)

 # run bot
 reactor.run()

from twisted.internet import protocol
from twisted.protocols import irc

class LogBot(irc.IRCClient):

 def connectionMade(self):
 irc.IRCClient.connectionMade(self)
 self.logger = MessageLogger(open(self.factory.filename, "a"))
 self.logger.log("[connected at %s]" %
 time.asctime(time.localtime(time.time())))
 
 def signedOn(self):
 self.join(self.factory.channel)

 
class LogBotFactory(protocol.ClientFactory):
 
 protocol = LogBot
 
 def __init__(self, channel, filename):
 self.channel = channel
 self.filename = filename