朱剑的财富博客

http://stackoverflow.com/questions/3043394/python-tcp-server-writing-to-clients

import socket
import select

class Client(object):

    '''This object is created for each client connection.  It tracks
    what has been read, what has been written, and processes complete
    messages terminated by newlines.  It responds by returning the
    original message wrapped in square brackets and terminated by a
    newline. '''

    def __init__(self,who,sock,server):

        '''who - client address
        sock - client socket
        server - server object for this client
        '''

        self.who = who
        self.readbuf = ''
        self.writbuf = ''
        self.server = server
        self.sock = sock

    def close(self):

        '''Removes client from server's reader/writer queues and
        closes the connection.'''

        self.sock.close()
        if self.sock in self.server.readers:
            self.server.readers.remove(self.sock)
        if self.sock in self.server.writers:
            self.server.writers.remove(self.sock)
        self.server.data.pop(self.sock)

    def pumprecv(self):

        '''Server calls pumprecv() when something is readable from the
        client socket.  The data is appended to the client's read
        buffer.mro Complete messages (if any) are then removed from
        the buffer and processed.'''

        try:
            tmp = self.sock.recv(1000)
        except socket.error,e:
            print 'recv',e
            self.close()
        else:                
            if tmp:
                self.readbuf += tmp

                # Complete messages are processed
                while '\n' in self.readbuf:
                    msg,self.readbuf = self.readbuf.split('\n',1)
                    print self.who,msg
                    self.writbuf += '[' + msg + ']\n'
                    # New data to send.  Make sure client is in the
                    # server's writer queue.
                    if self.sock not in self.server.writers:
                        self.server.writers.append(self.sock)
            else:
                self.close()

    def pumpsend(self):
        try:
            # send some data.  tmp is #chars sent (may not be all in writbuf).
            tmp = self.sock.send(self.writbuf)
        except socket.error,e:
            print 'send:',e
            self.close()
        else:
            # Removed sent characters from writbuf.
            self.writbuf = self.writbuf[tmp:]
            # If writbuf is empty, remove socket from server's write queue.
            if not self.writbuf:
                self.server.writers.remove(self.sock)

class Server(object):
    def __init__(self,ip='127.0.0.1',port=9999):
        self.ssock = socket.socket()
        self.ssock.bind((ip,port))
        self.ssock.listen(5)
        self.readers = [self.ssock]
        self.data = {}
        self.writers = []
        self.quit = False

    def pumpaccept(self):

        '''Called when server socket is readable to accept a
        connection and create a Client object.'''

        csock,who = self.ssock.accept()
        print 'Connected %s:%d' % who
        self.readers.append(csock)
        self.data[csock] = Client(who,csock,self)

    def serve(self):
        while not self.quit or self.writers:
            readable,writable,other = select.select(self.readers,self.writers,[],1.0)
            # Operate on copies of the queues since the pumpXXX() commands can modify the lists.
            if self.ssock in readable[:]:
                self.pumpaccept()
                readable.remove(self.ssock)
            for reader in readable[:]:
                self.data[reader].pumprecv()
            for writer in writable[:]:
                self.data[writer].pumpsend()

            if not readable and not writable and not other:
                print '.',

if __name__ == '__main__':
    srv = Server()
    srv.serve()

>>> from socket import *
>>> s=socket()
>>> s.connect(('localhost',9999))
>>> s.send('one\ntwo\nthree')
13
>>> s.send('\nfour\n')
6
>>> s.recv(1024)
'[one]\n[two\three]\n[four]\n'
>>> s.close()

http://daxi.me/2009/11/231/

import sys, time
import stackless

import stacklesssocket
#sys.modules["socket"] = stacklesssocket
stacklesssocket.install()
import socket

class Server(object):
    def __init__(self, conn):
        self.clients = {}
        # Create an INET, STREAMing socket
        self.serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.serversocket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        # Bind the socket to an addres, and a port
        self.serversocket.bind(conn)
        # Become a server socket
        self.serversocket.listen(5)
        stackless.tasklet(self.acceptConn)()

    def acceptConn(self):
        while self.serversocket.accept:
            # Accept connections from outside
            (clientsocket, address) = self.serversocket.accept()
            # Now do something with the clientsocket
            # In this case, each client is managed in a tasklet
            stackless.tasklet(self.manageSocket)(clientsocket, address)
            stackless.schedule()

    def manageSocket(self, clientsocket, address):
        # Record the client data in a dict
        self.clients[clientsocket] = address
        print "Client %s:%s connected..." % (address[0],address[1])
        # For each send we expect the socket returns 1, if its 0 an error ocurred
        if not clientsocket.send('Connection OK\n\rType q! to quit.\n\r>'):
            clientsocket.close()
            return
        data = ''
        while clientsocket.connect:
            data += clientsocket.recv(4096)
            if data == '':
                break
            # If we detect a \n filter the event
            if '\n' in data:
                if data == '\r\n':
                    if not clientsocket.send("Unknown command.  Type 'help' to see a list of available commands.\r\n>"):
                        break
                elif data == 'q!\r\n':
                    # If the user sends a q!, close the connection and remove from list
                    print "Closed connection for %s:%s" % (address[0],address[1])
                    del self.clients[clientsocket]
                    break
                elif data == 'help\r\n':
                    # Display available commands
                    clientsocket.send("Commands:\r\n")
                    for verb in ["look - Who is online", "help - Display this.", "q! - Quit"]:
                        clientsocket.send("  "+ verb +"\r\n")
                    clientsocket.send(">")
                elif data == 'look\r\n':
                    # Show the connected clients
                    clientsocket.send("There are %d users connected:\r\n" % len(self.clients))
                    clientsocket.send("Name\tHost\t\tPort\r\n")
                    clientsocket.send("-" * 40 +"\r\n")
                    for clientIP, clientPort in self.clients.itervalues():
                        clientsocket.send("Unknown\t"+ str(clientIP) +"\t"+ str(clientPort) +"\r\n")
                    clientsocket.send(">")
                else:
                    # Send the message to all connected clients
                    for client in self.clients:
                        if client is clientsocket:
                            if not client.send('\rYou said: %s>' % data):
                                break
                        else:
                            if not client.send('\rClient %s said: %s>' % (address,data)):
                                break
                data = ''
            stackless.schedule()
        clientsocket.close()

