用Python教你如何“养”一只DHT爬虫(1)

文章由Byrx.net分享于2019-03-21 06:03:11评论（170）

用Python教你如何“养”一只DHT爬虫(1)


废话少说, 直接上菜.

我假设你了解:

1, DHT协议

2, 网络字节序/主机字节序

3, bencode

4, UDP

5, 种子文件构造

不懂的赶紧去google, 要是缺一个, 我会一口盐汽水喷死你的!

最重要的是, 你必须会编程!!!!!!! 必须会!!!!!!!!!!!

ok, DHT原理是什么我在这就不写了, 毕竟会看我这文章的人都是已经知道了的.

本文贴的代码均为Python, 使用其他编程语言的人可以看注释. 为了简单, 只会说大概思路和关键性代码, 细节自行搞定.

本文讲的是要实现一个爬虫, 所以不会跟协议文档那么严格. 只要保证你能正确请求,回应即可. 用软件开发的一句话来说: 只要接口一致, 管你内部细节代码是怎么写的.

第一步, 构建自己的路由表, 这里涉及到大量Python代码, 请深呼吸:

在构建自己的路由表之前, 得写两个辅助函数, 后面会用到:

  1. from hashlib import sha1  
  2. from random import randint  
  3. def node_id():  
  4.     """  
  5.     把爬虫"伪装"成正常node, 一个正常的node有ip, port, node ID三个属性, 因为是基于UDP协议,   
  6.     所以向对方发送信息时, 即使没"明确"说明自己的ip和port时, 对方自然会知道你的ip和port,   
  7.     反之亦然. 那么我们自身node就只需要生成一个node ID就行, 协议里说到node ID用sha1算法生成,   
  8.     sha1算法生成的值是长度是20 byte, 也就是20 * 8 = 160 bit, 正好如DHT协议里说的那范围: 0 至 2的160次方,   
  9.     也就是总共能生成1461501637330902918203684832716283019655932542976个独一无二的node.   
  10.     ok, 由于sha1总是生成20 byte的值, 所以哪怕你写SHA1(20)或SHA1(19)或SHA1("I am a 2B")都可以,   
  11.     只要保证大大降低与别人重复几率就行. 注意, node ID非十六进制,   
  12.     也就是说非FF5C85FE1FDB933503999F9EB2EF59E4B0F51ECA这个样子, 即非hash.hexdigest().  
  13.     """ 
  14.     hash = sha1()  
  15.     s = ""  
  16.     for i in range(20):  
  17.         s += chr(randint(0, 255))  
  18.     hash.update(s)  
  19.     return hash.digest()  
  20.  
  21. def intify(nid):  
  22.     """这是一个小工具, 把一个node ID转换为数字. 后面会频繁用到.""" 
  23.     assert len(nid) == 20 
  24.     return long(nid.encode('hex'), 16) #先转换成16进制, 再变成数字 

协议里说道, table里有bucket, bucket里有node, 每个bucket有K个node, 目前K=8, 即每个bucket有8个node. 由于table范围是0到2的160次方, 那么一个table最多能有(2的160次方)/K那么多的bucket.

OK, 按照OOP编程思想来说, 那么肯定会有table, bucket, node这3个类, 无OOP的, 自己看着办.

