# 示例一 twisted底層API的使用
from twisted.internet import reacto
from twisted.internet import main
from twisted.internet.interfaces import IReadDescriptor
import socket

class MySocket(IReadDescriptor):
  def __init__(self, address):
    # 連接服務器
    self.address = address
    self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    self.sock.connect(address)
    self.sock.setblocking(0)

    # tell the Twisted reactor to monitor this socket for reading
    reactor.addReader(self)
 
 # 接口: 告訴reactor 監(jiān)聽的套接字描述符
  def fileno(self):
    try:
      return self.sock.fileno()
    except socket.error:
      return -1
      
 # 接口: 在連接斷開時的回調
  def connectionLost(self, reason):
    self.sock.close()

    reactor.removeReader(self)
 
 # 當應用程序需要終止時 調用:
    # reactor.stop()

 # 接口: 當套接字描述符有數(shù)據(jù)可讀時
  def doRead(self):
    bytes = ''

 # 盡可能多的讀取數(shù)據(jù)
    while True:
      try:
        bytesread = self.sock.recv(1024)
        if not bytesread:
          break
        else:
          bytes += bytesread
      except socket.error, e:
        if e.args[0] == errno.EWOULDBLOCK:
          break
        return main.CONNECTION_LOST

    if not bytes: 
      return main.CONNECTION_DONE
    else:
      # 在這里解析協(xié)議并處理數(shù)據(jù)
      print bytes

# 示例二 twisted抽象的使用
from twisted.internet import reactor
from twisted.internet.protocol import Protocol, ClientFactory
class MyProtocol(Protocol):
 
 # 接口: Protocols初始化時調用，并傳入Transports
 # 另外 twisted會自動將Protocols的factory對象成員設為ProtocolsFactory實例的引用
 #   如此就可以通過factory來與MyProtocolFactory交互
 def makeConnection(self,trans):
    print 'make connection: get transport: ', trans
    print 'my factory is: ', self.factory
    
 # 接口: 有數(shù)據(jù)到達
  def dataReceived(self, data):
    self.poem += data
    msg = 'Task %d: got %d bytes of poetry from %s'
    print msg % (self.task_num, len(data), self.transport.getPeer())
 
 # 接口: 連接斷開
  def connectionLost(self, reason):
    # 連接斷開的處理


class MyProtocolFactory(ClientFactory):

 # 接口: 通過protocol類成員指出需要創(chuàng)建的Protocols
  protocol = PoetryProtocol # tell base class what proto to build

  def __init__(self, address):
    self.poetry_count = poetry_count
    self.poems = {} # task num -> poem
    
 # 接口: 在創(chuàng)建Protocols的回調
  def buildProtocol(self, address):
    proto = ClientFactory.buildProtocol(self, address)
    # 在這里對proto做一些初始化....
    return proto
    
 # 接口: 連接Server失敗時的回調
  def clientConnectionFailed(self, connector, reason):
    print 'Failed to connect to:', connector.getDestination()
    
def main(address):
 factory = MyClientFactory(address)
  host, port = address
  # 連接服務端時傳入ProtocolsFactory
  reactor.connectTCP(host, port, factory) 
  reactor.run()

d = Deferred()
# 添加正確回調和錯誤回調
d.addCallbacks(your_ok_callback, your_err_callback)
# 添加公共回調函數(shù)
d.addBoth(your_common_callback)

# 正確返回 將依次調用 your_ok_callback(Res) -> common_callback(Res)
d.callback(Res)
# 錯誤返回 將依次調用 your_err_callback(Err) -> common_callback(Err)
d.errback(Err)

# 注意，對同一個Defered對象，只能返回一次，嘗試多次返回將會報錯

#coding:utf-8
#xiaorui.cc
from twisted.internet import reactor, defer
from twisted.internet.threads import deferToThread
import os,sys
from twisted.python import threadable; threadable.init(1)
deferred =deferToThread.__get__
import time
def todoprint_(result):
  print result
def running():
  "Prints a few dots on stdout while the reactor is running."
#   sys.stdout.write("."); sys.stdout.flush()
  print '.'
  reactor.callLater(.1, running)
@deferred
def sleep(sec):
  "A blocking function magically converted in a non-blocking one."
  print 'start sleep %s'%sec
  time.sleep(sec)
  print '\nend sleep %s'%sec
  return "ok"
def test(n,m):
  print "fun test() is start"
  m=m
  vals = []
  keys = []
  for i in xrange(m):
    vals.append(i)
    keys.append('a%s'%i)
  d = None
  for i in xrange(n):
    d = dict(zip(keys, vals))
  print "fun test() is end"
  return d
if __name__== "__main__":
#one
  sleep(10).addBoth(todoprint_)
  reactor.callLater(.1, running)
  reactor.callLater(3, reactor.stop)
  print "go go !!!"
  reactor.run()
#two
  aa=time.time()
  de = defer.Deferred()
  de.addCallback(test)
  reactor.callInThread(de.callback,10000000,100 )
  print time.time()-aa
  print "我這里先做別的事情"
  print de
  print "go go end"