我一直对下载文件比较感兴趣。现在我下载文件大部分是用迅雷，但迅雷也有一些不如意的地方，内存占用大，一些不必要的功能太多，不可定制。尤其是最后一点。现在有些下载对useragent，cookie,auth等要求很多，迅雷这时就无能为力了。最好能有一个在后台运行的download server，以较小的内存代价运行，界面通过访问本地的端口显示。下面对其中可能涉及的一些技术进行探讨。在python下实现下载比较容易。以下载http://nodejs.org/dist/v0.10.12/node.exe为例：
import urllib2 urllib2.urlopen('http://nodejs.org/dist/v0.10.12/node.exe')
但在网速不给力的情况下，这样下载就会花很长时间，分段下载是个可行的方法。
首先要得到文件的大小：
import httpliub def _getinfo(host,path): conn=httplib.HTTPConnection(host) conn.request('HEAD',path) res= conn.getresponse() if res.status==httplib.OK: result=res.getheader('content-length') conn.close() return int(result)
然后分段下载：
CHUNK=16*1024 def _getpart(host,path,fname,start,end): current=start headers={'Range':'bytes=%s-%s' % (start, end)} f=open(fname,'wb') conn=httplib.HTTPConnection(host) conn.request('GET',path,'',headers) print 'No. %d begin to download range bytes=%s-%s ' % (start, end) res=conn.getresponse() while True : chunk=res.read(CHUNK) if not chunk: conn.close() f.close() break f.seek(current) f.write(chunk) print 'No. %d write at %d'%(pid,current) current=current+CHUNK
采取res.read(CHUNK)的方式可以减少内存的占用。
分段下载没有问题，但问题是依次分段下载根本没有解决问题，只有同时分段下载才能提高网速。“同时”意味着多线程，复杂的锁，资源分配实非我辈菜鸟所能掌握的。好在有大神给出了解决方案，用gevent。gevent引入了协程的概念，程序实际上要单线程运行，但在程序内部不停地切换，实现多线程的效果。以较低的代价实现多线程，又叫协程。这与nodejs较相似。但nodejs的学习难度太大，只好用gevent了。
说到gevent，我不得不吐糟一下，资料太混乱了。主页面上的是0.13.8，实际上在github上是1.0rc2。文档中介绍的是0.13.8的，1.0rc2变化巨大，与文档根本对不上。只能一点一点摸索。
引入gevent后的整个下载是这样的。
temp=urlparse.urlparse(url)
size=_getinfo(temp.netloc,temp.path) num=20 t=size//num p=gevent.pool(15) fname=url.split('/')[-1] for i in range(num): start=t*i end=start+t-1 if i==num-1 :end=size job=gevent.spawn(_getpart,temp.netloc,temp.path,fname,start,end) p.add(job) p.join() print 'downloaded'
同时也要对_getpart进行修改
def _getpart(self,pid,host,path,fname,start,end,**kwargs): monkey.patch_socket() current=start headers={'Range':'bytes=%s-%s' % (start, end)} f=self._open(fname) conn=self._getconn(host) conn.request('GET',path,'',headers) print 'No. %d begin to download range bytes=%s-%s ' % (pid ,start, end) gevent.sleep(0) res=conn.getresponse() while True : gevent.sleep(0) chunk=res.read(self.CHUNK) if not chunk: self._returnconn(host,conn) self._close(fname) print 'No. %d download range bytes=%s-%s successed' % (pid ,start, end) break f.seek(current) f.write(chunk) print 'No. %d write at %d'%(pid,current) current=current+self.CHUNK
在凡是需要等待的地方加入gevent.sleep(0),这相当于通知系统这里要等待，可以干别的了。但这这里有个问题，在没有patch（加入monkey.patch_socket()）时，
所有的协程总是以固定的顺序写入，并不像是并行运行。只有patch后才像是并行。找了许多文档也没有解释清楚。
这样就行了吗，还不行。同一文件被反复打开，关闭。如何解决，引入计数。就是这样：
#文件句柄记录,｛文件名：[文件句柄，引用计数]｝
self._filehandle={}
def _open(self,fn): if fn in self._filehandle: self._filehandle[fn][1]+=1 return self._filehandle[fn][0] else: fp=open(fn,'wb') self._filehandle[fn]=[fp,1] return fp def _close(self,fn): self._filehandle[fn][1]-=1 if self._filehandle[fn][1] ==0: self._filehandle[fn][0].close() del self._filehandle[fn]
以后打开文件时调用_open（），关闭时调用_close()。这样避免了重复打开，重复关闭。
再改进下吧，connection也可以重用。下载时大量的联接都是针对同一网站，重用可以加快下载。策略是req完成后，联接并不马上关闭，而是保存的“联接池”中，当需用联接时，先在联接池中查找，有就重用，没有就先新建一条联接。没用的联接在经过一段时间再关闭。所以联接池并不对联接数量进行控制。
既然是延迟关闭，那么就用到了timer，python自带的timer就可以啊。最终还是没用，因为timer是threading下的，属新开线程，消耗太大。另外仅管timer在文档中说是class但实际上根本不是，坑爹啊，是function，_Timer才是class。
gevent的timer也不太好用，文档没有，不行自造一个吧。要求：在固定时隔内运行一系列函数，函数可动态增减，定时器可开关。，结果就是这个，这是网上抄来的，向大侠表示感谢。
class Timer(object): def __init__(self,interval): self._interval=interval self._callbacks = {} self._app=None self._flag=False def start(self): self._flag=True if self._app==None: self._app = gevent.spawn( self._loop ) def stop(self): self._flag=False self._app==None def _loop( self ): while not self._flag: for callback in self._callbacks.value(): callback() gevent.sleep( self.interval ) def status(self): return self._flag def add(self, funcname,func, *args, **kwargs ): if not funcname in self._callbacks: self._callbacks[ funcname ]= callback(func, *args, **kwargs) def remove(funcname): if funcname in self._callbacks: del self._callbackes[funcname]
严格来说这个定时器还是有些隐患，因为在_callbacks中的所有函数执行完成后，才开始计时，如果执行时间较长，或有异常就会出问题。上面提到的callback是对函数的封装，也是向同一位大侠抄来的：
class callback: """ 可执行对象 """ def __init__( self, func, *args, **kwargs ): self.func = func self.args = list(args) self.kwargs = kwargs def __call__( self, *args, **kwargs ): for k in self.kwargs: if not kwargs.has_key(k): kwargs[k] = self.kwargs[k] args = self.args + list(args) return self.func( *args, **kwargs ) def __str__( self ): return "<CallableObject %s %s %s />"%(str(self.func),str(self.args),str(self.kwargs))
这样复用联接就好办了
def _getconn(self,host): result=None for item in self._conn: if item[0]==host: result=item[1] self._conn.remove(item) break if result==None: result=httplib.HTTPConnection(host) result.connect() return result def _returnconn(self,host,conn): self._conn.append([host,conn,time.time()]) self._timer.add('closeconn',self._closeconn) def _closeconn(self): limit=time.time()-self.CONNDELAY temp=[] for item in self._conn: if item[2]<limit: item.close() else: temp.append(item) self._conn=temp if len(self._conn)==0: self._timer.remove('closeconn')
三个函数分别是取联接，归还联接，及定时器中的关闭联接。这样还不行，有的重用联接还有抛出异常，responsenotready。问题出在第一个head request上，request一定要read只后联接才能重用。
def _getinfo(self,host,path, **kwargs): conn=self._getconn(host) conn.request('HEAD',path) res= conn.getresponse() res.read() if res.status==httplib.OK: result=res.getheader('content-length') self._returnconn(host,conn) return int(result)
最后再把整个封装成一个类，可以随时增加下载。下面是完整的代码：
1 from gevent import monkey 2 from gevent.pool import Pool 3 from gevent import greenlet 4 import urlparse,httplib,gevent,time 5 from gevent.core import timer 6 7 #封装callback 8 class callback: 9 12 def __init__( self, func, *args, **kwargs ): 13 self.func = func 14 self.args = list(args) 15 self.kwargs = kwargs 16 17 def __call__( self, *args, **kwargs ): 18 for k in self.kwargs: 19 if not kwargs.has_key(k): 20 kwargs[k] = self.kwargs[k] 21 args = self.args + list(args) 22 return self.func( *args, **kwargs ) 23 24 def __str__( self ): 25 return "<CallableObject %s %s %s />"%(str(self.func),str(self.args),str(self.kwargs)) 26 27 #定时器类 28 class Timer(object): 29 30 def __init__(self,interval): 31 self._interval=interval 32 self._callbacks = {} 33 self._app=None 34 self._flag=False 35 36 def start(self): 37 self._flag=True 38 if self._app==None: 39 self._app = gevent.spawn( self._loop ) 40 41 42 def stop(self): 43 self._flag=False 44 self._app==None 45 46 def _loop( self ): 47 while not self._flag: 48 for callback in self._callbacks.value(): 49 callback() 50 gevent.sleep( self.interval ) 51 52 def status(self): 53 return self._flag 54 55 def add(self, funcname,func, *args, **kwargs ): 56 if not funcname in self._callbacks: 57 self._callbacks[ funcname ]= callback(func, *args, **kwargs) 58 59 def remove(funcname): 60 if funcname in self._callbacks: 61 del self._callbackes[funcname] 62 63 #服务器类， 64 class server(object): 65 66 def __init__(self): 67 68 #读写块大小 69 self.CHUNK=16*1024 70 #下载协程池大小 71 self.POOLSIZE=15 72 #下载超时（S） 73 self.TIMEOUT=10 74 #下载重试次数 75 self.RETRY=10 76 #连接空闲后，关闭前的时间 77 self.CONNDELAY=3 78 #计时器扫描间隔 79 self.INTERVAL=1.0 80 #文件句柄记录,｛文件名：[文件句柄，引用计数]｝ 81 self._filehandle={} 82 #联接记录，[host,conn,time.time()] 83 self._conn=[] 84 self._pool=Pool(self.POOLSIZE) 85 self._timer=Timer(self.INTERVAL) 86 87 88 #建立联接 89 def _getconn(self,host): 90 result=None 91 for item in self._conn: 92 if item[0]==host: 93 result=item[1] 94 self._conn.remove(item) 95 break 96 if result==None: 97 result=httplib.HTTPConnection(host) 98 result.connect() 99 return result 100 101 #将富余连接置入self._conn 102 def _returnconn(self,host,conn): 103 self._conn.append([host,conn,time.time()]) 104 self._timer.add('closeconn',self._closeconn) 105 106 #关闭超时连接 107 def _closeconn(self): 108 limit=time.time()-self.CONNDELAY 109 temp=[] 110 for item in self._conn: 111 if item[2]<limit: 112 item.close() 113 else: 114 temp.append(item) 115 self._conn=temp 116 if len(self._conn)==0: 117 self._timer.remove('closeconn') 118 119 120 #记录文件句柄 121 def _open(self,fn): 122 if fn in self._filehandle: 123 self._filehandle[fn][1]+=1 124 return self._filehandle[fn][0] 125 else: 126 fp=open(fn,'wb') 127 self._filehandle[fn]=[fp,1] 128 return fp 129 130 #按引用计数关闭文件句柄 131 def _close(self,fn): 132 self._filehandle[fn][1]-=1 133 if self._filehandle[fn][1] ==0: 134 self._filehandle[fn][0].close() 135 del self._filehandle[fn] 136 137 #取得下载文件信息 138 def _getinfo(self,host,path, **kwargs): 139 conn=self._getconn(host) 140 conn.request('HEAD',path) 141 res= conn.getresponse() 142 res.read() 144 if res.status==httplib.OK: 145 result=res.getheader('content-length') 146 self._returnconn(host,conn) 147 return int(result) 148 149 #分段下载 150 def _getpart(self,pid,host,path,fname,start,end,**kwargs): 151 monkey.patch_socket() 152 current=start 153 headers={'Range':'bytes=%s-%s' % (start, end)} 154 f=self._open(fname) 155 conn=self._getconn(host) 156 conn.request('GET',path,'',headers) 157 print 'No. %d begin to download range bytes=%s-%s ' % (pid ,start, end) 158 gevent.sleep(0) 159 res=conn.getresponse() 160 while True : 161 gevent.sleep(0) 162 chunk=res.read(self.CHUNK) 163 164 if not chunk: 165 self._returnconn(host,conn) 166 self._close(fname) 167 print 'No. %d download range bytes=%s-%s successed' % (pid ,start, end) 168 break 169 f.seek(current) 170 f.write(chunk) 171 print 'No. %d write at %d'%(pid,current) 172 current=current+self.CHUNK 173 174 #添加下载任务 175 def add(self,url): 176 temp=urlparse.urlparse(url) 177 size=self._getinfo(temp.netloc,temp.path) 178 num=20 179 t=size//num 180 fname=url.split('/')[-1] 181 for i in range(num): 182 start=t*i 183 end=start+t-1 184 if i==num-1 :end=size 185 job=gevent.spawn(self._getpart,i,temp.netloc,temp.path,fname,start,end) 186 self._pool.add(job) 187 self._pool.join() 188 print 'downloaded'
这个东西还存在很多问题，没有实现持久化，不能控制具体下载线程，没有处理重定向、超时等，下一步进一步研究。欢迎各位达人指正，拍砖。