字数统计: 3.5k字   |   阅读时长: 15分

python-ndn分析

Python-ndn是Python 3 中支持 AsyncIO 的命名数据网络客户端库。

个人理解：通过调用python-ndn库可以创建新的客户端节点，节点可以产生和接收兴趣包和数据包，节点需要通过NFD进行路由和转发。

简介：ndn.app 包包含类 NDNApp ，它连接 NDN 应用程序和 NFD 节点。NDNApp 提供类似于ndn-cxx 中的应用程序Face 的功能，包括：建立与NFD 节点的连接。表达兴趣并处理返回的数据。使用兴趣处理函数注册和取消注册路由。

/home/ygtrece/.local/lib/python3.6/site-packages/

ndn.app模块包括构造函数，创建用于连接NFD节点的face，(平台默认的接口，Linux下是Unix接口)，用于存储身份和密钥的keychain，兴趣包和数据包的默认验证器。

async def _receive(self, typ: int, data: BinaryStr):函数用于根据不同的包的类型(兴趣包，数据包，Nack包)对包进行解析，提取出对应的字段，并根据包的类型不同调用后续的 _on_xxx函数

put_raw_packet()函数用于调用self.face.send()发送一个data包，发送数据包。

prepare_data()函数通过生成、编码和签名来准备数据包，调用make_data()。

put_data()结合了put_raw_packet()和prepare_data()。

express_interest()函数用于立即发送兴趣包并返回用于获取结果的协程。其调用express_raw_interest()函数。express_raw_interest()函数通过self.face.send(raw_interest)发送兴趣包，然后调用_wait_for_data()阻塞等待，_wait_for_data()调用底层系统函数aio.wait_for()等待数据包到来，直到收到数据并返回该数据。如果无法接收数据或者超过约定的超时时间，则会引发异常。

main_loop()函数:param after_start: 与 NFD 建立连接后启动的协程。:return: True 如果连接不是由Ctrl+C 关闭的。例如，手动或通过对方。调用starting_task()函数，self.register()函数进行自身信息的登记。然后等待self.face.open()和self.face.run()。after_start：与 NFD 建立连接后启动的协程。

route()函数：用于为特定前缀注册永久路由的装饰器。该函数是非阻塞的，可以随时调用。如果在连接 NFD 之前调用它，NDNApp 会记住这条路由，并在每次建立连接时自动注册。将此路由注册到 NFD 失败将被忽略。

register函数：动态注册特定前缀的路由。

unregister函数：取消注册特定前缀的路由。

set_interest_filter：设置兴趣前缀的回调函数，无需向转发器发送注册命令。

unset_interest_filter：删除兴趣前缀的回调函数，而不发送取消注册命令。

关键参数：

这些参数用于填写数据包的 MetaInfo 字段。

  • meta_info (MetaInfo) - Data 的 MetaInfo 字段。 所有其他相关参数将被忽略。
  • content_type (int) - 内容类型。 ContentType.BLOB 默认情况下。
  • freshness_period (int) - FreshnessPeriod 以毫秒为单位。 默认情况下无。
  • final_block_id (BinaryStr) - FinalBlockId。 它应该是一个编码的组件。 默认情况下无。

这些参数用于填写兴趣包的字段。

  • interest_param (InterestParam) - 包含所有参数的数据类。 所有其他相关参数将被忽略。
  • can_be_prefix (bool) - CanBePrefix。 默认为假。
  • must_be_fresh (bool) - MustBeFresh。 默认为假。
  • nonce (int) - 随机数。 默认情况下会生成一个随机数。 要省略 Nonce，请明确将 None 传递给此参数。生命周期 (int) - InterestLifetime 以毫秒为单位。 默认为 4000。
  • hop_limit (int) - HopLimit。 默认情况下无。
  • forwarding_hint (list[NonStrictName]) - 参见 InterestParam。

签名：这些参数用于决定兴趣包或数据包如何签名以及由哪个签名者签名。 每个 Keychain 支持的参数都不同。 此处仅列出默认Keychain 支持的那些。 如果存在冲突，则参数越早列出其优先级越高。