由于是基于Kademila而写, 所以我习惯上把这三个类名变为KTable, KBucket, KNode:

  1. class KNode:  
  2.     def __init__(self, nid, ip, port):  
  3.         """  
  4.         nid就是node ID的简写, 就不取id这么模糊的变量名了. __init__方法相当于别的OOP语言中的构造方法,   
  5.         在python严格来说不是构造方法, 它是初始化, 不过, 功能差不多就行.  
  6.         """ 
  7.         self.nid = nid #node ID  
  8.         self.ip = ip  
  9.         self.port = port  
  10.  
  11.     #以下两个方法非Python程序员不需关心  
  12.     def __eq__(self, other):  
  13.         return self.nid == other.nid  
  14.     def __ne__(self, other):  
  15.         return self.nid != other.nid  
  16.  
  17.  
  18. class KBucket:  
  19.     def __init__(self, min, max):  
  20.         """  
  21.         min和max就是该bucket负责的范围, 比如该bucket的min:0, max:16的话,   
  22.         那么存储的node的intify(nid)值均为: 0到15, 那16就不负责, 这16将会是该bucket后面的bucket的min值.   
  23.         nodes属性就是个列表, 存储node. last_accessed代表最后访问时间, 因为协议里说到,   
  24.         当该bucket负责的node有请求, 回应操作; 删除node; 添加node; 更新node; 等这些操作时,   
  25.         那么就要更新该bucket, 所以设置个last_accessed属性, 该属性标志着这个bucket的"新鲜程度". 用linux话来说, touch一下.  
  26.         这个用来便于后面说的定时刷新路由表.  
  27.         """ 
  28.         self.min = min #最小node ID数字值  
  29.         self.max = max #最大node ID数字值  
  30.         self.nodes = [] #node列表  
  31.         self.last_accessed = time() #最后访问时间  
  32.  
  33.     def nid_in_range(self, nid):  
  34.         """判断指定的node ID是否属于该bucket的范围里""" 
  35.         return self.min <= intify(nid) < self.max  
  36.  
  37.     def append(self, node):  
  38.         """  
  39.         添加node, 参数node是KNode实例.  
  40.  
  41.         如果新插入的node的nid属性长度不等于20, 终止.  
  42.         如果满了, 抛出bucket已满的错误, 终止. 通知上层代码进行拆表.  
  43.         如果未满, 先看看新插入的node是否已存在, 如果存在, 就替换掉, 不存在, 就添加,  
  44.         添加/替换时, 更新该bucket的"新鲜程度".  
  45.         """ 
  46.         if len(node.nid) != 20: return 
  47.         if len(self.nodes) < 8:  
  48.             if node in self.nodes:  
  49.                 self.nodes.remove(node)  
  50.                 self.nodes.append(node)  
  51.             else:  
  52.                 self.nodes.append(node)  
  53.             self.last_accessed = time()  
  54.         else:  
  55.             raise BucketFull  
  56.  
  57.  
  58. class KTable:  
  59.     """  
  60.     该类只实例化一次.  
  61.     """ 
  62.     def __init__(self, nid):  
  63.         """  
  64.         这里的nid就是通过node_id()函数生成的自身node ID. 协议里说道, 每个路由表至少有一个bucket,   
  65.         还规定第一个bucket的min=0, max=2的160次方, 所以这里就给予了一个buckets属性来存储bucket, 这个是列表.  
  66.         """ 
  67.         self.nid = nid #自身node ID  
  68.         self.buckets = [KBucket(0, 2 ** 160)] #存储bucket的例表  
  69.  
  70.     def append(self, node):  
  71.         """添加node, 参数node是KNode实例""" 
  72.  
  73.         #如果待插入的node的ID与自身一样, 那么就忽略, 终止接下来的操作.  
  74.         if node.nid == self.nid: return   
  75.  
  76.         #定位出待插入的node应该属于哪个bucket.  
  77.         index = self.bucket_index(node.nid)  
  78.         bucket = self.buckets[index]  
  79.  
  80.         #协议里说道, 插入新节点时, 如果所归属的bucket是满的, 又都是活跃节点,   
  81.         #那么先看看自身的node ID是否在该bucket的范围里, 如果不在该范围里, 那么就把  
  82.         #该node忽略掉, 程序终止; 如果在该范围里, 就要把该bucket拆分成两个bucket, 按范围"公平平分"node.  
  83.         try:  
  84.             bucket.append(node)  
  85.         except BucketFull:  
  86.             if not bucket.nid_in_range(self.nid): return #这个步骤很重要, 不然递归循环很狂暴, 导致程序死翘翘.  
  87.             self.split_bucket(index)   
  88.             self.append(node)  
  89.  
  90.     def bucket_index(self, nid):  
  91.         """  
  92.         定位bucket的所在索引  
  93.  
  94.         传一个node的ID, 从buckets属性里循环, 定位该nid属于哪个bucket, 找到后, 返回对应的bucket的索引;   
  95.         没有找到, 说明就是要创建新的bucket了, 那么索引值就是最大索引值+1.  
  96.         注意: 为了简单, 就采用循环方式. 这个恐怕不是最有效率的方式.  
  97.         """ 
  98.         for index, bucket in enumerate(self.buckets):  
  99.             if bucket.nid_in_range(nid):  
  100.                 return index  
  101.         return index          
  102.  
  103.     def split_bucket(self, index):  
  104.         """  
  105.         拆表  
  106.  
  107.         index是待拆分的bucket(old bucket)的所在索引值.   
  108.         假设这个old bucket的min:0, max:16. 拆分该old bucket的话, 分界点是8, 然后把old bucket的max改为8, min还是0.   
  109.         创建一个新的bucket, new bucket的min=8, max=16.  
  110.         然后根据的old bucket中的各个node的nid, 看看是属于哪个bucket的范围里, 就装到对应的bucket里.   
  111.         各回各家,各找各妈.  
  112.         new bucket的所在索引值就在old bucket后面, 即index+1, 把新的bucket插入到路由表里.  
  113.         """ 
  114.         old = self.buckets[index]  
  115.         point = old.max - (old.max - old.min)/2 
  116.         new = KBucket(point, old.max)  
  117.         old.max = point  
  118.         self.buckets.insert(index + 1, new)  
  119.         for node in old:  
  120.             if new.nid_in_range(node.nid):  
  121.                 new.append(node)  
  122.         for node in new:  
  123.             old.remove(node)          
  124.  
  125.     def find_close_nodes(self, target):  
  126.         """  
  127.         返回与目标node ID或infohash的最近K个node.  
  128.  
  129.         定位出与目标node ID或infohash所在的bucket, 如果该bucuck有K个节点, 返回.   
  130.         如果不够到K个节点的话, 把该bucket前面的bucket和该bucket后面的bucket加起来, 只返回前K个节点.  
  131.         还是不到K个话, 再重复这个动作. 要注意不要超出最小和最大索引范围.  
  132.         总之, 不管你用什么算法, 想尽办法找出最近的K个节点.  
  133.         """ 
  134.         nodes = []  
  135.         if len(self.buckets) == 0: return nodes  
  136.         index = self.bucket_index(target)  
  137.         nodes = self.buckets[index].nodes  
  138.         min = index - 1 
  139.         max = index + 1 
  140.         while len(nodes) < K and (min >= 0 or max < len(self.buckets)):  
  141.             if min >= 0:  
  142.                 nodes.extend(self.buckets[min].nodes)  
  143.             if max < len(self.buckets):  
  144.                 nodes.extend(self.buckets[max].nodes)  
  145.             min -= 1 
  146.             max += 1 
  147.  
  148.         num = intify(target)  
  149.         nodes.sort(lambda a, b, num=num: cmp(num^intify(a.nid), num^intify(b.nid)))  
  150.         return nodes[:K] #K是个常量, K=8 

ok, 路由表这个玩意儿比较有技术含量, 又难以描述, 所以会贴代码演示. 接下来的DHT客户端/服务端就不再贴那么多的代码了, 毕竟处理网络的代码太多太复杂, 技术含量不高, 按照DHT协议描述的那样操作就行了.

第二步, 实现DHT客户端


共2页: 上一页12下一页

相关内容

    暂无相关文章

评论关闭

最新python教程

python~HOT