处理器

在 Nornir 中 处理器（Processors） 是一种可以通过自定义代码处理某些事件的插件，它就是一个可以处理任务的装饰器，它在不改变任务结果的前提下，让用户可以自己编写代码对任务结果进行加工，为处理任务提供了更多的扩展性。它有一些优点：

  1. 由于处理器是基于事件（event-based）的，所以可以异步处理事件，例如在某台主机完成任务后马上处理该主机的结果，不用需等待其它主机完成任务。

  2. 基于事件编写的代码更简洁，更容易理解。

来通过几个例子来看看处理器是如何工作的，先初始化一个 nornir 对象：

  1. [1]:
  1. from typing import Dict
  2. from nornir import InitNornir
  4. nr = InitNornir(config_file="files/config.yaml")

编写一个处理器，它的作用是打印一些有关任务执行的信息：

  1. [2]:
  1. from nornir.core import Nornir
  2. from nornir.core.inventory import Host
  3. from nornir.core.task import Task, AggregatedResult, MultiResult, Result, Task
  5. class PrintResult:
  6.     # 任务开始运行时执行的动作
  7.     def task_started(self, task: Task) -> None:
  8.         print(f" 任务[{task.name}] 开始执行 ".center(79, "="))
  10.     # 任务运行结束后执行的动作
  11.     def task_completed(self, task: Task, result: AggregatedResult) -> None:
  12.         print(f" 任务[{task.name}]执行结束 ".center(79, "="))
  14.     # 任务分配给单台主机运行时执行的动作
  15.     def task_instance_started(self, task: Task, host: Host) -> None:
  16.         print(f"任务[{task.name}]分配给主机[{host.name}]开始执行.\n")
  18.     # 任务分配给单台主机运行完成后执行的动作
  19.     def task_instance_completed(
  20.         self, task: Task, host: Host, result: MultiResult
  21.     ) -> None:
  22.         print(f"任务[{task.name}]分配给主机[{host.name}]执行完成，执行结果：{result.result} \n")
  24.     # 子任务开始运行时执行的动作
  25.     def subtask_instance_started(self, task: Task, host: Host) -> None:
  26.         pass
  28.     # 子任务结束运行时执行的动作
  29.     def subtask_instance_completed(
  30.         self, task: Task, host: Host, result: MultiResult
  31.     ) -> None:
  32.         pass

编写一个简单的任务，让自定义的处理器 PrintResult 来处理结果：

  1. [3]:
  1. def greeter(task: Task, greet: str) -> Result:
  2.     return Result(
  3.         host=task.host,
  4.         result=f"{greet}! My name is {task.host.name}!"
  5.     )

要使用自定义的处理器，需要用到 nornir 对象的 with_processors 方法，这个方法需要传递一个 Processer 的列表对象 Processers，然后返回一个带有 Processers 的 nornir 对象：

  1. [4]:
  1. # 为了保持简洁，这里使用过滤器过滤所有角色是 `spine` 的主机来执行任务
  2. nr = nr.filter(role="spine")
  3. nr_with_processors = nr.with_processors([PrintResult()])
  5. nr_with_processors.run(
  6.     task=greeter,
  7.     greet="Hi",
  8.     name="Hi",
  9. )
  11. nr_with_processors.run(
  12.     task=greeter,
  13.     greet="Bye",
  14.     name="Bye",
  15. )
  1. ================================= 任务[Hi] 开始执行 =================================
  2. 任务[Hi]分配给主机[spine00.bj]开始执行.
  4. 任务[Hi]分配给主机[spine00.bj]执行完成，执行结果：Hi! My name is spine00.bj!
  6. 任务[Hi]分配给主机[spine01.bj]开始执行.
  8. 任务[Hi]分配给主机[spine01.gz]开始执行.
  9. 任务[Hi]分配给主机[spine01.bj]执行完成，执行结果：Hi! My name is spine01.bj!
  12. 任务[Hi]分配给主机[spine01.gz]执行完成，执行结果：Hi! My name is spine01.gz!
  14. ================================== 任务[Hi]执行结束 =================================
  15. ================================= 任务[Bye] 开始执行 ================================
  16. 任务[Bye]分配给主机[spine00.bj]开始执行.
  17. 任务[Bye]分配给主机[spine01.bj]开始执行.
  19. 任务[Bye]分配给主机[spine01.bj]执行完成，执行结果：Bye! My name is spine01.bj!
  22. 任务[Bye]分配给主机[spine01.gz]开始执行.
  24. 任务[Bye]分配给主机[spine01.gz]执行完成，执行结果：Bye! My name is spine01.gz!
  26. 任务[Bye]分配给主机[spine00.bj]执行完成，执行结果：Bye! My name is spine00.bj!
  28. ================================= 任务[Bye]执行结束 =================================
  1. [4]:
  1. AggregatedResult (Bye): {'spine00.bj': MultiResult: [Result: "Bye"], 'spine01.bj': MultiResult: [Result: "Bye"], 'spine01.gz': MultiResult: [Result: "Bye"]}