简介：ndn.encoding 包包含有助于对 NDN 名称、名称组件、数据和兴趣进行编码和解码的类和函数。
这个包包含三个部分： TLV 元素：处理 TLV 变量、Names 和 NameComponents。
TlvModel：设计一种描述 TLV 格式的通用方式。 TLV 对象可以用派生自 TlVModel 的类来描述，其成员类型为 Field。
NDN Packet Fotmat v0.3：用于在 NDN Packet Format Spec 0.3 中编码和解析兴趣包和数据包的函数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
def make_interest(name: NonStrictName,
                  interest_param: InterestParam,            #兴趣包的参数
                  app_param: Optional[BinaryStr] = None,    #应用的参数
                  signer: Optional[Signer] = None,          #签名
                  need_final_name: bool = False):       

    interest = InterestPacket()  #InterestPacket是TlvModel的派生类
    interest.interest = InterestPacketValue() #也是TLVModel的派生类，作为整体TLV模型的value部分
    interest.interest.name = name
    interest.interest.can_be_prefix = interest_param.can_be_prefix
    interest.interest.must_be_fresh = interest_param.must_be_fresh
    interest.interest.nonce = interest_param.nonce
    interest.interest.lifetime = interest_param.lifetime
    interest.interest.hop_limit = interest_param.hop_limit

    markers = {}
    interest._signer.set_arg(markers, signer)
    ret = interest.encode(markers=markers)
    shrink_size = interest.interest._shrink_len.get_arg(markers['interest##inner_markers'])
    if shrink_size > 0:
        ret = shrink_length(ret, shrink_size)
    if need_final_name:
        return ret, InterestPacketValue.name.get_final_name(markers['interest##inner_markers'])
    else:
        return ret

简介：ndn.security 包提供了安全使用的基本工具。

简介：ndn.schema 包提供了名称树模式的实现，这是一个应用程序框架，通过应用程序命名空间组织应用程序功能。 可以基于它开发模块化的 NDN 库，应用程序开发人员可以使用这些库作为构建块。
NTSchema 的核心概念是命名空间模式树。 模式树是一个包含应用程序所有可能的命名约定的树结构。 与名称树不同，它的边缘可能是模式变量，而不是特定的名称组件。 例如，路径 /<Identity>/KEY/<KeyID> 可用于表示键的命名约定，其中特定键 - 例如 /Alice/KEY/%01 和 /Bob/KEY/%c2 与之匹配 .
NTSchema 的两个主要组件是自定义节点和策略。 在模式树中，每个节点都代表一个命名空间。 与特定名称匹配后，节点可用于生产和消费数据。 例如，如果我们调用matched_node = tree.match('/Alice/KEY/%01')，它将返回一个匹配节点/<Identity>/KEY/<KeyID>，变量设置Identity='Alice', KeyID =\x01。 然后我们调用matched_node.provide(key_data)，它将生成带有数据key_data的密钥并使其可用。 当我们调用 key_data =matched_node.need() 时，它会尝试获取密钥。 自定义节点将具有自定义管道来处理提供和需要函数调用。 策略是附加到节点的注释，指定用户定义的安全、存储等策略。

基本应用：

NDNApp 连接到 NFD 节点，并提供表达和处理兴趣的接口。以下代码使用默认配置初始化 NDNApp 实例。

1
2
3
from ndn.app import NDNApp	#从ndn.app导入NDNApp函数
app = NDNApp()	#新建一个app
app.run_forever()  #NDNApp 连接到 NFD 节点，并提供表达和处理兴趣的接口，run_forever()函数调用main_loop，self.face.open()和self.face.run()

如果应用程序有 main 函数，请使用该参数。

1
2
3
4
5
6
7
8
9
10
from ndn.app import NDNApp  #从ndn.app导入NDNApp函数
app = NDNApp()  #新建一个app

async def main():
    # Do something
    app.shutdown()  # Close the connection and shutdown

app.run_forever(after_start=main()) 
#NDNApp 连接到 NFD 节点，并提供表达和处理兴趣的接口，run_forever()函数调用main_loop，self.face.open()和self.face.run()
#参数 after_start：与 NFD 建立连接后启动的协程。

消费者：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
from ndn.encoding import Name
async def main():
    try:
        #首先调用app.py中的express_interest，这个函数通过self.face.send(interest)发送兴趣包,返回值调用了_wait_for_data，最后返回生产者发送回的data_name, meta_info, content信息，声明程序挂起，去执行其他的异步程序。kwargs指传不定量的键值对参数
        data_name, meta_info, content = await app.express_interest(
            # Interest Name
            '/example/testApp/randomData',
            must_be_fresh=True,
            can_be_prefix=False,
            # Interest lifetime in ms
            lifetime=6000)
        # Print out Data Name, MetaInfo and its conetnt.
        print(f'Received Data Name: {Name.to_str(data_name)}')
        print(meta_info)
        print(bytes(content) if content else None)
    except InterestNack as e:
        # A NACK is received
        print(f'Nacked with reason={e.reason}')
    except InterestTimeout:
        # Interest times out
        print(f'Timeout')
    except InterestCanceled:
        # Connection to NFD is broken
        print(f'Canceled')
    except ValidationFailure:
        # Validation failure
        print(f'Data failed to validate')
    finally:
        app.shutdown()

生产者

生产者可以调用以注册永久路由。可以在启动应用程序之前完成路由注册。NDNApp 将自动宣布该路由到 NFD 节点。

1
2
3
@app.route('/example/testApp')
def on_interest(name, interest_param, application_param):
    app.put_data(name, content=b'content', freshness_period=10000)