if __name__ == "__main__":
    host = "127.0.0.1"
    port = 3000
    print "Starting up server on IP:port %s:%s" % (host, port)
    s = Server((host,port))
    stackless.run()

1. #!/usr/bin/python
2. # -*- coding:utf-8 -*-
3. import sys
4. import re
5. import urllib
7. class ServerSaid:
9.     ApiURL = ’http://server-say.appspot.com/api’
10.     #
11.     #请到http://server-said.appspot.com/注册您的Ip地址。没有注册的Ip每小时最多10条消息。
12.     #
13.     Account = ”
14.     MessageBody = ”
15.     DefaultEncode = ’utf-8′
17.     def SendMessage(self):
18.         cleanMessage = self.MessageBody.encode(self.DefaultEncode)
19.         if (self.checkEmail(self.Account) and self.checkMessage(cleanMessage)):
20.             cleanMessage = self.MessageBody.encode(‘utf-8′)
21.             url = self.ApiURL + ’?account=’+ urllib.quote(self.Account) +’&message=’ + urllib.quote(cleanMessage)
22.         #   print url
23.             query = urllib.urlopen(url)
24.             if ( query.read() == ’200′ ):
25.                 print ’Message be sent!\n’
27.             else:
28.                 print self.Error(0)
29.         else :
30.             print self.Error(1)
32.     def Error(self, code=0):
33.         return  ’Message can\’t be send! \n’
35.     def checkEmail(self, Email):
36.         RegexString = r’^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w{2,5}$’
38.         return re.match(RegexString, Email)
40.     def checkMessage(self, Message):
42.         RegexString = r’^.{1,140}$’
43.         return re.match(RegexString, Message)
45. if __name__ == ’__main__’:
47.     if (len(sys.argv)>1):
48.         handler = ServerSaid()
49.         handler.Account = sys.argv[1]
51.         Message = sys.argv[2]
53.         handler.MessageBody = Message.decode(handler.DefaultEncode)
55.         handler.SendMessage()
56.     else:
57.         print ’serversaid.py YOUR_GTALK MESSAGE ’

这里为了防止消息的滥发，使用前最好先到 http://server-say.appspot.com/ 注册一下。没有注册的IP每小时仅能发送10条消息，我想大部分情况下也够用了。注册了的用户可以无限制的发送消息了，除非我在GAE注册的那张信用卡里的钱花光——我会哭的。

啥也不说了，PHP接口也搞定了！

http://www.litrin.net/2010/12/02/gtalk%E9%80%9A%E7%9F%A5%E6%9C%BA%E5%99%A8%E4%BA%BA%E8%84%9A%E6%9C%AC/

http://www.zhlwish.com/2011/04/04/pyxmpp_gtalk/

#!/usr/bin/python
# -*- coding: utf-8 -*-

from pyxmpp.jid import JID
from pyxmpp.message import Message
from pyxmpp.jabber.client import JabberClient
from pyxmpp.jabber.simple import send_message
from pyxmpp import streamtls

class Gtalk():
    def __init__(self, sid, spwd):
        self.sid = JID(sid)
        self.spwd = spwd

    def send_msg(self, rid,  msg):
        self.rid = JID(rid)
        if not self.sid.resource:
            self.sid = JID(self.sid.node, self.sid.domain, 'send_message')

        msg = Message(to_jid=self.rid, body=msg)
        def send(stream):
            stream.send(msg)

        self.xmpp_do(send)

    def xmpp_do(self, function):
        class Client(JabberClient):
            def session_started(self):
                function(self.stream)
                self.disconnect()

        tls = streamtls.TLSSettings(require=True, verify_peer=False)
        auth = ['sasl:PLAIN']
        gtalkClient = Client(self.sid, self.spwd, tls_settings=tls, auth_methods=auth)
        gtalkClient.connect()
        try:
            gtalkClient.loop(1)
        except KeyboardInterrupt:
            print u'disconnecting...'
            gtalkClient.disconnect()

if __name__ == '__main__':
    g = Gtalk('myaccount@gmail.com', u'mypassword')
    g.send_msg('to@gmail.com', 'message')