可以看到，任务执行完成后，它的过程都被打印出来了，这是由自定义的处理器 PrintResult 来完成的。

打印结果是无序的，因为默认情况下 nornir 的任务是多线程异步执行的。

前面说到 with_processors 方法需要传递一个 Processers 对象，这个对象是由 Processer 组成的列表。

现在来再定义一个处理器，它的任务是将任务的信息保存在字典中。

  1. [5]:
  1. class SaveResultToDict:
  2.     def __init__(self, data: Dict[str, None]) -> None:
  3.         self.data = data
  5.     def task_started(self, task: Task) -> None:
  6.         self.data[task.name] = {}
  7.         self.data[task.name]["started"] = True
  8.         print(f"任务开始信息已经保存到 {self.data.keys()}!")
  10.     def task_completed(self, task: Task, result: AggregatedResult) -> None:
  11.         self.data[task.name]["completed"] = True
  12.         print(f"任务完成信息已经保存到 {self.data.keys()}!")
  14.     def task_instance_started(self, task: Task, host: Host) -> None:
  15.         self.data[task.name][host.name] = {"started": True}
  16.         print(f"主机[{host.name}]任务开始信息已经保存到 {self.data.keys()}!")
  18.     def task_instance_completed(
  19.         self, task: Task, host: Host, result: MultiResult
  20.     ) -> None:
  21.         self.data[task.name][host.name] = {
  22.             "completed": True,
  23.             "result": result.result,
  24.         }
  25.         print(f"主机[{host.name}]任务完成信息已经保存到 {self.data.keys()}!")
  27.     def subtask_instance_started(self, task: Task, host: Host) -> None:
  28.         pass
  30.     def subtask_instance_completed(
  31.         self, task: Task, host: Host, result: MultiResult
  32.     ) -> None:
  33.         pass