python-ndn提供了一种描述性方法来定义特定的 TLV 格式，称为 TLV 模型。每个对象都可以由从 TlvModel 派生的类来描述。TLV 对象的元素表示为 Field 的实例变量。字段按顺序编码。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
from ndn.encoding import *

class Model(TlvModel):          # Model = [Name] [IntVal] [StrVal] [BoolVal]
    name = NameField()          # Name = NAME-TYPE TLV-LENGTH ...
    int_val = UintField(0x03)   # IntVal = INT-VAL-TYPE TLV-LENGTH nonNegativeInteger
    str_val = BytesField(0x02)  # StrVal = STR-VAL-TYPE TLV-LENGTH *OCTET
    bool_val = BoolField(0x01)  # BoolVal = BOOL-VAL-TYPE 0
#UintField，BytesField，BoolField都在tlv_model中,都是field的派生类，field是一个抽象基类。
#metaclass为 abc.ABCMeta 的抽象基类如果想要声明“抽象方法”，可以使用abc模块中的装饰器 @abstractmethod ，如果想声明“抽象属性”，可以使用abc模块中的@abstractproperty 。
model = Model()
model.name = '/name'
model.str_val = b'bit string'    #b'使变量变为字节类型
assert model.encode() == b'\x07\x06\x08\x04name\x02\nbit string' #assert：表达式为错误时出现异常

model = Model.parse(b'\x07\x06\x08\x04name\x02\nbit string')
assert model.str_val == b'bit string'

TLV 模型中没有必填字段。默认情况下，每个字段都是，这意味着它不会被编码。None

嵌套模型

python-ndn允许一个 TLV 模型是另一个 TLV 模型的字段（ModelField），从而实现分层结构。此外，TLV 模型不包含外部“类型”和“长度”。这可以通过将它封装到另一个TLV模型中来解决。

1
2
3
4
5
6
7
8
9
10
class Inner(TlvModel):              # Inner = [Val1]
    val1 = UintField(0x01)          # Val1  = 1 TLV-LENGTH nonNegativeInteger

class Outer(TlvModel):              # Outer = [Val2]
    val2 = ModelField(0x02, Inner)  # Val2  = 2 TLV-LENGTH Inner

obj = Outer()
obj.val2 = Inner()
obj.val2.val1 = 255
assert obj.encode() == b'\x02\x03\x01\x01\xFF'

重复模型

重复字段是特定类型字段的数组。编码时，元素按顺序编码。

1
2
3
4
5
6
class WordArray(TlvModel):                               # WordArray = *Words
    words = RepeatedField(UintField(0x01, fixed_len=2))  # Words = 1 2 2OCTET

array = WordArray()
array.words = [i for i in range(3)]
assert array.encode() == b'\x01\x02\x00\x00\x01\x02\x00\x01\x01\x02\x00\x02'

派生

为了避免重复，TlvModel可以扩展1个或多个其他TlvModels。但是，要指示 TLV 编码导线中基类的位置，必须为每个基类提供一个字段以显式包含其基类。这些字段必须具有值 IncludeBase。无法分配 TlvModel 实例的包含字段，并且在编码和解析过程中将被忽略。

1
2
3
4
5
6
7
8
9
10
11
class Base(TlvModel):         # Base = [M2]
    m2 = UintField(0x02)

class Derived(Base):          # Derived = [M1] [M2] [M3]
    m1 = UintField(0x01)
    _base = IncludeBase(Base)
    m3 = UintField(0x03)

obj = Derived()
obj.m1, obj.m2, obj.m3 = range(1, 4)
assert obj.encode() == b'\x01\x01\x01\x02\x01\x02\x03\x01\x03'

重写

派生类可以重写其基类的字段。若要覆盖字段，请在包含后声明具有相同名称的字段。覆盖字段将在其原始位置进行编码，与声明顺序无关。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class A1(TlvModel):          # A1 = [M1]
    m1 = UintField(0x01)

class A2(A1):                # A2 = [M1] [M2]
    _a1 = IncludeBase(A1)
    m2 = UintField(0x02)

class B1(TlvModel):          # B1 = [X] [A1] [Y]
    x = UintField(0x0a)
    a = ModelField(0x03, A1)
    y = UintField(0x0b)

class B2(B1):                # B2 = [X] [A2] [Y]
    IncludeBase(B1)
    a = ModelField(0x03, A2)

解析

TlvModel可以从导线解析。所有字段都按顺序解析。如果无序或未知字段是非关键字段，则忽略这些字段。未知的临界场导致 解码错误 。

1
2
3
4
5
6
7
8
9
10
11
from ndn.encoding import *