现在来再次执行任务 greeter，这次使用两个处理器 SaveResultToDict 和 PrintResult 来对任务进行处理：

  1. [6]:
  1. data = {}
  3. nr_with_processors = nr.with_processors([PrintResult(),SaveResultToDict(data)])
  5. nr_with_processors.run(
  6.     task=greeter,
  7.     greet="Hi",
  8.     name="Hi",
  9. )
  11. nr_with_processors.run(
  12.     task=greeter,
  13.     greet="Bye",
  14.     name="Bye",
  15. )
  1. ================================= 任务[Hi] 开始执行 =================================
  2. 任务开始信息已经保存到 dict_keys(['Hi'])!
  3. 任务[Hi]分配给主机[spine00.bj]开始执行.
  5. 主机[spine00.bj]任务开始信息已经保存到 dict_keys(['Hi'])!任务[Hi]分配给主机[spine01.bj]开始执行.
  8. 任务[Hi]分配给主机[spine00.bj]执行完成，执行结果：Hi! My name is spine00.bj!
  10. 主机[spine00.bj]任务完成信息已经保存到 dict_keys(['Hi'])!
  11. 任务[Hi]分配给主机[spine01.gz]开始执行.
  13. 主机[spine01.gz]任务开始信息已经保存到 dict_keys(['Hi'])!
  14. 任务[Hi]分配给主机[spine01.gz]执行完成，执行结果：Hi! My name is spine01.gz!
  16. 主机[spine01.gz]任务完成信息已经保存到 dict_keys(['Hi'])!
  17. 主机[spine01.bj]任务开始信息已经保存到 dict_keys(['Hi'])!
  18. 任务[Hi]分配给主机[spine01.bj]执行完成，执行结果：Hi! My name is spine01.bj!
  20. 主机[spine01.bj]任务完成信息已经保存到 dict_keys(['Hi'])!
  21. ================================== 任务[Hi]执行结束 =================================
  22. 任务完成信息已经保存到 dict_keys(['Hi'])!
  23. ================================= 任务[Bye] 开始执行 ================================
  24. 任务开始信息已经保存到 dict_keys(['Hi', 'Bye'])!
  25. 任务[Bye]分配给主机[spine00.bj]开始执行.
  27. 主机[spine00.bj]任务开始信息已经保存到 dict_keys(['Hi', 'Bye'])!
  28. 任务[Bye]分配给主机[spine00.bj]执行完成，执行结果：Bye! My name is spine00.bj!
  30. 主机[spine00.bj]任务完成信息已经保存到 dict_keys(['Hi', 'Bye'])!
  31. 任务[Bye]分配给主机[spine01.bj]开始执行.
  32. 任务[Bye]分配给主机[spine01.gz]开始执行.
  34. 主机[spine01.gz]任务开始信息已经保存到 dict_keys(['Hi', 'Bye'])!
  35. 任务[Bye]分配给主机[spine01.gz]执行完成，执行结果：Bye! My name is spine01.gz!
  37. 主机[spine01.gz]任务完成信息已经保存到 dict_keys(['Hi', 'Bye'])!
  39. 主机[spine01.bj]任务开始信息已经保存到 dict_keys(['Hi', 'Bye'])!
  40. 任务[Bye]分配给主机[spine01.bj]执行完成，执行结果：Bye! My name is spine01.bj!
  42. 主机[spine01.bj]任务完成信息已经保存到 dict_keys(['Hi', 'Bye'])!
  43. ================================= 任务[Bye]执行结束 =================================
  44. 任务完成信息已经保存到 dict_keys(['Hi', 'Bye'])!
  1. [6]:
  1. AggregatedResult (Bye): {'spine00.bj': MultiResult: [Result: "Bye"], 'spine01.bj': MultiResult: [Result: "Bye"], 'spine01.gz': MultiResult: [Result: "Bye"]}

任务已经成功执行，并且两个处理器都按照预期进行工作，任务执行的最后也打印出了最后的结果： AggregatedResult 对象，事实上如果处理器里面已经对结果进行除了，这个对象也不需要再给它赋值然后再使用 print_result 打印出来了。

这里注意一点，因为 Processers 是一个列表，所以它里面 Processer 的执行顺序是按照列表的顺序来运行的。

接下来看一下处理器 SaveResultToDict 对 data 做的操作：

  1. [7]:
  1. import json
  2. print(json.dumps(data, indent=4))
  1. {
  2.     "Hi": {
  3.         "started": true,
  4.         "spine00.bj": {
  5.             "completed": true,
  6.             "result": "Hi! My name is spine00.bj!"
  7.         },
  8.         "spine01.gz": {
  9.             "completed": true,
  10.             "result": "Hi! My name is spine01.gz!"
  11.         },
  12.         "spine01.bj": {
  13.             "completed": true,
  14.             "result": "Hi! My name is spine01.bj!"
  15.         },
  16.         "completed": true
  17.     },
  18.     "Bye": {
  19.         "started": true,
  20.         "spine00.bj": {
  21.             "completed": true,
  22.             "result": "Bye! My name is spine00.bj!"
  23.         },
  24.         "spine01.gz": {
  25.             "completed": true,
  26.             "result": "Bye! My name is spine01.gz!"
  27.         },
  28.         "spine01.bj": {
  29.             "completed": true,
  30.             "result": "Bye! My name is spine01.bj!"
  31.         },
  32.         "completed": true
  33.     }
  34. }

通过以上两个示例，可以看到 处理器（Processers） 处理器的强大功能，通过它来操作处理任务结果更加简单，也无需通过 print_result 来查看任务结果。

一些想法

借助处理器还可以做哪些其他事情？

  1. 将任务执行事件发送到 slack/IRC/logging_system

  2. 让使用者可以关注到正在的执行的任务情况而无需等待所有主机的任务执行完成（尤其是当设备数量很多时）

  3. 如果某些任务失败，及时通知/发出警报

  4. 根据业务场景尽情发挥吧！

Nornir 基础教程到这里就结束了，如果想要更加深入的了解，请继续阅读进阶部分。