class Model(TlvModel):          # Model = [Name] [IntVal] [StrVal] [BoolVal]
    name = NameField()          # Name = NAME-TYPE TLV-LENGTH ...
    int_val = UintField(0x03)   # IntVal = INT-VAL-TYPE TLV-LENGTH nonNegativeInteger
    str_val = BytesField(0x02)  # StrVal = STR-VAL-TYPE TLV-LENGTH *OCTET
    bool_val = BoolField(0x01)  # BoolVal = BOOL-VAL-TYPE 0

model = Model.parse(b'\x07\x06\x08\x04name\x02\nbit string')
assert Name.to_str(model.name) == '/name'
assert model.str_val == b'bit string'
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
def prepare_data(self, name: NonStrictName, content: Optional[BinaryStr] = None, **kwargs):
    if 'signer' in kwargs:
        signer = kwargs['signer']
    else:
        signer = self.keychain.get_signer(kwargs)
    if 'meta_info' in kwargs:
        meta_info = kwargs['meta_info']
    else:
        meta_info = MetaInfo.from_dict(kwargs)
    return make_data(name, meta_info, content, signer=signer)	#根据tlv编码规则造出一个数据包

def put_raw_packet(self, data: BinaryStr):
    if not self.face.running:
        raise NetworkError('cannot send packet before connected')
    self.face.send(data)
1
2
3
4
5
6
7
8
9
10
11
12
13
  def express_interest(self,
                       name: NonStrictName,
                       app_param: Optional[BinaryStr] = None,
                       validator: Optional[Validator] = None,
                       need_raw_packet: bool = False,
                       **kwargs) -> Coroutine[Any, None, Tuple[FormalName, MetaInfo, Optional[BinaryStr]]]:
...
      interest, final_name = make_interest(name, interest_param, app_param, signer=signer, need_final_name=True)	#根据tlv编码规则造出一个兴趣包
      future = aio.get_event_loop().create_future()
      node = self._int_tree.setdefault(final_name, InterestTreeNode())
      node.append_interest(future, interest_param)
      self.face.send(interest)	#发送兴趣包
      return self._wait_for_data(future, interest_param.lifetime, final_name, node, validator, need_raw_packet)
1
2
3
4
5
6
7
8
9
10
11
12
async def _wait_for_data(self, future: aio.Future, lifetime: int, name: FormalName, node: InterestTreeNode, validator: Validator, need_raw_packet: bool):
    lifetime = 100 if lifetime is None else lifetime
    try:
        name, meta_info, content, sig, raw_packet = await aio.wait_for(future, timeout=lifetime/1000.0)	#如果无法接收数据或超时，引发异常
    ...
    if await validator(name, sig):
        if need_raw_packet:
            return name, meta_info, content, raw_packet
        else:
            return name, meta_info, content	#返回数据包的字段
    else:
        raise ValidationFailure(name, meta_info, content)

python-ndn提供了一种描述性方法来定义特定的 TLV 格式，称为 TLV 模型。每个对象都可以由从 TlvModel 派生的类来描述。TLV 对象的元素表示为 Field 的实例变量。字段按顺序编码。

python-ndn允许一个 TLV 模型是另一个 TLV 模型的字段ModelField，从而实现分层结构。此外，TLV 模型不包含外部“类型”和“长度”。这可以通过将它封装到另一个TLV模型中来解决。

consumer：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
from ndn.app import NDNApp
from ndn.encoding import Name
import time
app = NDNApp()

async def main():
    while True:
        data_name, meta_info, content = await app.express_interest(
            # Interest Name
            '/example/testApp/Interest',
            must_be_fresh=True,
            can_be_prefix=False,
            # Interest lifetime in ms
            lifetime=6000)
        # Print out Data Name, MetaInfo and its conetnt.
        print(f'Received Data Name: {Name.to_str(data_name)}')
        print(meta_info)
        print(bytes(content) if content else None)
        time.sleep(2)
    #app.shutdown()

app.run_forever(after_start=main())

producer:

1
2
3
4
5
6
7
8
9
10
11
12
from ndn.app import NDNApp
from ndn.encoding import Name
app = NDNApp()

@app.route('/example/testApp')
def on_interest(name, interest_param, application_param):
    app.put_data(name, content=b'content', freshness_period=10000)

async def main():
    on_interest('/example/testApp/Data', b'content', 10000)

app.run_forever(after_start=main())

producer2

1
2
3
4
5
6
7
8
9
10
11
12
13
from ndn.app import NDNApp
from ndn.encoding import Name
app = NDNApp()


def on_interest(name, interest_param, application_param):
    app.put_data(name, content=b'content', freshness_period=10000)

async def main():
    await app.register('/example/testApp', on_interest)
    #on_interest('/example/testApp/Data', b'content', 10000)

app.run_forever(after_start=main())

扫一扫，分享到微信

微信分享二维码
本站总访问量次 |

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

这一定是一个<br><br>很长很长的一生啊