devbox
知新_RL
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Python-Switch-Route 使用Python3通过SSH和SNMP操作交换机_python3 连接交换机

作者：知新_RL | 2024-02-28 00:27:52

赞

踩

python3 连接交换机

通过Python自动操作交换机

文件一：Main_Switch.py 操作示例

文件二：DEF_SSH_eNSP_Switch_S5700.py 通过SSH交互控制交换机完成任务

文件三：DEF_SNMP_eNSP_Switch_S5700.py 通过SNMP获取交换机信息

文件四：DEV_SSH.py 操作交换机的SSH驱动部分

文件五：DEV_SNMP.py 操作交换机SNMP驱动部分，目前这个需要Linux环境

 

文件一代码：

  1. #_*_ coding:utf8 _*_
  2. from DEF_SNMP_eNSP_Switch_S5700 import *
  3. from DEF_SSH_eNSP_Switch_S5700 import *
  4.  
  5. import logging                                                              # 日志模块
  6. Log = logging.getLogger('__name__')                                         # 获取实例
  7. formatter = logging.Formatter('%(asctime)s %(levelname)-8s: %(message)s')   # 指定logger输出格式
  8. file_handler = logging.FileHandler('Main_Switch.log')                       # 日志文件路径
  9. file_handler.setFormatter(formatter)                                        # 可以通过setFormatter指定输出格式
  10. Log.addHandler(file_handler)                                                # 为logger添加的日志处理器
  11. # 设置记录的日志级别
  12. #Log.setLevel(logging.DEBUG)
  13. Log.setLevel(logging.INFO)
  14. #Log.setLevel(logging.WARNING)
  15. #Log.setLevel(logging.ERROR)
  16. #Log.setLevel(logging.CRITICAL)
  17.  
  18.  
  19.  
  20. ## 测试 SNMP 功能
  21.  
  22. '''
  23. ## SNMP 功能由于 DEV_SNMP.py 是根据Linux写的，需要Linux环境
  25. SNMP_PWD = 'pwd@123'
  26. SNMP_HOST = '192.168.56.2'
  27. SNMP_Ver = '2c'
  29. ## 查询设备IP和MAC绑定信息，生成字典形式
  30. R = SNMP_生成以IP为键以MAC地址列表为值的字典(SNMP_PWD, SNMP_HOST)
  31. if R[0] == 0:
  32.     D_IP_MAC = R[1]
  33.     INFO = '成功，IP和MAC绑定信息字典：' + str(D_IP_MAC)
  34.     Log.info(INFO)
  35.     print(INFO)
  36. else:
  37.     ERROR = '失败，错误信息：'+ R[1]
  38.     Log.error(ERROR)
  39.     print(ERROR)
  42. ## 查询设备VLAN接口的IP地址信息，生成字典形式
  43. R = SNMP_生成以VLAN为键以VLAN_IP_MASK列表为值的字典(SNMP_PWD, SNMP_HOST)
  44. if R[0] == 0:
  45.     D_VLAN_NET = R[1]
  46.     INFO = '成功，VLAN接口和IP信息字典：' + str(D_VLAN_NET)
  47.     Log.info(INFO)
  48.     print(INFO)
  49. else:
  50.     ERROR = '失败，错误信息：'+ R[1]
  51.     Log.error(ERROR)
  52.     print(ERROR)
  53. '''
  54.  
  55.  
  56.  
  57.  
  58. ## 测试 SSH 功能
  59.  
  60. # 每台SSH设备的登录信息
  61. D_DEV0 = {}
  62. D_DEV0['SSH_USER'] = 'test'
  63. D_DEV0['SSH_PASS'] = 'pwd@123'
  64. D_DEV0['SSH_IP'] = '192.168.0.1'
  65. D_DEV0['SSH_PORT'] = 2001
  66.  
  67. D_DEV1 = {}
  68. D_DEV1['SSH_USER'] = 'test'
  69. D_DEV1['SSH_PASS'] = 'pwd@123'
  70. D_DEV1['SSH_IP'] = '192.168.1.1'
  71.  
  72. D_DEV2 = {}
  73. D_DEV2['SSH_USER'] = 'test'
  74. D_DEV2['SSH_PASS'] = 'pwd@123'
  75. D_DEV2['SSH_IP'] = '192.168.56.2'
  76.  
  77.  
  78. ## 全部SSH设备组成列表（顺序无所谓）
  79. L_DEVS = [D_DEV0, D_DEV1, D_DEV2]
  80.  
  81.  
  82. ## 制作选提示信息
  83. 设备列表 = '''
  84. 可以登录的设备列表
  85. '''
  86. for i in range(0, len(L_DEVS)):
  87.     设备列表 += '[ '+ str(i) + ' ] 选择 ' + L_DEVS[i]['SSH_IP'] + ' 设备进行操作\n'
  88. 设备列表 += '[ q ] 退出选择设备\n请选择设备：'
  89.  
  90. #print(设备列表)
  91. '''
  93. 可以登录的设备列表
  94. [ 0 ] 选择 192.168.0.1 设备进行操作
  95. [ 1 ] 选择 192.168.1.1 设备进行操作
  96. [ 2 ] 选择 192.168.56.2 设备进行操作
  97. [ q ] 退出选择设备
  99. '''
  100.  
  101.  
  102. ## 制作业务功能选择列表
  103. 业务列表 = '''=== 功能菜单 ===
  104. [ 0 ] 保存配置
  105. [ 1 ] 查看全部IP和MAC绑定信息
  106. [ 2 ] 绑定指定IP和指定MAC
  107. [ 3 ] 在指定网段自动选择可用IP和指定MAC绑定
  108. [ 4 ] 查找MAC地址所在网段
  109. [ 5 ] 在MAC所在网段自动选择可用IP和进行绑定
  110. [ 6 ] 解除指定IP和指定MAC的绑定
  111. [ 7 ] 解除指定IP的全部MAC绑定
  112. [ 8 ] 解除指定MAC的全部IP绑定
  113. [ e ] 改变登录设备
  114. [ q ] 退出功能程序
  115. === 功能菜单 ===
  117. 请输入功能编号：'''
  118.  
  119.  
  120.  
  121. ## 循环交互操作
  122. while 1:
  123.     if '字典_登录信息' in locals().keys():
  124.         print("【提示】当前已经缓存", 字典_登录信息['SSH_IP'], "登录信息")
  125.         print()
  126.     else:
  127.         目标设备 = input(设备列表)
  128.         INDEX = [str(i) for i in range(0, len(L_DEVS))]
  129.         if 目标设备 in INDEX:
  130.             字典_登录信息 = L_DEVS[int(目标设备)]
  131.             print("【提示】当前已经选择", 字典_登录信息['SSH_IP'], "登录信息")
  132.             print()
  133.         elif 目标设备 == 'q':
  134.             print("用户退出选择")
  135.             break
  136.         else:
  137.             print("无效输入，请重新选择")
  138.             print()
  139.             while 1:
  140.                 目标设备 = input(设备列表)
  141.                 INDEX = [str(i) for i in range(0, len(L_DEVS))]
  142.                 if 目标设备 in INDEX:
  143.                     字典_登录信息 = L_DEVS[int(目标设备)]
  144.                     print("【提示】当前已经选择", 字典_登录信息['SSH_IP'], "登录信息")
  145.                     print()
  146.                 elif 目标设备 == 'q':
  147.                     print("用户退出选择")
  148.                     break
  149.             break
  150.  
  151.     业务选择 = input(业务列表)
  152.     # 0 保存配置
  153.     if 业务选择 == '0':
  154.         T0 = time.time()
  155.         print("正在执行 保存配置 请稍后")
  156.         R = 保存配置(字典_登录信息)
  157.         T1 = time.time()
  158.         if R[0] == 0:
  159.             INFO = R[1]
  160.             Log.info(INFO)
  161.             print(INFO)
  162.         else:
  163.             ERROR = R[1]
  164.             Log.error(ERROR)
  165.             print(ERROR)
  166.         print("耗时 %.1f 秒" % (T1-T0))
  167.         print()
  168.     # 1 查看全部IP和MAC绑定信息
  169.     elif 业务选择 == '1':
  170.         T0 = time.time()
  171.         print("正在执行 查看全部IP和MAC绑定信息 请稍后")
  172.         R = 获取IP和MAC绑定信息(字典_登录信息)
  173.         T1 = time.time()
  174.         if R[0] == 0:
  175.             print("成功")
  176.             D_IP_MAC = R[1]
  177.             if D_IP_MAC == {}:
  178.                 print("当前无绑定记录")
  179.             else:
  180.                 print("IP\t\t绑定MAC列表")
  181.                 for K in D_IP_MAC:
  182.                     print(K, "\t", D_IP_MAC[K])
  183.         else:
  184.             print("失败")
  185.             print("失败原因", R[1])
  186.         print("耗时 %.1f 秒" % (T1-T0))
  187.         print()
  188.     # 2 绑定指定IP和指定MAC
  189.     elif 业务选择 == '2':
  190.         Bind_IP  = input("输入要绑定的IP地址（如192.168.0.1)：")
  191.         Bind_MAC = input("要绑定的MAC地址（任意mac地址写法）：")
  192.         T0 = time.time()
  193.         print("正在执行 绑定指定IP和指定MAC 请稍后")
  194.         R = 绑定指定IP和指定MAC(字典_登录信息, Bind_IP, Bind_MAC)
  195.         T1 = time.time()
  196.         if R[0] == 0:
  197.             print("成功")
  198.             print("成功信息", R[1])
  199.             INFO = R[1]
  200.             Log.info(INFO)
  201.             print(INFO)
  202.         else:
  203.             print("失败")
  204.             print("失败原因", R[1])
  205.             ERROR = R[1]
  206.             Log.error(ERROR)
  207.         print("耗时 %.1f 秒" % (T1-T0))
  208.         print()
  209.     # 3在指定网段自动选择可用IP和指定MAC绑定
  210.     elif 业务选择 == '3':
  211.         Bind_NET  = input("要绑定的网段（如192.168.0.1/24 或 192.168.0.1/255.255.255.0： ")
  212.         Bind_MAC = input("要绑定的MAC地址（任意mac地址写法）：")
  213.         T0 = time.time()
  214.         print("正在执行 在指定网段自动选择可用IP和指定MAC绑定 请稍后")
  215.         R = 在指定网段自动选择可用IP和指定MAC绑定(字典_登录信息, Bind_NET, Bind_MAC)
  216.         T1 = time.time()
  217.         if R[0] == 0:
  218.             print("成功")
  219.             print("成功信息", R[1])
  220.             INFO = R[1]
  221.             Log.info(INFO)
  222.             print(INFO)
  223.         else:
  224.             print("失败")
  225.             print("失败原因", R[1])
  226.             ERROR = R[1]
  227.             Log.error(ERROR)
  228.         print("耗时 %.1f 秒" % (T1-T0))
  229.         print()
  230.     # 4 查找MAC地址所在网段
  231.     elif 业务选择 == '4':
  232.         MAC = input("要查找的MAC地址（任意mac地址写法）：")
  233.         T0 = time.time()
  234.         print("正在执行 查找MAC地址所在网段 请稍后")
  235.         R = 查找MAC地址所在网段(字典_登录信息, MAC)
  236.         T1 = time.time()
  237.         if R[0] == 0:
  238.             print("成功")
  239.             print("成功信息", R[1])
  240.             INFO = R[1]
  241.             Log.info(INFO)
  242.             print(INFO)
  243.         else:
  244.             print("失败")
  245.             print("失败原因", R[1])
  246.             ERROR = R[1]
  247.             Log.error(ERROR)
  248.         print("耗时 %.1f 秒" % (T1-T0))
  249.         print()
  250.     # 5 在MAC所在网段自动选择可用IP和进行绑定
  251.     elif 业务选择 == '5':
  252.         Bind_MAC = input("要绑定的MAC地址（任意mac地址写法）：")
  253.         T0 = time.time()
  254.         print("正在执行 在MAC所在网段自动选择可用IP和进行绑定 请稍后")
  255.         R = 在MAC所在网段自动选择可用IP和进行绑定(字典_登录信息, Bind_MAC)
  256.         T1 = time.time()
  257.         if R[0] == 0:
  258.             print("成功")
  259.             print("成功信息", R[1])
  260.             INFO = R[1]
  261.             Log.info(INFO)
  262.             print(INFO)
  263.         else:
  264.             print("失败")
  265.             print("失败原因", R[1])
  266.             ERROR = R[1]
  267.             Log.error(ERROR)
  268.         print("耗时 %.1f 秒" % (T1-T0))
  269.         print()
  270.     # 6 解除指定IP和指定MAC的绑定
  271.     elif 业务选择 == '6':
  272.         Undo_Bind_IP  = input("要解除绑定的IP地址（如192.168.0.1)：")
  273.         Undo_Bind_MAC = input("要解除绑定的MAC地址（任意mac地址写法）：")
  274.         T0 = time.time()
  275.         print("正在执行 解除指定IP和指定MAC的绑定 请稍后")
  276.         R = 解除指定IP和指定MAC的绑定(字典_登录信息, Undo_Bind_IP, Undo_Bind_MAC)
  277.         T1 = time.time()
  278.         if R[0] == 0:
  279.             print("成功")
  280.             print("成功信息", R[1])
  281.             INFO = R[1]
  282.             Log.info(INFO)
  283.             print(INFO)
  284.         else:
  285.             print("失败")
  286.             print("失败原因", R[1])
  287.             ERROR = R[1]
  288.             Log.error(ERROR)
  289.         print("耗时 %.1f 秒" % (T1-T0))
  290.         print()
  291.     # 7 解除指定IP的全部MAC绑定
  292.     elif 业务选择 == '7':
  293.         Undo_Bind_IP  = input("要解除绑定的IP地址（如192.168.0.1)：")
  294.         T0 = time.time()
  295.         print("正在执行 解除指定IP的全部MAC绑定 请稍后")
  296.         R = 解除指定IP的全部MAC绑定(字典_登录信息, Undo_Bind_IP)
  297.         T1 = time.time()
  298.         if R[0] == 0:
  299.             print("成功")
  300.             print("成功信息", R[1])
  301.             INFO = R[1]
  302.             Log.info(INFO)
  303.             print(INFO)
  304.         else:
  305.             print("失败")
  306.             print("失败原因", R[1])
  307.             ERROR = R[1]
  308.             Log.error(ERROR)
  309.         print("耗时 %.1f 秒" % (T1-T0))
  310.         print()
  311.     # 8 解除指定MAC的全部IP绑定
  312.     elif 业务选择 == '8':
  313.         Undo_Bind_MAC = input("要解除绑定的MAC地址（任意mac地址写法）：")
  314.         T0 = time.time()
  315.         print("正在执行 解除指定MAC的全部IP绑定 请稍后")
  316.         R = 解除指定MAC的全部IP绑定(字典_登录信息, Undo_Bind_MAC)
  317.         T1 = time.time()
  318.         if R[0] == 0:
  319.             print("成功")
  320.             print("成功信息", R[1])
  321.             INFO = R[1]
  322.             Log.info(INFO)
  323.             print(INFO)
  324.         else:
  325.             print("失败")
  326.             print("失败原因", R[1])
  327.             ERROR = R[1]
  328.             Log.error(ERROR)
  329.         print("耗时 %.1f 秒" % (T1-T0))
  330.         print()
  331.     elif 业务选择 == 'e':
  332.         print()
  333.         print("【提示】修改登录设备")
  334.         while 1:
  335.             目标设备 = input(设备列表)
  336.             INDEX = [str(i) for i in range(0, len(L_DEVS))]
  337.             if 目标设备 in INDEX:
  338.                 字典_登录信息 = L_DEVS[int(目标设备)]
  339.                 print("【提示】当前重新选择", 字典_登录信息['SSH_IP'], "登录信息")
  340.                 print()
  341.                 break
  342.             elif 目标设备 == 'q':
  343.                 print("用户退出选择")
  344.                 break
  345.             else:
  346.                 print("无效输入，请重新选择")
  347.     elif 业务选择 == 'q':
  348.         print("用户正常退出程序")
  349.         break
  350.     else:
  351.         print("无效选择，重新选择")

 

 

文件二代码：

  1. #_*_ coding:utf8 _*_
  2. from DEV_SSH import *
  3. import struct
  4. import re
  5. import logging          # 日志模块
  6. import sys
  7.  
  8. Log = logging.getLogger("__name__")
  9. if not logging.FileHandler:
  10.     # 指定logger输出格式
  11.     formatter = logging.Formatter('%(asctime)s %(levelname)-8s : %(message)s')
  12.     # 文件日志
  13.     file_handler = logging.FileHandler("log")
  14.     file_handler = logging.FileHandler("DEF_eNSP_Switch_S5700.log") # 日志文件路径
  15.     file_handler.setFormatter(formatter)  # 可以通过setFormatter指定输出格式
  16.     Log.addHandler(file_handler)
  17.     Log.setLevel(logging.DEBUG)
  18.  
  19.  
  20.  
  21.  
  22.  
  23. ###############################################################################################################################
  24. ## 检查IP是否合法
  25. ## 参数 IP_STR    点分十进制字符串，例：'192.168.0.1'
  26. def TEST_IP_STR(IP_STR):
  27.     if type(IP_STR) == str:
  28.         L_IP = IP_STR.split('.')                                                                ## 以点分割，各元素组成列表
  29.         if len(L_IP) == 4:
  30.             try:                                                                                ## 尝试把4段内容转成数字
  31.                 IP_0 = int(L_IP[0])
  32.                 IP_1 = int(L_IP[1])
  33.                 IP_2 = int(L_IP[2])
  34.                 IP_3 = int(L_IP[3])
  35.             except:
  36.                 ERROR = '函数 TEST_IP_STR() 参数 IP_STR 以点分成4段中有不能转成数字的部分'
  37.                 return(1, ERROR)
  38.             else:                                                                               ## 4段值各自转成数字成功后判断每个数字的取值范围
  39.                 if 0<= IP_0 <=255 and 0<= IP_1 <=255 and 0<= IP_2 <=255 and 0<= IP_3 <=255:
  40.                     INFO = '函数 TEST_IP_STR() 参数 IP_STR 检测合格，变量值 = ' + IP_STR
  41.                     return(0, INFO)
  42.                 else:
  43.                     ERROR = '函数 TEST_IP_STR() 参数 IP_STR 以点分成4段中有超出0-255范围的值'
  44.                     return(1, ERROR)
  45.         else:
  46.             ERROR = '函数 TEST_IP_STR() 参数 IP_STR 不能以点分成4段'
  47.             return(1, ERROR)
  48.     else:
  49.         ERROR = '函数 TEST_IP_STR() 参数 IP_STR 类型不是字符串'
  50.         return(1, ERROR)
  51. ###############################################################################################################################
  52.  
  53.  
  54. ###############################################################################################################################
  55. ## 检查登录信息字典
  56. ## 参数 D_LOGIN_INFO  帐号、密码、地址、端口组成的字典
  57. ## 如果无端口号设置为默认22端口（会修改字典）
  58. def TEST_D_LOGIN_INFO(D_LOGIN_INFO):
  59.     if type(D_LOGIN_INFO) != dict:
  60.         E = '函数 TEST_D_LOGIN_INFO 参数 D_LOGIN_INFO 必须是字典类型'
  61.         return(1, E)
  62.  
  63.     if 'SSH_USER' not in D_LOGIN_INFO:
  64.         E = '函数 TEST_D_LOGIN_INFO 参数 D_LOGIN_INFO 中 KEY SSH_USER 不存在（没有登录帐号信息）'
  65.         return(1, E)
  66.     else:
  67.         登录帐号 = D_LOGIN_INFO['SSH_USER']
  68.         if type(登录帐号) != str:
  69.             E = '函数 TEST_D_LOGIN_INFO 参数 D_LOGIN_INFO 中 KEY SSH_USER 的值（登录帐号）不是字符串'
  70.             return(1, E)
  71.  
  72.     if 'SSH_PASS' not in D_LOGIN_INFO:
  73.         E = '函数 TEST_D_LOGIN_INFO 参数 D_LOGIN_INFO 中 KEY SSH_PASS 不存在（没有登录密码）'
  74.         return(1, E)
  75.     else:
  76.         登录密码 = D_LOGIN_INFO['SSH_PASS']
  77.         if type(登录密码) != str:
  78.             E = '函数 TEST_D_LOGIN_INFO 参数 D_LOGIN_INFO 中 KEY SSH_PASS 的值（登录密码）不是字符串'
  79.             return(1, E)
  80.  
  81.     if 'SSH_IP' not in D_LOGIN_INFO:
  82.         E = '函数 TEST_D_LOGIN_INFO 参数 D_LOGIN_INFO 中 KEY SSH_IP 不存在（没有登录IP地址）'
  83.         return(1, E)
  84.     else:
  85.         IP_STR = D_LOGIN_INFO['SSH_IP']
  86.         R = TEST_IP_STR(IP_STR)                     ## 调用 TEST_IP_STR() 检查IP是否合法
  87.         if R[0] != 0:
  88.             E = '函数 TEST_D_LOGIN_INFO 参数 D_LOGIN_INFO 中 KEY SSH_IP 的值（登录IP地址）IP格式错误 ' + R[1]
  89.             return(1, E)
  90.  
  91.     if 'SSH_PORT' not in D_LOGIN_INFO:
  92.         D_LOGIN_INFO['SSH_PORT'] = 22
  93.         INFO = '函数 TEST_D_LOGIN_INFO 参数 D_LOGIN_INFO 中 KEY SSH_PORT 不存在（没有登录端口号）自动设置为默认22端口号'
  94.         return(0, INFO)                             ## 修改为默认端口号后全部检查合格
  95.     else:
  96.         PORT = D_LOGIN_INFO['SSH_PORT']
  97.         if type(PORT) != int:
  98.             E = '函数 TEST_D_LOGIN_INFO 参数 D_LOGIN_INFO 中 KEY SSH_PORT 的值（登录端口号）不是数字'
  99.             return(1, E)
  100.         else:
  101.             if 0< PORT <65535:
  102.                 INFO = '函数 TEST_D_LOGIN_INFO 参数 D_LOGIN_INFO 中 KEY SSH_PORT 的值（登录端口号）在(0,65535)区间内，检测合格，变量值 = ' + str(PORT)
  103.                 return(0, INFO)                     ## 全部检查合格
  104.             else:
  105.                 E = '函数 TEST_D_LOGIN_INFO 参数 D_LOGIN_INFO 中 KEY SSH_PORT 的值（登录端口号）数值不在(0,65535)区间内'
  106.                 return(1, E)
  107. ###############################################################################################################################
  108.  
  109.  
  110. ###############################################################################################################################
  111. ## 尝试把掩码转成掩码位数
  112. ## MASK 参数类型：字符串（'24' 或 '255.255.255.0' 样式）
  113. ## MASK 参数类型：数字（0到32）
  114. ## 成功返回 (0, 掩码位数（数字）)
  115. ## 失败返回 (1, 错误信息)
  116. def TRY_MASK_2_MASK_INT(MASK):
  117.     ## 字符串掩码格式和掩码长度对应的字典，方便快速查找
  118.     D_MASK = {
  119.     '0.0.0.0':0,
  120.     '128.0.0.0':1,'192.0.0.0':2,'224.0.0.0':3,'240.0.0.0':4,'248.0.0.0':5,'252.0.0.0':6,'254.0.0.0':7,'255.0.0.0':8,
  121.     '255.128.0.0':9,'255.192.0.0':10,'255.224.0.0':11,'255.240.0.0':12,'255.248.0.0':13,'255.252.0.0':14,'255.254.0.0':15,'255.255.0.0':16,
  122.     '255.255.128.0':17,'255.255.192.0':18,'255.255.224.0':19,'255.255.240.0':20,'255.255.248.0':21,'255.255.252.0':22,'255.255.254.0':23,'255.255.255.0':24,
  123.     '255.255.255.128':25,'255.255.255.192':26,'255.255.255.224':27,'255.255.255.240':28,'255.255.255.248':29,'255.255.255.252':30,'255.255.255.254':31,
  124.     '255.255.255.255':32}
  125.  
  126.     if type(MASK) == int:                               ## 如果是数字类型，后续再判断数值是否在掩码范围内
  127.         if 0 <= MASK <= 32:                             ## 如果掩码数值在0到32内
  128.             return(0, MASK)                             ## 返回成功状态码0和掩码数值
  129.         else:
  130.             ERROR = 'ERROR 变量范围：掩码只能在0到32范围内'
  131.             return(1, ERROR)
  132.     elif type(MASK) == str:                             ## 如果是字符串类型，可能是数字掩码，可能是字符串类型的数字掩码
  133.         try:
  134.             ## 尝试把参数MASK转成数字类型
  135.             MASK_INT = int(MASK)                        ## int() 函数可以自动删除字符串类型数字的前后空格
  136.         except:
  137.             ## 不能转换成数字可能是点分十格式掩码的字符串
  138.             L_MASK = MASK.split('.')                    ## 以点分割，各元素组成列表
  139.             if len(L_MASK) == 4:                        ## 如果能分成4段，说明是点分十格式掩码字符串
  140.                 if MASK in D_MASK:                      ## 如果这个点分十格式掩码字符串存在于掩码和掩码位数字典中
  141.                     MASK_INT = D_MASK[MASK]             ## 获取点分十格式掩码字符串对应的掩码数值
  142.                     return(0, MASK_INT)                 ## 返回成功状态码0和掩码数值
  143.                 else:
  144.                     ERROR = 'ERROR 变量范围：掩码超出有效范围'
  145.                     return(1, ERROR)
  146.             else:                                       ## 如果不能分成4段，格式错误
  147.                 ERROR = 'ERROR 变量格式：掩码格式错误'
  148.                 return(1, ERROR)
  149.         else:                                           ## 可以转成数字
  150.             RR = TRY_MASK_2_MASK_INT(MASK_INT)                    ## 调用自身函数处理新的数字类型参数
  151.             return(RR)                                  ## 返回自身处理结果给上级函数
  152.     else:
  153.         ERROR = 'ERROR 参数类型：只能是数字或字符串或字符串类型的数字'
  154.         return(1, ERROR)
  155. ###############################################################################################################################
  156.  
  157.  
  158. ## IP_INT 转 IP_STR
  159. ## IP_INT（4字节无符号整数类型IP地址）
  160. ## IP_STR（点分十进制字符串类型IP地址）
  161. def IP_INT_2_IP_STR(IP_INT):
  162.     IP_Byte = struct.pack('>I', IP_INT)     # 打包成4字节无符号整数（大端/网络端）
  163.     元组_IP_数字 = struct.unpack('BBBB', IP_Byte)
  164.     ## 每个数字转成字符串并加上'.'拼成点分十形式字符串
  165.     #IP_STR = str(元组_IP_数字[0]) +'.'+ str(元组_IP_数字[1]) +'.'+ str(元组_IP_数字[2]) +'.'+ str(元组_IP_数字[3]) ## Python2用这个写法
  166.     IP_STR = f'{str(元组_IP_数字[0])}.{str(元组_IP_数字[1])}.{str(元组_IP_数字[2])}.{str(元组_IP_数字[3])}'         ## Python3可用的新写法
  167.     return(IP_STR)
  168.  
  169.  
  170. ## IP_STR 转 IP_INT
  171. ## IP_STR（点分十进制字符串类型IP地址）
  172. ## IP_INT（4字节无符号整数类型IP地址）
  173. def IP_STR_2_IP_INT(IP_STR):
  174.     IP分段 = IP_STR.split('.')
  175.     B_IP = struct.pack('BBBB', int(IP分段[0]), int(IP分段[1]), int(IP分段[2]), int(IP分段[3]))  # 4个字节数字按顺序拼成4字节字节码
  176.     T_IP_INT = struct.unpack('>I', B_IP)    # 把拼成的4字节字节码转成大端格式的4字节无符号整数
  177.     IP_INT = T_IP_INT[0]                    # 打包成字节返回是元组，第一个元素是打包的结果
  178.     return(IP_INT)
  179.  
  180.  
  181. ## 根据地址和掩码计算起始和结束地址
  182. ## 返回(NET_IP_MIN, NET_IP_MAX)
  183. ## NET_IP_MIN（网段首地址/网段号）
  184. ## NET_IP_MAX（网段末地址/广播号）
  185. def 根据地址和掩码计算起始和结束地址(IP_STR, MASK_INT):
  186.     主机位数 = 32 - MASK_INT
  187.     主机数量 = 2**主机位数
  188.     IP_INT = IP_STR_2_IP_INT(IP_STR)
  189.     位移操作缓存 = IP_INT >> 主机位数
  190.     IP_NET_INT = 位移操作缓存 << 主机位数
  191.     NET_IP_MIN = IP_NET_INT                 ## 每个网段的首IP地址为网段号
  192.     NET_IP_MAX = IP_NET_INT + 主机数量 -1   ## 每个网段的末IP地址为广播号（以0为第一个，最后一个要总数-1）
  193.     return(NET_IP_MIN, NET_IP_MAX)
  194.  
  195.  
  196. ## 根据IP地址和掩码位数生成IP所在网段的全部IP_INT地址列表（列表从小到大顺序）
  197. ## IP_INT（4字节无符号整数类型IP地址）
  198. ## IP_STR（点分十进制字符串类型IP地址）
  199. ## MASK_INT（掩码长度数字，范围0-32）
  200. def IP_MASK_2_IP_INT_LIST(IP_STR, MASK_INT):
  201.     主机位数 = 32 - MASK_INT                                   ## 32位的IPv4地址由网络位部分和主机位部分组成
  202.     主机数量 = 2**主机位数                                     ## 主机数量由主机位的比特个数可以组成数字的全部可能组合
  203.     IP_INT = IP_STR_2_IP_INT(IP_STR)                           ## （点分十进制字符串类型IP地址）转成（4字节无符号整数类型IP地址）
  204.     位移操作缓存 = IP_INT >> 主机位数                          ## 先往右移主机个数位，清除主机位上的值
  205.     IP_NET_INT = 位移操作缓存 << 主机位数                      ## 再往左移主机个数位，填充主机位上的值为0，得到IP的所在段的网络号（网段中第一个IP地址）对应的4字节数字值
  206.     IP_INT_LIST = [i+IP_NET_INT for i in range(0,主机数量)]    ## 生成IP所在网段的全部IP地址
  207.     return(IP_INT_LIST)                                        ## 返回网段全部IP地址
  208.  
  209.  
  210. ## 根据IP地址和掩码位数生成IP所在网段的全部IP_STR地址列表（列表从小到大顺序）
  211. ## IP_STR（点分十进制字符串类型IP地址）
  212. ## MASK_INT（掩码长度数字，范围0-32）
  213. def IP_MASK_2_IP_STR_LIST(IP_STR, MASK_INT):
  214.     主机位数 = 32 - MASK_INT
  215.     主机数量 = 2**主机位数
  216.     IP_INT = IP_STR_2_IP_INT(IP_STR)
  217.     位移操作缓存 = IP_INT >> 主机位数
  218.     IP_NET_INT = 位移操作缓存 << 主机位数
  219.     IP_STR_LIST = []
  220.     for i in range(0,主机数量):
  221.         R = IP_INT_2_IP_STR(IP_NET_INT + i)     ## IP的数字值转成IP点分十格式字符串
  222.         IP_STR_LIST.append(R)
  223.     return(IP_STR_LIST)
  224.  
  225.  
  226. ##################################################################################
  227. ## 功能函数 MAC缓存信息转成MAC对应VLAN字典()
  228. ## 把如下字符串内容
  229. ## <Huawei>display mac-address
  230. ## MAC address table of slot 0:
  231. ## -------------------------------------------------------------------------------
  232. ## MAC Address    VLAN/       PEVLAN CEVLAN Port            Type      LSP/LSR-ID  
  233. ##                VSI/SI                                              MAC-Tunnel  
  234. ## -------------------------------------------------------------------------------
  235. ## 0a00-2700-0010 1           -      -      GE0/0/1         dynamic   0/-         
  236. ## 5489-9836-1256 1           -      -      GE0/0/2         dynamic   0/-
  237. ## 5489-9836-1256 2           -      -      GE0/0/3         dynamic   0/-（缓存过期前电脑移动到别的vlan会多出这样的缓存记录）
  238. ## -------------------------------------------------------------------------------
  239. ## Total matching items on slot 0 displayed = 2 
  240. ## <Huawei>
  241. ## 转换成字典 {'0a00-2700-0010': ['1'], '5489-9836-1256': ['1', '2']}
  242. ##################################################################################
  243. def MAC缓存信息转成MAC对应VLAN字典(S_DATA):
  244.     D_MAC_VLAN = {}
  245.     MAC表达式 = '[a-f0-9A-F]{4}\-[a-f0-9A-F]{4}\-[a-f0-9A-F]{4}'
  246.     MAC缓存记录表达式 = MAC表达式 + '(.*)'
  247.     RE_F = re.finditer(MAC缓存记录表达式, S_DATA)
  248.     列表_MAC缓存信息 = [i.group() for i in RE_F]
  249.     #print("列表_MAC缓存信息", 列表_MAC缓存信息)
  250.     if 列表_MAC缓存信息 != []:
  251.         for i in 列表_MAC缓存信息:
  252.             L = i.split()
  253.             #print("L", L)
  254.             if len(L) > 1:                          # 能分成2段及以上
  255.                 MAC = L[0]                          # 字符串类型MAC地址
  256.                 VLAN = L[1]                         # 字符串类型的数字（VLAN号）
  257.                 #print("MAC", MAC, "VLAN", VLAN)
  258.                 if MAC not in D_MAC_VLAN:
  259.                     D_MAC_VLAN[MAC] = [VLAN]
  260.                 else:
  261.                     if VLAN not in D_MAC_VLAN[MAC]:
  262.                         D_MAC_VLAN[MAC].append(VLAN)
  263.                     #else:
  264.                     #    pass
  265.     return(D_MAC_VLAN)
  266.  
  267.  
  268. ################################################################################
  269. ## 功能函数 VLAN和NET字典()
  270. ## 把如下字符串内容
  271. ## <Huawei>display ip interface brief
  272. ## Interface                         IP Address/Mask      Physical   Protocol  
  273. ## MEth0/0/1                         unassigned           down       down      
  274. ## NULL0                             unassigned           up         up(s)     
  275. ## Vlanif10                          192.168.10.1/24      down       down      
  276. ## Vlanif20                          192.168.20.1/24      down       down      
  277. ## <Huawei>
  278. ## 转换成字典 {'Vlanif10': ['192.168.10.1/24'], 'Vlanif20': ['192.168.20.1/24']}
  279. ################################################################################
  280. def VLAN和NET字典(S_DATA):
  281.     D_VLAN_IP_MASK = {}
  282.     IP表达式 = '[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+/[0-9]+'    # 数字.数字.数字.数字/数字
  283.     表达式 = '(.*)Vlanif(.*)' + IP表达式
  284.     RE_F = re.finditer(表达式, S_DATA)
  285.     列表_VLAN_NET = [i.group() for i in RE_F]             # 每条匹配内容做成列表形式
  286.     #print("列表_VLAN_NET", 列表_VLAN_NET)
  287.     
  288.     if 列表_VLAN_NET != []:
  289.         for i in 列表_VLAN_NET:
  290.             L = i.split()
  291.             #print("L", L)
  292.             if len(L) > 1:                                # 能分成2段及以上
  293.                 VLAN = L[0]                               # 字符串类型MAC地址
  294.                 NET = L[1]                                # 字符串类型的数字（VLAN号）
  295.                 #print("VLAN", VLAN, "NET", NET)
  296.                 if VLAN not in D_VLAN_IP_MASK:
  297.                     D_VLAN_IP_MASK[VLAN] = [NET]
  298.                 else:
  299.                     D_VLAN_IP_MASK[VLAN].append(NET)
  300.     return(D_VLAN_IP_MASK)
  301.  
  302.  
  303. ###############################################################################
  304. ## 功能函数 VLAN和IP字典()
  305. ## 把如下字符串内容
  306. ## <Huawei>display ip interface brief
  307. ## Interface                         IP Address/Mask      Physical   Protocol  
  308. ## MEth0/0/1                         unassigned           down       down      
  309. ## NULL0                             unassigned           up         up(s)     
  310. ## Vlanif10                          192.168.10.1/24      down       down      
  311. ## Vlanif20                          192.168.20.1/24      down       down      
  312. ## <Huawei>
  313. ## 转换成字典 {'Vlanif10': ['192.168.10.1'], 'Vlanif20': ['192.168.20.1']}
  314. ###############################################################################
  315. def VLAN和IP字典(S_DATA):
  316.     D_VLAN_IP = {}
  317.     IP表达式 = '[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+'     # 数字.数字.数字.数字
  318.     表达式 = '(.*)Vlanif(.*)' + IP表达式
  319.     RE_F = re.finditer(表达式, S_DATA)
  320.     列表_VLAN_IP = [i.group() for i in RE_F]        # 每条匹配内容做成列表形式
  321.     #print("列表_VLAN_IP", 列表_VLAN_IP)
  322.     
  323.     if 列表_VLAN_IP != []:
  324.         for i in 列表_VLAN_IP:
  325.             L = i.split()
  326.             #print("L", L)
  327.             if len(L) > 1:                          # 能分成2段及以上
  328.                 VLAN = L[0]                         # 字符串类型MAC地址
  329.                 IP = L[1]                           # 字符串类型的数字（VLAN号）
  330.                 #print("VLAN", VLAN, "IP", IP)
  331.                 if VLAN not in D_VLAN_IP:
  332.                     D_VLAN_IP[VLAN] = [IP]
  333.                 else:
  334.                     D_VLAN_IP[VLAN].append(IP)
  335.     return(D_VLAN_IP)
  336.  
  337.  
  338. ###############################################################################################################################
  339. ## 尝试把网段表示格式：'IP/MASK' 格式转成元组 (IP_STR, MASK_INT)
  340. ## 参数 NET_STR 网段表示格式（字符串）例：'192.168.0.0/255.255.255.0' 或 '192.168.0.0/24'
  341. ## 成功返回 (0, (IP_STR, MASK_INT))
  342. ## 把 192.168.0.1/24 拆成 '192.168.0.1' 和 24
  343. ## 把 192.168.0.1/255.255.255.0 拆成 '192.168.0.1' 和 24
  344. ## 失败返回 (1, 错误信息)
  345. def TRY_NET_STR_2_IP_MASK(NET_STR):
  346.     if type(NET_STR) == str:
  347.         L_IP_MASK = NET_STR.split('/')
  348.         if len(L_IP_MASK) == 2:
  349.             IP_STR = L_IP_MASK[0]
  350.             MASK_STR = L_IP_MASK[1]
  351.             #print("IP_STR", IP_STR, type(IP_STR))
  352.             #print("MASK_STR", MASK_STR, type(MASK_STR))
  353.             TEST_IP = TEST_IP_STR(IP_STR)                      ## 判断IP是否正确
  354.             R_TRY_MASK = TRY_MASK_2_MASK_INT(MASK_STR)         ## 判断并处理掩码
  355.             if TEST_IP[0] == R_TRY_MASK[0] == 0:               ## 当IP和MASK全部合法时计算可用IP地址
  356.                 MASK_INT = R_TRY_MASK[1]
  357.                 return(0, (IP_STR, MASK_INT))
  358.             else:
  359.                 ERROR = 'ERROR 参数格式(字符串)：'
  360.                 if TEST_IP[0] == 1:
  361.                     ERROR += 'IP格式有错误：' + TEST_IP[1]
  362.                 if R_TRY_MASK[0] == 1:
  363.                     ERROR += '掩码格式有错误：' + R_TRY_MASK[1]
  364.                 return(1, ERROR)
  365.         else:
  366.             ERROR = 'ERROR 参数格式(字符串)：不能以"/"符号分成2段'
  367.             return(1, ERROR)
  368.     else:
  369.         ERROR = 'ERROR 参数类型：必须是字符串'
  370.         return(1, ERROR)
  371. ###############################################################################################################################
  372.  
  373.  
  374. ###############################################################################################################################
  375. ## 尝试把MAC地址转成指定格式
  376. ## 参数 MAC_STR   字符串类型的MAC地址，只要含有12个十六进制字符即可
  377. ## 参数 转换格式  把传入的MAC地址形式转成指定样式，参数默认值为网络设备常用样式：'xxxx-xxxx-xxxx'
  378. def TRY_MAC_2_MAC(MAC_STR, 转换格式='xxxx-xxxx-xxxx'):
  379.     if type(MAC_STR) == str:
  380.         MAC_STR = re.sub('[^a-fA-F0-9]', '', MAC_STR)                   # 先删除不是16进制范围的字符
  381.         if len(MAC_STR) == 12:                                          # 判断新的 mac 长度是否正常
  382.             if 转换格式 == 'xxxx-xxxx-xxxx':
  383.                 mac = MAC_STR.lower()
  384.                 mac_new = mac[0:4] + '-' + mac[4:8] + '-' + mac[8:12]   # 改成新格式 xxxx-xxxx-xxxx
  385.                 return(0, mac_new)
  386.             elif 转换格式 == 'XXXX-XXXX-XXXX':
  387.                 MAC = MAC_STR.upper()
  388.                 MAC_NEW = MAC[0:4] + '-' + MAC[4:8] + '-' + MAC[8:12]   # 改成新格式 XXXX-XXXX-XXXX
  389.                 return(0, MAC_NEW)
  390.             elif 转换格式 == 'xx-xx-xx-xx-xx-xx':
  391.                 mac = MAC_STR.lower()
  392.                 mac_new = mac[0:2] + '-' + mac[2:4] + '-' + mac[4:6] + '-' + mac[6:8] + '-' + mac[8:10] + '-' + mac[10:12]   # 改成新格式 xx-xx-xx-xx-xx-xx
  393.                 return(0, mac_new)
  394.             elif 转换格式 == 'XX-XX-XX-XX-XX-XX':
  395.                 MAC = MAC_STR.upper()
  396.                 MAC_NEW = MAC[0:2] + '-' + MAC[2:4] + '-' + MAC[4:6] + '-' + MAC[6:8] + '-' + MAC[8:10] + '-' + MAC[10:12]   # 改成新格式 XX-XX-XX-XX-XX-XX
  397.                 return(0, MAC_NEW)
  398.             elif 转换格式 == 'xx:xx:xx:xx:xx:xx':
  399.                 mac = MAC_STR.lower()
  400.                 mac_new = mac[0:2] + ':' + mac[2:4] + ':' + mac[4:6] + ':' + mac[6:8] + ':' + mac[8:10] + ':' + mac[10:12]   # 改成新格式 xx:xx:xx:xx:xx:xx
  401.                 return(0, mac_new)
  402.             elif 转换格式 == 'XX:XX:XX:XX:XX:XX':
  403.                 MAC = MAC_STR.upper()
  404.                 MAC_NEW = MAC[0:2] + ':' + MAC[2:4] + ':' + MAC[4:6] + ':' + MAC[6:8] + ':' + MAC[8:10] + ':' + MAC[10:12]   # 改成新格式 XX:XX:XX:XX:XX:XX
  405.                 return(0, MAC_NEW)
  406.             else:
  407.                 ERROR = '函数 TRY_MAC_2_MAC() 参数 转换格式 的形式未定义'
  408.                 return(1, ERROR)
  409.         else:
  410.             ERROR = '函数 TRY_MAC_2_MAC() 参数 MAC_STR 不是有效MAC地址: ' + MAC_STR
  411.             return(1, ERROR)
  412.     else:
  413.         ERROR = '函数 TRY_MAC_2_MAC() 参数 MAC_STR 需要是字符串类型，当前类型是：' + str(type(MAC_STR))
  414.         return(1, ERROR)
  415. ###############################################################################################################################
  416.  
  417.  
  418. ###############################################################################################################################
  419. ## 功能函数：查看交互命令行当前所在模式，如果不是查看模式，执行quit命令直到返回查看模式
  420. ## 参数 S_DATA    执行交互命令后的回显内容
  421. ## 参数 SHELL     交互操作子SHELL对象
  422. ## 参数 最大深度  执行quit命令的最大次数
  423. def 返回查看模式(S_DATA, SHELL, 最大深度=5):
  424.     if 最大深度 > 0:
  425.         L_S_DATA = S_DATA.split()                                               # 以空格分隔回显内容
  426.         Log.debug('函数 返回查看模式() 的 L_S_DATA 变量值 = ' + str(L_S_DATA))
  427.         最后内容 = L_S_DATA[-1]                                                 # 取最后一段，一般为等待命令的提示符（交换机终端回显日志会有干扰，交换机设置禁止终端打印日志功能）
  428.         查看模式 = re.search('<(.*)>', 最后内容)                                # 尝试查找<>结构
  429.         配置模式 = re.search('\[(.*)\]', 最后内容)                              # 尝试查找[]结构
  430.         if 配置模式:
  431.             CMD = 'quit'
  432.             S_DATA = SHELL_CMD(SHELL, CMD, 0.5)
  433.             Log.debug('判断是配置模式，执行quit命令，回显内容：' + S_DATA)
  434.             最大深度 = 最大深度 -1
  435.             R = 返回查看模式(S_DATA, SHELL, 最大深度)
  436.             return(R)
  437.         elif 查看模式:
  438.             INFO = '已经返回到<查看模式>'
  439.             return(0,INFO)
  440.         else:
  441.             ERROR = '最后一行找不到 <> 或 [] 符号'
  442.             return(1,ERROR)
  443.     else:
  444.         ERROR = '已经退出最大深度还没有返回到<查看模式>放弃'
  445.         return(1,ERROR)
  446. ###############################################################################################################################
  447.  
  448.  
  449. ###############################################################################################################################
  450. ## 功能函数：从查询静态绑定信息命令回显中提取以IP为KEY以MAC为值的字典
  451. ## 参数 S_DATA    执行交互命令后的回显内容
  452. ## 把如下字符串内容
  453. ## dis cu | include user-bind static
  454. ## user-bind static ip-address 1.1.1.1 mac-address 0000-1111-2222
  455. ## user-bind static ip-address 1.1.1.1 mac-address 0000-0000-0001
  456. ## user-bind static ip-address 1.1.1.2 mac-address 0000-0000-0002
  457. ## <Huawei>
  458. ## 转换成字典 {'1.1.1.1': ['0000-1111-2222', '0000-0000-0001'], '1.1.1.2': ['0000-0000-0002']}
  459. def IP_MAC_绑定信息转成IP为KEY字典(S_DATA):
  460.     D_IP_MAC = {}                                                   # 存放IP为键MAC为值的字典 示例 {'IP1':['MAC'], 'IP2':['MAC1', 'MAC2']}
  461.  
  462.     ## 从命令回显中过滤出纯IP和MAC的绑定记录，并转成列表形式
  463.     表达式 = '(.*)ip-address(.*)mac-address(.*)'                    # 匹配绑定记录的正则表达式
  464.     RE_F = re.finditer(表达式, S_DATA)                              # 找到所有匹配的内容（每条绑定记录）
  465.     列表_绑定信息 = [i.group() for i in RE_F]                       # 每条匹配内容做成列表形式
  466.     #print("列表_绑定信息", 列表_绑定信息)
  467.  
  468.     ## 定位IP和MAC各自在绑定记录的位置
  469.     if 列表_绑定信息 != []:
  470.         首条记录 = 列表_绑定信息[0]                                     # 提取第一条绑定记录
  471.         列表_首条记录分割 = 首条记录.split()                            # 第一条绑定记录以空格分段变成列表
  472.         IP表达式 = '[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+'                     # 匹配 x.x.x.x 类型IP地址的正则表达式
  473.         MAC表达式 = '[a-f0-9A-F]{4}\-[a-f0-9A-F]{4}\-[a-f0-9A-F]{4}'    # 匹配 xxxx-xxxx-xxxx 类型MAC地址的正则表达式
  474.         IP_位置 = ''                                                    # 准备存放 IP 下标值
  475.         MAC_位置 = ''                                                   # 准备存放 MAC 下标值
  476.         for i in range(0, len(列表_首条记录分割)):                      # 遍历首条绑定记录每一段内容
  477.             RE_IP = re.search(IP表达式, 列表_首条记录分割[i])           # 尝试在当前段中匹配IP地址
  478.             RE_MAC = re.search(MAC表达式, 列表_首条记录分割[i])         # 尝试在当前段中匹配MAC地址
  479.             if RE_IP:                                                   # 如果在当前段中匹配到IP地址
  480.                 #print(i, "is IP:", 列表_首条记录分割[i])
  481.                 IP_位置 = i                                             # 设置'IP_位置'变量值为当前段下标值（数字int类型）
  482.             if RE_MAC:                                                  # 如果在当前段中匹配到MAC地址
  483.                 #print(i, "is MAC:", 列表_首条记录分割[i])
  484.                 MAC_位置 = i                                            # 设置'MAC_位置'变量值为当前段下标值（数字int类型）
  485.  
  486.         ## 逐行提取IP和MAC的值，做成字典形式
  487.         if IP_位置 != '' and MAC_位置 != '':                            # 当'IP_位置'和'MAC_位置'都找到对应下标时
  488.             for i in 列表_绑定信息:                                     # 遍历每一条绑定记录
  489.                 #print("每行内容", i)
  490.                 SP = i.split()                                          # 绑定记录以空格分段成列表
  491.                 #print("SP", SP)
  492.                 IP = SP[IP_位置]                                        # 根据已知下标提取IP的值
  493.                 MAC = SP[MAC_位置]                                      # 根据已知下标提取MAC的值
  494.                 if IP not in D_IP_MAC:                                  # 如果当前IP不在D_IP_MAC字典中
  495.                     D_IP_MAC[IP] = [MAC]                                # 向D_IP_MAC字典中添加此对键值对，MAC做成列表形式
  496.                 else:                                                   # 如果当前IP已经存在D_IP_MAC字典中
  497.                     D_IP_MAC[IP].append(MAC)                            # 把MAC添加到对应键值对中
  498.             #print("D_IP_MAC", D_IP_MAC)
  499.             return(D_IP_MAC)                                            # 返回制作好的字典，如果没有绑定记录也会返回空字典
  500.         else:                                                           # 当'IP_位置'和'MAC_位置'任意一个没有找到对应下标时
  501.             return(D_IP_MAC)                                            # 直接返回空字典
  502.     else:
  503.         return(D_IP_MAC)                                                # 回显结果中没有找到任何IP和MAC的绑定记录，直接返回空字典
  504. ###############################################################################################################################
  505.  
  506.  
  507. ###############################################################################################################################
  508. ## 功能函数：从查询静态绑定信息命令回显中提取以MAC为KEY以IP为值的字典
  509. ## 参数 S_DATA    执行交互命令后的回显内容
  510. ## 把如下字符串内容
  511. ## dis cu | include user-bind static
  512. ## user-bind static ip-address 1.1.1.1 mac-address 0000-1111-2222
  513. ## user-bind static ip-address 1.1.1.1 mac-address 0000-0000-0001
  514. ## user-bind static ip-address 1.1.1.2 mac-address 0000-0000-0002
  515. ## <Huawei>
  516. ## 转换成字典 {'0000-1111-2222': ['1.1.1.1'], '0000-0000-0001': ['1.1.1.1'], '0000-0000-0002': ['1.1.1.2']}
  517. def IP_MAC_绑定信息转成MAC为KEY字典(S_DATA):
  518.     D_MAC_IP = {}
  519.  
  520.     表达式 = '(.*)ip-address(.*)mac-address(.*)'
  521.     RE_F = re.finditer(表达式, S_DATA)
  522.     列表_绑定信息 = [i.group() for i in RE_F]
  523.     #print("列表_绑定信息", 列表_绑定信息)
  524.  
  525.     if 列表_绑定信息 != []:
  526.         首条记录 = 列表_绑定信息[0]
  527.         列表_首条记录分割 = 首条记录.split()
  528.         IP表达式 = '[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+'
  529.         MAC表达式 = '[a-f0-9A-F]{4}\-[a-f0-9A-F]{4}\-[a-f0-9A-F]{4}'
  530.         IP_位置 = ''
  531.         MAC_位置 = ''
  532.         for i in range(0, len(列表_首条记录分割)):
  533.             RE_IP = re.search(IP表达式, 列表_首条记录分割[i])
  534.             RE_MAC = re.search(MAC表达式, 列表_首条记录分割[i])
  535.             if RE_IP:
  536.                 #print(i, "is IP:", 列表_首条记录分割[i])
  537.                 IP_位置 = i
  538.             if RE_MAC:
  539.                 #print(i, "is MAC:", 列表_首条记录分割[i])
  540.                 MAC_位置 = i
  541.  
  542.         if IP_位置 != '' and MAC_位置 != '':
  543.             for i in 列表_绑定信息:
  544.                 #print("每行内容", i)
  545.                 SP = i.split()
  546.                 #print("SP", SP)
  547.                 IP = SP[IP_位置]
  548.                 MAC = SP[MAC_位置]
  549.                 if MAC not in D_MAC_IP:
  550.                     D_MAC_IP[MAC] = [IP]
  551.                 else:
  552.                     D_MAC_IP[MAC].append(IP)
  553.             #print("D_MAC_IP", D_MAC_IP)
  554.             return(D_MAC_IP)
  555.         else:
  556.             return(D_MAC_IP)
  557.     else:
  558.         return(D_MAC_IP)
  559. ###############################################################################################################################
  560.  
  561.  
  562. ###############################################################################################################################
  563. ## 功能函数：在IP和MAC对应字典中是否出现IP和MAC绑定记录
  564. ## 参数 D 有IP和MAC对应关系的字典，可以是 D_IP_MAC 或 D_MAC_IP
  565. ## 参数 IP 点分十进制字符串类型IP地址
  566. ## 参数 MAC 连字符十六进制字符串类型MAC地址
  567. def 判断是否绑定成功(D, IP, MAC):
  568.     if D == {}:
  569.         E = '绑定失败：绑定记录是空字典'
  570.         return(1,E)
  571.  
  572.     if IP in D:                                                                 # 是以IP为key的字典格式
  573.         if MAC in D[IP]:
  574.             INFO = '绑定成功，当前 ' + IP + ' 的绑定MAC信息列表 ' + str(D[IP])
  575.             return(0, INFO)
  576.         else:
  577.             ERROR = '绑定失败，当前 ' + IP + ' 的绑定MAC信息列表 ' + str(D[IP])
  578.             return(1, ERROR)
  579.     elif MAC in D:                                                              # 是以MAC为key的字典格式
  580.         if IP in D[MAC]:
  581.             INFO = '绑定成功，当前 ' + MAC + ' 的绑定IP信息列表 ' + str(D[MAC])
  582.             return(0,INFO)
  583.         else:
  584.             ERROR = '绑定失败，当前 ' + MAC + ' 的绑定IP信息列表 ' + str(D[MAC])
  585.             return(1, ERROR)
  586.     else:                                                                       # 没有IP或MAC的绑定记录
  587.         ERROR = '绑定失败，没有 ' + IP + ' 或 ' + MAC + ' 的任何的绑定记录'
  588.         return(1, ERROR)
  589. ###############################################################################################################################
  590.  
  591.  
  592. ###############################################################################################################################
  593. ## 功能函数 自动查找网段中可用IP_优先自增()
  594. ## 不填充中间有被删除绑定的IP地址空缺位置
  595. ## 新MAC分配的IP优先使用已经绑定的最大IP地址的后一个IP地址
  596. ## 在达到自动分配可用的最大IP后再填充中间空缺IP位置（从小开始填充）
  597. ###############################################################################################################################
  598. def 自动查找网段中可用IP_优先自增(NET_IP_STR, NET_MASK_INT, S_DATA, 网段开头保留地址数量=1, 网段末尾保留地址数量=1):
  599.     ## 检查参数是否合法
  600.     if 网段开头保留地址数量 < 0:
  601.         ERROR = '函数参数 网段开头保留地址数量 小于0'
  602.         return(1, ERROR)
  603.     if 网段末尾保留地址数量 < 0:
  604.         ERROR = '函数参数 网段末尾保留地址数量 小于0'
  605.         return(1, ERROR)
  606.     ## 计算可用IP地址范围及判断是否还有可自动分配IP地址
  607.     NET_IP_MIN, NET_IP_MAX = 根据地址和掩码计算起始和结束地址(NET_IP_STR, NET_MASK_INT)     ## 网段首末地址：网段号和广播号
  608.     可自动分配地址最小值 = NET_IP_MIN + 1 + 网段开头保留地址数量                            ## 起始IP +1 排除网络号，再加上网段开头保留地址数量
  609.     可自动分配地址最大值 = NET_IP_MAX - 1 - 网段末尾保留地址数量                            ## 结尾IP -1 避开广播号，再减去网段末尾保留地址数量
  610.     #print("可自动分配地址最小值", 可自动分配地址最小值, IP_INT_2_IP_STR(可自动分配地址最小值))
  611.     #print("可自动分配地址最大值", 可自动分配地址最大值, IP_INT_2_IP_STR(可自动分配地址最大值))
  612.     Log.debug('可自动分配地址最小值：' + str(可自动分配地址最小值) + ' ' + IP_INT_2_IP_STR(可自动分配地址最小值))
  613.     Log.debug('可自动分配地址最大值：' + str(可自动分配地址最大值) + ' ' + IP_INT_2_IP_STR(可自动分配地址最大值))
  614.     if 可自动分配地址最小值 > 可自动分配地址最大值:
  615.         ERROR = '没有可自动分配地址：保留地址过多 或 网段太小'
  616.         return(1, ERROR)
  617.  
  618.     ## 开始查找可用IP地址
  619.     可用_IP_STR = ''
  620.     
  621.     ## 从 S_DATA 绑定信息中提取全部的IP地址
  622.     D_IP_MAC = IP_MAC_绑定信息转成IP为KEY字典(S_DATA)
  623.     L_BIND_IP_STR = [i for i in D_IP_MAC]                          ## 列表_已绑定的全部IP地址(字符形式)
  624.     #print("L_BIND_IP_STR 已绑定使用地址", L_BIND_IP_STR)
  625.     Log.debug('已绑定使用地址（IP_STR）：' + str(L_BIND_IP_STR))
  626.     L_BIND_IP_INT = [IP_STR_2_IP_INT(i) for i in L_BIND_IP_STR]    ## 列表_已绑定的全部IP地址(数字形式)
  627.     #print("L_BIND_IP_INT 已绑定使用地址", L_BIND_IP_INT)
  628.     Log.debug('已绑定使用地址（IP_INT）：' + str(L_BIND_IP_INT))
  629.     
  630.     ## 自动分配网段可用地址中已经被占用的地址：在已绑定的全部IP地址中有多少个是自动分配网段中可以使用的IP地址
  631.     ## 如果没有，那自动分配网段中的全部地址都可以使用，直接取最小的用
  632.     ## 如果有，
  633.     列表_网段已被占用地址 = [i for i in L_BIND_IP_INT if 可自动分配地址最小值<=i<=可自动分配地址最大值]
  634.     #print("列表_网段已被占用地址", 列表_网段已被占用地址)
  635.     Log.debug('列表_网段已被占用地址：' + str(列表_网段已被占用地址))
  636.     if 列表_网段已被占用地址 == []:
  637.         #print("网段", NET_IP_STR, NET_MASK_INT, "暂无绑定记录，直接使用网段中可自动分配地址的最小IP地址")
  638.         Log.debug('网段' + NET_IP_STR +'/'+ str(NET_MASK_INT) + '暂无绑定记录，直接使用网段中可自动分配地址的最小IP地址')
  639.         可用_IP_INT = 可自动分配地址最小值              ## 直接使用网段中可自动分配地址的最小IP地址
  640.         可用_IP_STR = IP_INT_2_IP_STR(可用_IP_INT)      ## 数字型IP地址转成字符型IP地址
  641.         return(0, 可用_IP_STR)
  642.     else:
  643.         网段已被占用地址_MAX = max(列表_网段已被占用地址)     ## 提取网段中已经使用的最大IP值
  644.         if 网段已被占用地址_MAX +1 <= 可自动分配地址最大值:   ## 如果网段中已经使用的最大IP值增加1还自动分配可用地址范围内
  645.             可用_IP_INT = 网段已被占用地址_MAX +1             ## 可用IP就取网段中已经使用的最大IP的后一个IP地址
  646.             可用_IP_STR = IP_INT_2_IP_STR(可用_IP_INT)
  647.             #print("使用已经绑定IP的后一个IP地址", 可用_IP_STR)
  648.             Log.debug('使用已经绑定IP的后一个IP地址：' + 可用_IP_STR)
  649.             return(0, 可用_IP_STR)
  650.         else:                                                           ## 否则表示已经到顶，返回去看看有没有解绑掉的空缺IP地址
  651.             #print("自增方式自动分配IP已经到顶，开始从头查看是否有已经解绑的空缺IP地址")
  652.             集合_网段已被占用地址 = set(列表_网段已被占用地址)          ## 转成集合判断元素是否存在会快一点
  653.             #print("集合_网段已被占用地址", 集合_网段已被占用地址)
  654.             for i in range(可自动分配地址最小值, 可自动分配地址最大值+1):    ## 从小到大遍历自动分配可用地址
  655.                 #print("遍历可网段中可自动分配IP地址", i, IP_INT_2_IP_STR(i))
  656.                 if i not in 集合_网段已被占用地址:                      ## 如果遍历到的这个IP地址不在已经绑定地址集合中
  657.                     可用_IP_STR = IP_INT_2_IP_STR(i)                    ## 遍历到的这个IP地址就是可用地址，转成字符形式IP地址
  658.                     #print("找到空缺可用IP地址", 可用_IP_STR)
  659.                     Log.debug('找到空缺可用IP地址：' + 可用_IP_STR)
  660.                     break                                               ## 找到了就终止循环
  661.             ## 判断捡漏查找结果
  662.             if 可用_IP_STR == '':
  663.                 ERROR = '无可用地址：网段可自动分配区间地址已经全部被使用，可以尝试扩大网段或减少保留地址数量'
  664.                 return(1, ERROR)
  665.             else:
  666.                 return(0, 可用_IP_STR)
  667.  
  668.  
  669. ###############################################################################################################################
  670. ## 功能函数 自动查找网段中可用IP_自动填充()
  671. ## 在已用IP范围外和自动分配地址范围内找到最小可用IP
  672. ## 会填充自动分配地址范围内有被删除IP的空缺位置
  673. ###################################################
  674. def 自动查找网段中可用IP_自动填充(NET_IP_STR, NET_MASK_INT, S_DATA, 网段开头保留地址数量=1, 网段末尾保留地址数量=1):
  675.     ## 检查参数是否合法
  676.     if 网段开头保留地址数量 < 0:
  677.         ERROR = '函数参数 网段开头保留地址数量 小于0'
  678.         return(1, ERROR)
  679.     if 网段末尾保留地址数量 < 0:
  680.         ERROR = '函数参数 网段末尾保留地址数量 小于0'
  681.         return(1, ERROR)
  682.     ## 计算可用IP地址范围及判断是否还有可自动分配IP地址
  683.     NET_IP_MIN, NET_IP_MAX = 根据地址和掩码计算起始和结束地址(NET_IP_STR, NET_MASK_INT)     ## 网段首末地址：网段号和广播号
  684.     可自动分配地址最小值 = NET_IP_MIN + 1 + 网段开头保留地址数量                            ## 起始IP +1 排除网络号，再加上网段开头保留地址数量
  685.     可自动分配地址最大值 = NET_IP_MAX - 1 - 网段末尾保留地址数量                            ## 结尾IP -1 避开广播号，再减去网段末尾保留地址数量
  686.     #print("可自动分配地址最小值", 可自动分配地址最小值, IP_INT_2_IP_STR(可自动分配地址最小值))
  687.     #print("可自动分配地址最大值", 可自动分配地址最大值, IP_INT_2_IP_STR(可自动分配地址最大值))
  688.     Log.debug('可自动分配地址最小值：' + str(可自动分配地址最小值) + ' ' + IP_INT_2_IP_STR(可自动分配地址最小值))
  689.     Log.debug('可自动分配地址最大值：' + str(可自动分配地址最大值) + ' ' + IP_INT_2_IP_STR(可自动分配地址最大值))
  690.     if 可自动分配地址最小值 > 可自动分配地址最大值:
  691.         ERROR = '没有可自动分配地址：保留地址过多 或 网段太小'
  692.         return(1, ERROR)
  693.     
  694.     ## 开始查找可用IP地址
  695.     可用_IP_STR = ''
  696.     
  697.     ## 从 S_DATA 绑定信息中提取全部的IP地址
  698.     D_IP_MAC = IP_MAC_绑定信息转成IP为KEY字典(S_DATA)
  699.     L_BIND_IP_STR = [i for i in D_IP_MAC]                             ## 列表_已绑定的全部IP地址(字符形式)
  700.     #print("L_BIND_IP_STR 已绑定使用地址", L_BIND_IP_STR)
  701.     Log.debug('已绑定使用地址（IP_STR）：' + str(L_BIND_IP_STR))
  702.     L_BIND_IP_INT = [IP_STR_2_IP_INT(i) for i in L_BIND_IP_STR]       ## 列表_已绑定的全部IP地址(数字形式)
  703.     #print("L_BIND_IP_INT 已绑定使用地址", L_BIND_IP_INT)
  704.     Log.debug('已绑定使用地址（IP_INT）：' + str(L_BIND_IP_INT))
  705.     
  706.     ## 从小到大遍历可以自动分配的地址范围，判断是否被使用，尝试找出没有被使用的最小IP，作为自动绑定的可用IP
  707.     列表_网段已被占用地址 = [i for i in L_BIND_IP_INT if 可自动分配地址最小值<=i<=可自动分配地址最大值]
  708.     #print("列表_网段已被占用地址", 列表_网段已被占用地址)
  709.     集合_网段已被占用地址 = set(列表_网段已被占用地址)                ## 转成集合判断元素是否存在会快一点
  710.     #print("集合_网段已被占用地址", 集合_网段已被占用地址)
  711.     for i in range(可自动分配地址最小值, 可自动分配地址最大值+1):     ## 从小到大遍历自动分配可用地址
  712.         #print("遍历可网段中可自动分配IP地址", i, IP_INT_2_IP_STR(i))
  713.         if i not in 集合_网段已被占用地址:                            ## 如果遍历到的这个IP地址不在已经绑定地址集合中
  714.             可用_IP_STR = IP_INT_2_IP_STR(i)                          ## 遍历到的这个IP地址就是可用地址，转成字符形式IP地址
  715.             #print("找到空缺可用IP地址", 可用_IP_STR)
  716.             Log.debug('找到空缺可用IP地址：' + 可用_IP_STR)
  717.             break                                                     ## 找到了就终止循环
  718.     ## 判断捡漏查找结果
  719.     if 可用_IP_STR == '':
  720.         ERROR = '无可用地址：网段可自动分配区间地址已经全部被使用，可以尝试扩大网段或减少保留地址数量'
  721.         return(1, ERROR)
  722.     else:
  723.         return(0, 可用_IP_STR)
  724. ###############################################################################################################################
  725.  
  726.  
  727.  
  728.  
  729.  
  730. '''
  731. ########################
  732. ## 任务函数，完成任务 ##
  733. ########################
  734. '''
  735.  
  736. ####################################################################################################
  737. ## 任务函数：保存配置()
  738. ####################################################################################################
  739.  
  740. ## 任务控制部分（负责检查参数，控制SSH连接的打开和关闭，调用相应交互操作命令执行任务）
  741. def 保存配置(D_LOGIN_INFO):
  742.     测试结果,结果说明 = TEST_D_LOGIN_INFO(D_LOGIN_INFO)
  743.     if 测试结果 == 0:
  744.         R = SSH_LOGIN(D_LOGIN_INFO)                 # 尝试登录SSH设备
  745.         if R[0] == 0:                               # 登录成功
  746.             SSH = R[1]                              # 获取SSH连接对象
  747.             SHELL = R[2]                            # 获取可交互操作的子SHELL对象
  748.             RR = SHELL_SAVE(SSH, SHELL)             # 调用相应交互操作命令执行任务
  749.             SSH.close()                             # 任务完成后断开SSH连接
  750.             return(RR)                              # 把任务执行结果返回给上级函数
  751.         else:
  752.             return(1, R[1])                         # 返回失败代码和错误信息                     
  753.     else:
  754.         return(1, 结果说明)
  755.  
  756. ## 任务实现部分（执行交互操作命令，根据回显结果进行处理，返回处理状态和处理结果，DEBUG日志）
  757. def SHELL_SAVE(SSH, SHELL):
  758.     ## 判断当前是否是<>模式
  759.     CMD = 'display clock'                                              # 任意命令，拿到回显最后一行，判断是 <> 还是 []
  760.     S_DATA = SHELL_CMD(SHELL, CMD, 0.5)
  761.     Log.debug('函数 SHELL_SAVE() 的 display clock 命令回显：' + S_DATA)
  762.     code,data = 返回查看模式(S_DATA, SHELL, 最大深度=5)                # 调用 返回查看模式() 这个交换机需要在查看模式才能保存配置
  763.     if code == 0:
  764.         Log.debug(data + '开始执行 save 命令')
  765.         CMD = 'save'
  766.         S_DATA = SHELL_CMD(SHELL, CMD, 0.5)
  767.         Log.debug('函数 ' + sys._getframe().f_code.co_name + ' 的 ' + CMD + ' 命令回显：' + S_DATA)
  768.         正则表达式 = '(.*)Are you sure to continue(.*)'
  769.         RE_S = re.search(正则表达式, S_DATA)
  770.         if RE_S:
  771.             CMD = 'y'
  772.             S_DATA = SHELL_CMD(SHELL, CMD, 2)
  773.             Log.debug('函数 ' + sys._getframe().f_code.co_name + ' 的 ' + CMD + ' 命令回显：' + S_DATA)
  774.             ## 如果遇到保存名字，直接回车
  775.             正则表达式 = '(.*)Please input the file name(.*)'
  776.             RE_S = re.search(正则表达式, S_DATA)
  777.             if RE_S:
  778.                 CMD = ''    ## 无命令，会直接输入回车
  779.                 S_DATA = SHELL_CMD(SHELL, CMD, 2)
  780.                 Log.debug('函数 ' + sys._getframe().f_code.co_name + ' 的 ' + CMD + ' 命令回显：' + S_DATA)
  781.             ## 查看是否出现保存成功的字样，部分机器慢，需要设置一个长一点的等待时间
  782.             保存成功字符串 = re.search('(.*)successfully(.*)', S_DATA)     # 检查回显中是否有成功字样出现
  783.             if 保存成功字符串:
  784.                 INFO = '保存成功'
  785.                 return(0, INFO)
  786.             else:
  787.                 ERROR = '未发现successfully字符，可能保存时间过久，命令暂停时间不够，请开启日志DEBUG模式查看操作过程'
  788.                 return(1, ERROR)
  789.         else:
  790.             ERROR = '回显内容中没有匹配到' + 正则表达式
  791.             return(1, ERROR)
  792.     else:
  793.         ERROR = '返回<查看模式失败>失败信息：' + data
  794.         return(1, ERROR)
  795. ####################################################################################################
  796.  
  797.  
  798.  
  799. ####################################################################################################
  800. ## 任务函数：获取IP和MAC绑定信息()
  801. ####################################################################################################
  802.  
  803. ## 任务控制部分（负责检查参数，控制SSH连接的打开和关闭，调用相应交互操作命令执行任务）
  804. def 获取IP和MAC绑定信息(D_LOGIN_INFO):
  805.     测试结果,结果说明 = TEST_D_LOGIN_INFO(D_LOGIN_INFO)
  806.     if 测试结果 == 0:
  807.         R = SSH_LOGIN(D_LOGIN_INFO)
  808.         if R[0] == 0:
  809.             SSH = R[1]
  810.             SHELL = R[2]
  811.             RR = SHELL_D_IP_MAC(SSH, SHELL)
  812.             SSH.close()
  813.             return(RR)
  814.         else:
  815.             return(1, R[1])
  816.     else:
  817.         return(1, 结果说明)
  818.  
  819. ## 任务实现部分（执行交互操作命令，根据回显结果进行处理，返回处理状态和处理结果，DEBUG日志）
  820. def SHELL_D_IP_MAC(SSH, SHELL):
  821.     CMD = 'screen-length 0 temporary'
  822.     S_DATA = SHELL_CMD(SHELL, CMD, 0.3)
  823.     CMD = 'dis cu | include user-bind static'           # 准备设备执行交互命令：查看IP和MAC绑定信息
  824.     S_DATA = SHELL_CMD(SHELL, CMD, 2)
  825.     Log.debug('函数 ' + sys._getframe().f_code.co_name + ' 的 ' + CMD + ' 命令回显：' + S_DATA)     ## DEBUG
  826.     D_IP_MAC = IP_MAC_绑定信息转成IP为KEY字典(S_DATA)   # 调用功能函数处理回显内容
  827.     return(0,D_IP_MAC)                                  # 返回成功代码和处理结果
  828. ####################################################################################################
  829.  
  830.  
  831.  
  832. ####################################################################################################
  833. ## 任务函数：绑定指定IP和指定MAC()
  834. ####################################################################################################
  835.  
  836. ## 任务控制部分（负责检查参数，控制SSH连接的打开和关闭，调用相应交互操作命令执行任务）
  837. def 绑定指定IP和指定MAC(D_LOGIN_INFO, Bind_IP, Bind_MAC):
  838.     ## 检查参数IP地址是否合法
  839.     IP_TEST = TEST_IP_STR(Bind_IP)
  840.     if IP_TEST[0] != 0:
  841.         return(IP_TEST)             # 不合法立即终止
  842.     ## 检查参数MAC地址是否合法
  843.     R_TRY = TRY_MAC_2_MAC(Bind_MAC, 转换格式='xxxx-xxxx-xxxx')
  844.     if R_TRY[0] != 0:
  845.         return(R_TRY)            # 不合法立即终止
  846.     else:
  847.         Bind_MAC = R_TRY[1]      # 不管用户输入什么格式，都转成'xxxx-xxxx-xxxx'格式
  848.  
  849.     测试结果,结果说明 = TEST_D_LOGIN_INFO(D_LOGIN_INFO)
  850.     if 测试结果 == 0:
  851.         R = SSH_LOGIN(D_LOGIN_INFO)
  852.         if R[0] == 0:
  853.             SSH = R[1]
  854.             SHELL = R[2]
  855.             RR = SHELL_Bind_IP_MAC(SSH, SHELL, Bind_IP, Bind_MAC)
  856.             SSH.close()
  857.             return(RR)
  858.         else:
  859.             return(1, R[1])
  860.     else:
  861.         return(1, 结果说明)
  862.  
  863. ## 任务实现部分（执行交互操作命令，根据回显结果进行处理，返回处理状态和处理结果，DEBUG日志）
  864. def SHELL_Bind_IP_MAC(SSH, SHELL, Bind_IP, Bind_MAC):
  865.     ## 开始按顺序执行交互命令
  866.     CMD = 'screen-length 0 temporary'
  867.     S_DATA = SHELL_CMD(SHELL, CMD, 0.5)
  868.     CMD = 'sys'                                                                                     # 准备设备执行交互命令：进入配置模式
  869.     S_DATA = SHELL_CMD(SHELL, CMD, 0.5)
  870.     CMD = 'user-bind static ip-address ' + Bind_IP + ' mac-address ' + Bind_MAC                     # 准备设备执行交互命令：绑定IP和MAC
  871.     S_DATA = SHELL_CMD(SHELL, CMD, 0.5)
  872.     Log.debug('函数 ' + sys._getframe().f_code.co_name + ' 的 ' + CMD + ' 命令回显：' + S_DATA)     ## DEBUG
  873.     ## 判断此次绑定任务是否成功
  874.     CMD = 'dis cu | include user-bind static ip-address ' + Bind_IP                                 # 准备设备执行交互命令：检查是否成功绑定
  875.     S_DATA = SHELL_CMD(SHELL, CMD, 1)
  876.     Log.debug('函数 ' + sys._getframe().f_code.co_name + ' 的 ' + CMD + ' 命令回显：' + S_DATA)     ## DEBUG
  877.     D_IP_MAC = IP_MAC_绑定信息转成IP为KEY字典(S_DATA)
  878.     RR = 判断是否绑定成功(D_IP_MAC, Bind_IP, Bind_MAC)
  879.     return(RR)
  880. ####################################################################################################
  881.  
  882.  
  883.  
  884. ####################################################################################################
  885. ## 任务函数：在指定网段自动选择可用IP和指定MAC绑定()
  886. ####################################################################################################
  887.  
  888. ## 任务控制部分（负责检查参数，控制SSH连接的打开和关闭，调用相应交互操作命令执行任务）
  889. def 在指定网段自动选择可用IP和指定MAC绑定(D_LOGIN_INFO, Bind_NET, Bind_MAC):
  890.     ## 检查参数，尝试把字符串表示的网段转成网段IP_STR和掩码MASK_INT
  891.     R_TRY_NET = TRY_NET_STR_2_IP_MASK(Bind_NET)
  892.     if R_TRY_NET[0] != 0:
  893.         return(1, R_TRY_NET[1])
  894.     else:
  895.         Bind_NET_IP_STR = R_TRY_NET[1][0]
  896.         Bind_NET_MASK_INT = R_TRY_NET[1][1]
  897.     ## 检查参数，尝试把用户输入的MAC地址转成交换机常用MAC格式
  898.     R_TRY_MAC = TRY_MAC_2_MAC(Bind_MAC, 转换格式='xxxx-xxxx-xxxx')
  899.     if R_TRY_MAC[0] != 0:
  900.         return(1, R_TRY_MAC[1])
  901.     else:
  902.         Bind_MAC = R_TRY_MAC[1]
  903.     
  904.     测试结果,结果说明 = TEST_D_LOGIN_INFO(D_LOGIN_INFO)
  905.     if 测试结果 == 0:
  906.         R = SSH_LOGIN(D_LOGIN_INFO)
  907.         if R[0] == 0:
  908.             SSH = R[1]
  909.             SHELL = R[2]
  910.             RR = SHELL_Bind_NET_MAC(SSH, SHELL, Bind_NET_IP_STR, Bind_NET_MASK_INT, Bind_MAC)
  911.             SSH.close()
  912.             return(RR)
  913.         else:
  914.             return(1, R[1])
  915.     else:
  916.         return(1, 结果说明)
  917.  
  918. ## 任务实现部分（执行交互操作命令，根据回显结果进行处理，返回处理状态和处理结果，DEBUG日志）
  919. def SHELL_Bind_NET_MAC(SSH, SHELL, Bind_NET_IP_STR, Bind_NET_MASK_INT, Bind_MAC):
  920.     ## 开始按顺序执行交互命令
  921.     CMD = 'screen-length 0 temporary'
  922.     S_DATA = SHELL_CMD(SHELL, CMD, 0.5)
  923.     CMD = 'sys'
  924.     S_DATA = SHELL_CMD(SHELL, CMD, 0.5)
  925.     Log.debug('函数 ' + sys._getframe().f_code.co_name + ' 的 ' + CMD + ' 命令回显：' + S_DATA)     ## DEBUG
  926.     CMD = 'dis cu | include user-bind static'
  927.     S_DATA = SHELL_CMD(SHELL, CMD, 2)
  928.     Log.debug('函数 ' + sys._getframe().f_code.co_name + ' 的 ' + CMD + ' 命令回显：' + S_DATA)     ## DEBUG
  929.     状态_搜索可用IP, 结果_搜索可用IP = 自动查找网段中可用IP_优先自增(Bind_NET_IP_STR, Bind_NET_MASK_INT, S_DATA)
  930.     if 状态_搜索可用IP == 0:
  931.         Bind_IP = 结果_搜索可用IP
  932.         RR = SHELL_Bind_IP_MAC(SSH, SHELL, Bind_IP, Bind_MAC)
  933.         return(RR)
  934.     else:
  935.         return(1, 结果_搜索可用IP)
  936. ####################################################################################################
  937.  
  938.  
  939.  
  940. ####################################################################################################
  941. ## 任务函数：查找MAC地址所在网段()
  942. ####################################################################################################
  943.  
  944. ## 任务控制部分（负责检查参数，控制SSH连接的打开和关闭，调用相应交互操作命令执行任务）
  945. def 查找MAC地址所在网段(D_LOGIN_INFO, MAC):
  946.     R_TRY_MAC = TRY_MAC_2_MAC(MAC, 转换格式='xxxx-xxxx-xxxx')
  947.     if R_TRY_MAC[0] != 0:
  948.         return(1, R_TRY_MAC[1])
  949.     else:
  950.         MAC = R_TRY_MAC[1]
  951.     
  952.     测试结果,结果说明 = TEST_D_LOGIN_INFO(D_LOGIN_INFO)
  953.     if 测试结果 == 0:
  954.         R = SSH_LOGIN(D_LOGIN_INFO)
  955.         if R[0] == 0:
  956.             SSH = R[1]
  957.             SHELL = R[2]
  958.             RR = SHELL_MAC_IN_VLAN(SSH, SHELL, MAC)
  959.             SSH.close()
  960.             return(RR)
  961.         else:
  962.             return(1, R[1])
  963.     else:
  964.         return(1, 结果说明)
  965.  
  966. ## 任务实现部分（执行交互操作命令，根据回显结果进行处理，返回处理状态和处理结果，DEBUG日志）
  967. def SHELL_MAC_IN_VLAN(SSH, SHELL, MAC):
  968.     CMD = 'display mac-address ' + MAC
  969.     S_DATA = SHELL_CMD(SHELL, CMD, 1)
  970.     Log.debug('函数 ' + sys._getframe().f_code.co_name + ' 的 ' + CMD + ' 命令回显：' + S_DATA)     ## DEBUG
  971.     D_MAC_VLAN = MAC缓存信息转成MAC对应VLAN字典(S_DATA)
  972.     if MAC in D_MAC_VLAN:
  973.         列表_VLAN = D_MAC_VLAN[MAC]
  974.         if len(列表_VLAN) == 1:
  975.             VLAN_ID_STR = 列表_VLAN[0]
  976.             return(0, VLAN_ID_STR)
  977.         else:
  978.             E = 'MAC地址 ' + str(MAC) + ' 在VLAN ' + str(列表_VLAN) + ' 间漂移，当前无法确定VLAN号'
  979.             return(1, E)
  980.     else:
  981.         E = '在MAC地址缓存中没有找到 ' + str(MAC)
  982.         return(1, E)
  983. ####################################################################################################
  984.  
  985.  
  986.  
  987. ####################################################################################################
  988. ## 任务函数：在MAC所在网段自动选择可用IP和进行绑定()
  989. ####################################################################################################
  990.  
  991. ## 任务控制部分（负责检查参数，控制SSH连接的打开和关闭，调用相应交互操作命令执行任务）
  992. def 在MAC所在网段自动选择可用IP和进行绑定(D_LOGIN_INFO, Bind_MAC):
  993.     R_TRY_MAC = TRY_MAC_2_MAC(Bind_MAC, 转换格式='xxxx-xxxx-xxxx')
  994.     if R_TRY_MAC[0] != 0:
  995.         return(1, R_TRY_MAC[1])
  996.     else:
  997.         Bind_MAC = R_TRY_MAC[1]
  998.     
  999.     测试结果,结果说明 = TEST_D_LOGIN_INFO(D_LOGIN_INFO)
  1000.     if 测试结果 == 0:
  1001.         R = SSH_LOGIN(D_LOGIN_INFO)
  1002.         if R[0] == 0:
  1003.             SSH = R[1]
  1004.             SHELL = R[2]
  1005.             RR = SHELL_AUTO_Bind_MAC(SSH, SHELL, Bind_MAC)
  1006.             SSH.close()
  1007.             return(RR)
  1008.         else:
  1009.             return(1, R[1])
  1010.     else:
  1011.         return(1, 结果说明)
  1012.  
  1013. ## 任务实现部分（执行交互操作命令，根据回显结果进行处理，返回处理状态和处理结果，DEBUG日志）
  1014. def SHELL_AUTO_Bind_MAC(SSH, SHELL, Bind_MAC):
  1015.     CMD = 'screen-length 0 temporary'
  1016.     S_DATA = SHELL_CMD(SHELL, CMD, 0.3)
  1017.  
  1018.     CMD = 'display ip interface brief'              # 交换机命令：查看VLAN的接口IP
  1019.     S_DATA = SHELL_CMD(SHELL, CMD, 1)
  1020.     Log.debug('函数 ' + sys._getframe().f_code.co_name + ' 的 ' + CMD + ' 命令回显：' + S_DATA)     ## DEBUG
  1021.     D_VLAN_IP_MASK = VLAN和NET字典(S_DATA)
  1022.     if D_VLAN_IP_MASK == {}:
  1023.         E = '查不到任何VLAN的接口IP'
  1024.         return(1,E)
  1025.  
  1026.     CMD = 'display mac-address ' + Bind_MAC         # 交换机命令：查找MAC的网络信息
  1027.     S_DATA = SHELL_CMD(SHELL, CMD, 1)
  1028.     Log.debug('函数 ' + sys._getframe().f_code.co_name + ' 的 ' + CMD + ' 命令回显：' + S_DATA)     ## DEBUG
  1029.     D_MAC_VLAN = MAC缓存信息转成MAC对应VLAN字典(S_DATA)
  1030.     if Bind_MAC in D_MAC_VLAN:
  1031.         #print(Bind_MAC, "VLAN缓存记录", D_MAC_VLAN[Bind_MAC])
  1032.         列表_VLAN = D_MAC_VLAN[Bind_MAC]
  1033.         if len(列表_VLAN) == 1:
  1034.             #print("查VLAN网段")
  1035.             S_VLAN_ID = 'Vlanif' + 列表_VLAN[0]
  1036.             if S_VLAN_ID in D_VLAN_IP_MASK:
  1037.                 Bind_NET = D_VLAN_IP_MASK[S_VLAN_ID][0]    # 例 ['192.168.0.1/24'] 取出 '192.168.0.1/24'
  1038.                 Bind_NET_SP = Bind_NET.split('/')
  1039.                 Bind_NET_IP_STR = Bind_NET_SP[0]
  1040.                 Bind_NET_MASK_INT = int(Bind_NET_SP[1])
  1041.                 RR = SHELL_Bind_NET_MAC(SSH, SHELL, Bind_NET_IP_STR, Bind_NET_MASK_INT, Bind_MAC)
  1042.                 return(RR)
  1043.             else:
  1044.                 E = 'VLAN ' + S_VLAN_ID + ' 没有接口IP地址'
  1045.                 return(1,E)
  1046.         else:
  1047.             E = 'MAC地址 ' + str(Bind_MAC) + ' 在VLAN' + str(列表_VLAN) + '间漂移，当前无法确定VLAN号'
  1048.             return(1,E)
  1049.     else:
  1050.         E = '在MAC地址缓存中没有找到 ' + str(MAC)
  1051.         return(1,E)
  1052. ####################################################################################################
  1053.  
  1054.  
  1055.  
  1056. ####################################################################################################
  1057. ## 任务函数：解除指定IP和指定MAC的绑定()
  1058. ####################################################################################################
  1059.  
  1060. ## 任务控制部分（负责检查参数，控制SSH连接的打开和关闭，调用相应交互操作命令执行任务）
  1061. def 解除指定IP和指定MAC的绑定(D_LOGIN_INFO, Undo_Bind_IP, Undo_Bind_MAC):
  1062.     ## 检查参数IP地址是否合法
  1063.     IP_TEST = TEST_IP_STR(Undo_Bind_IP)
  1064.     if IP_TEST[0] != 0:
  1065.         return(IP_TEST)             # 不合法立即终止
  1066.     ## 检查参数MAC地址是否合法
  1067.     R_TRY = TRY_MAC_2_MAC(Undo_Bind_MAC, 转换格式='xxxx-xxxx-xxxx')
  1068.     if R_TRY[0] != 0:
  1069.         return(R_TRY)               # 不合法立即终止
  1070.     else:
  1071.         Undo_Bind_MAC = R_TRY[1]    # 不管用户输入什么格式，都转成'xxxx-xxxx-xxxx'格式
  1072.  
  1073.     测试结果,结果说明 = TEST_D_LOGIN_INFO(D_LOGIN_INFO)
  1074.     if 测试结果 == 0:
  1075.         R = SSH_LOGIN(D_LOGIN_INFO)
  1076.         if R[0] == 0:
  1077.             SSH = R[1]
  1078.             SHELL = R[2]
  1079.             RR = SHELL_UNDO_Bind_IP_MAC(SSH, SHELL, Undo_Bind_IP, Undo_Bind_MAC)
  1080.             SSH.close()
  1081.             return(RR)
  1082.         else:
  1083.             return(1, R[1])
  1084.     else:
  1085.         return(1, 结果说明)
  1086.  
  1087. ## 任务实现部分（执行交互操作命令，根据回显结果进行处理，返回处理状态和处理结果，DEBUG日志）
  1088. def SHELL_UNDO_Bind_IP_MAC(SSH, SHELL, Undo_Bind_IP, Undo_Bind_MAC):
  1089.     CMD = 'sys'
  1090.     S_DATA = SHELL_CMD(SHELL, CMD, 0.5)
  1091.     CMD = 'dis cu | include user-bind static ip-address ' + Undo_Bind_IP
  1092.     S_DATA = SHELL_CMD(SHELL, CMD, 1)
  1093.     Log.debug('函数 ' + sys._getframe().f_code.co_name + ' 的 ' + CMD + ' 命令回显：' + S_DATA)     ## DEBUG
  1094.     D_IP_MAC = IP_MAC_绑定信息转成IP为KEY字典(S_DATA)
  1095.     if Undo_Bind_IP in D_IP_MAC:
  1096.         if Undo_Bind_MAC in D_IP_MAC[Undo_Bind_IP]:
  1097.             CMD = 'undo user-bind static ip-address ' + Undo_Bind_IP + ' mac-address ' + Undo_Bind_MAC
  1098.             S_DATA = SHELL_CMD(SHELL, CMD, 1)
  1099.             Log.debug('函数 ' + sys._getframe().f_code.co_name + ' 的 ' + CMD + ' 命令回显：' + S_DATA)     ## DEBUG
  1100.             CMD = 'dis cu | include user-bind static ip-address ' + Undo_Bind_IP
  1101.             S_DATA = SHELL_CMD(SHELL, CMD, 1)
  1102.             Log.debug('函数 ' + sys._getframe().f_code.co_name + ' 的 ' + CMD + ' 命令回显：' + S_DATA)     ## DEBUG
  1103.             D_IP_MAC_复查 = IP_MAC_绑定信息转成IP为KEY字典(S_DATA)
  1104.             if Undo_Bind_IP in D_IP_MAC_复查:
  1105.                 if Undo_Bind_MAC in D_IP_MAC_复查[Undo_Bind_IP]:
  1106.                     ERROR = 'ERROR IP ' + Undo_Bind_IP + ' 和 ' + Undo_Bind_MAC + ' 解绑失败'
  1107.                     return(1,ERROR)
  1108.                 else:
  1109.                     INFO = 'INFO IP ' + Undo_Bind_IP + ' 和 ' + Undo_Bind_MAC + ' 解绑成功，剩余MAC绑定 ' + str(D_IP_MAC_复查[Undo_Bind_IP])
  1110.                     return(0,INFO)
  1111.             else:
  1112.                 INFO = 'INFO IP ' + Undo_Bind_IP + ' 解绑成功，且已无MAC绑定记录'
  1113.                 return(0,INFO)
  1114.         else:
  1115.             WARNING = 'WARNING IP ' + Undo_Bind_IP + ' 原先就没有和 ' + Undo_Bind_MAC + '的绑定记录'
  1116.             return(0,WARNING)
  1117.     else:
  1118.         WARNING = 'WARNING IP ' + Undo_Bind_IP + ' 原先就无MAC绑定记录'
  1119.         return(0,WARNING)
  1120. ####################################################################################################
  1121.  
  1122.  
  1123.  
  1124. ####################################################################################################
  1125. ## 任务函数：解除指定IP的全部MAC绑定()
  1126. ####################################################################################################
  1127.  
  1128. ## 任务控制部分（负责打开和关闭SSH连接，调用相应交互操作命令）
  1129. def 解除指定IP的全部MAC绑定(D_LOGIN_INFO, Undo_Bind_IP):
  1130.     ## 检查参数IP地址是否合法
  1131.     IP_TEST = TEST_IP_STR(Undo_Bind_IP)
  1132.     if IP_TEST[0] != 0:
  1133.         return(IP_TEST)             # 不合法立即终止
  1134.  
  1135.     测试结果,结果说明 = TEST_D_LOGIN_INFO(D_LOGIN_INFO)
  1136.     if 测试结果 == 0:
  1137.         R = SSH_LOGIN(D_LOGIN_INFO)
  1138.         if R[0] == 0:
  1139.             SSH = R[1]
  1140.             SHELL = R[2]
  1141.             RR = SHELL_UNDO_Bind_IP(SSH, SHELL, Undo_Bind_IP)
  1142.             SSH.close()
  1143.             return(RR)
  1144.         else:
  1145.             return(1, R[1])
  1146.     else:
  1147.         return(1, 结果说明)
  1148.  
  1149. ## 任务实现部分（执行交互操作命令，根据回显结果进行处理，返回处理状态和处理结果）
  1150. def SHELL_UNDO_Bind_IP(SSH, SHELL, Undo_Bind_IP):
  1151.     CMD = 'screen-length 0 temporary'
  1152.     S_DATA = SHELL_CMD(SHELL, CMD, 0.5)
  1153.     CMD = 'sys'
  1154.     S_DATA = SHELL_CMD(SHELL, CMD, 0.5)
  1155.     CMD = 'dis cu | include user-bind static ip-address ' + Undo_Bind_IP
  1156.     S_DATA = SHELL_CMD(SHELL, CMD, 1)
  1157.     Log.debug('函数 ' + sys._getframe().f_code.co_name + ' 的 ' + CMD + ' 命令回显：' + S_DATA)     ## DEBUG
  1158.     D_IP_MAC = IP_MAC_绑定信息转成IP为KEY字典(S_DATA)
  1159.     if Undo_Bind_IP in D_IP_MAC:
  1160.         for MAC in D_IP_MAC[Undo_Bind_IP]:
  1161.             CMD = 'undo user-bind static ip-address ' + Undo_Bind_IP + ' mac-address ' + MAC
  1162.             S_DATA = SHELL_CMD(SHELL, CMD, 1)
  1163.         ## 复查删除结果
  1164.         CMD = 'dis cu | include user-bind static ip-address ' + Undo_Bind_IP
  1165.         S_DATA = SHELL_CMD(SHELL, CMD, 1)
  1166.         Log.debug('函数 ' + sys._getframe().f_code.co_name + ' 的 ' + CMD + ' 命令回显：' + S_DATA)     ## DEBUG
  1167.         D_IP_MAC_复查 = IP_MAC_绑定信息转成IP为KEY字典(S_DATA)
  1168.         if Undo_Bind_IP in D_IP_MAC_复查:
  1169.             ERROR = 'ERROR IP ' + Undo_Bind_IP + ' 解绑全部MAC失败，剩余MAC绑定 ' + str(D_IP_MAC_复查[Undo_Bind_IP])
  1170.             return(1,ERROR)
  1171.         else:
  1172.             INFO = 'INFO IP ' + Undo_Bind_IP + ' 解绑全部MAC成功，已解除绑定的MAC列表 ' + str(D_IP_MAC[Undo_Bind_IP])
  1173.             return(0,INFO)
  1174.     else:
  1175.         WARNING = 'WARNING IP ' + Undo_Bind_IP + ' 原先就无MAC绑定记录'
  1176.         return(0,WARNING)
  1177. ####################################################################################################
  1178.  
  1179.  
  1180.  
  1181. ####################################################################################################
  1182. ## 任务函数：解除指定MAC的全部IP绑定()
  1183. ####################################################################################################
  1184.  
  1185. ## 任务控制部分（负责打开和关闭SSH连接，调用相应交互操作命令）
  1186. def 解除指定MAC的全部IP绑定(D_LOGIN_INFO, Undo_Bind_MAC):
  1187.     ## 检查参数MAC地址是否合法
  1188.     R_TRY = TRY_MAC_2_MAC(Undo_Bind_MAC, 转换格式='xxxx-xxxx-xxxx')
  1189.     if R_TRY[0] != 0:
  1190.         return(R_TRY)               # 不合法立即终止
  1191.     else:
  1192.         Undo_Bind_MAC = R_TRY[1]    # 不管用户输入什么格式，都转成'xxxx-xxxx-xxxx'格式
  1193.         
  1194.     测试结果,结果说明 = TEST_D_LOGIN_INFO(D_LOGIN_INFO)
  1195.     if 测试结果 == 0:
  1196.         R = SSH_LOGIN(D_LOGIN_INFO)
  1197.         if R[0] == 0:
  1198.             SSH = R[1]
  1199.             SHELL = R[2]
  1200.             code,data = SHELL_UNDO_Bind_MAC(SSH, SHELL, Undo_Bind_MAC)
  1201.             SSH.close()
  1202.             return(code,data)
  1203.         else:
  1204.             return(1, R[1])
  1205.     else:
  1206.         return(1, 结果说明)
  1207.  
  1208. ## 任务实现部分（执行交互操作命令，根据回显结果进行处理，返回处理状态和处理结果）
  1209. def SHELL_UNDO_Bind_MAC(SSH, SHELL, Undo_Bind_MAC):
  1210.     CMD = 'screen-length 0 temporary'
  1211.     S_DATA = SHELL_CMD(SHELL, CMD, 0.5)
  1212.     CMD = 'sys'
  1213.     S_DATA = SHELL_CMD(SHELL, CMD, 0.5)
  1214.     CMD = 'dis cu | include user-bind static'
  1215.     S_DATA = SHELL_CMD(SHELL, CMD, 1)
  1216.     Log.debug('函数 ' + sys._getframe().f_code.co_name + ' 的 ' + CMD + ' 命令回显：' + S_DATA)     ## DEBUG
  1217.     D_MAC_IP = IP_MAC_绑定信息转成MAC为KEY字典(S_DATA)
  1218.     if Undo_Bind_MAC in D_MAC_IP:
  1219.         for IP in D_MAC_IP[Undo_Bind_MAC]:
  1220.             CMD = 'undo user-bind static ip-address ' + IP + ' mac-address ' + Undo_Bind_MAC
  1221.             S_DATA = SHELL_CMD(SHELL, CMD, 1)
  1222.             Log.debug('函数 ' + sys._getframe().f_code.co_name + ' 的 ' + CMD + ' 命令回显：' + S_DATA)     ## DEBUG
  1223.         ## 复查删除结果
  1224.         CMD = 'dis cu | include user-bind static'
  1225.         S_DATA = SHELL_CMD(SHELL, CMD, 1)
  1226.         Log.debug('函数 ' + sys._getframe().f_code.co_name + ' 的 ' + CMD + ' 命令回显：' + S_DATA)     ## DEBUG
  1227.         D_MAC_IP_复查 = IP_MAC_绑定信息转成MAC为KEY字典(S_DATA)
  1228.         if Undo_Bind_MAC in D_MAC_IP_复查:
  1229.             ERROR = 'ERROR MAC ' + Undo_Bind_MAC + ' 解绑全部IP失败，剩余IP绑定 ' + str(D_MAC_IP_复查[Undo_Bind_MAC])
  1230.             return(1,ERROR)
  1231.         else:
  1232.             INFO = 'INFO MAC ' + Undo_Bind_MAC + ' 解绑全部IP成功，已解除绑定的IP列表 ' + str(D_MAC_IP[Undo_Bind_MAC])
  1233.             return(0,INFO)
  1234.     else:
  1235.         WARNING = 'WARNING MAC ' + Undo_Bind_MAC + ' 原先就无IP绑定记录'
  1236.         return(0,WARNING)
  1237. ####################################################################################################

 

 

文件三代码：

  1. #_*_ coding:utf8 _*_
  2. from DEV_SNMP import *      # 导入编写在另一个文件里的SNMP操作函数
  3. import sys                  # 本例中用于获取函数名写入日志文件
  4. import logging              # 日志模块
  5. Log = logging.getLogger("__name__")
  6. ## 如果日志实例不存在，就使用本程序日志模块
  7. if not logging.FileHandler:
  8.     formatter = logging.Formatter('%(asctime)s %(levelname)-8s : %(message)s')  # 指定logger输出格式
  9.     file_handler = logging.FileHandler("DEF_SNMP_eNSP_Switch_S5700.log")        # 日志文件路径
  10.     file_handler.setFormatter(formatter)                                        # 可以通过setFormatter指定输出格式
  11.     Log.addHandler(file_handler)
  12.     Log.setLevel(logging.DEBUG)
  13.  
  14.  
  15. ## 函数调用关系
  16. '''
  17. DEF_SNMP_eNSP_Switch_S5700.py
  18.     from DEV_SNMP import *      # 需要导入编写DEV_SNMP.py文件里的SNMP操作函数
  19.     import sys                  # 本文件中只用于获取函数名方便生成日志内容
  20.     import logging              # 日志模块
  21.     SNMP_MAC_2_mac(SNMP_MAC)                                               ## SNMP获取的MAC地址是 '00 00 00 00 00 00' 形式，需要转成 '0000-0000-0000' 形式
  22.     SNMP_L_Bind_IP_STR(SNMP_PWD, SNMP_HOST)                                ## 获取静态绑定IP列表
  23.     SNMP_L_Bind_MAC_STR(SNMP_PWD, SNMP_HOST)                               ## 获取静态绑定MAC列表
  24.     SNMP_L_IF_IP_STR(SNMP_PWD, SNMP_HOST)                                  ## 获取设备接口IP列表（VLAN接口、物理端口、特殊接口）
  25.     SNMP_L_IF_MASK_STR(SNMP_PWD, SNMP_HOST)                                ## 获取设备接口IP的掩码列表（VLAN接口、物理端口、特殊接口）
  26.     SNMP_L_IF_INDEX_STR(SNMP_PWD, SNMP_HOST)                               ## 获取设备接口编号（VLAN接口、物理端口、特殊接口）
  27.     SNMP_D_IF_DESCR(SNMP_PWD, SNMP_HOST)                                   ## 获取设备接口名称字典（VLAN接口、物理端口、特殊接口）## {'1':InLoopBack0, '2':'NULL0', '3':'Console9/0/0', '4':'MEth0/0/1', '5':'Vlanif1', '6':'GigabitEthernet0/0/1'}
  28.     SNMP_生成以IP为键以MAC地址列表为值的字典(SNMP_PWD, SNMP_HOST)          ## 以IP为键以MAC地址列表为值的字典 {IP_STR:[MAC_STR, MAC_STR]}
  29.         SNMP_L_Bind_IP_STR(SNMP_PWD, SNMP_HOST)
  30.         SNMP_L_Bind_MAC_STR(SNMP_PWD, SNMP_HOST)
  31.             SNMP_MAC_2_mac(SNMP_MAC)
  32.     SNMP_生成以VLAN为键以VLAN_IP_MASK列表为值的字典(SNMP_PWD, SNMP_HOST)   ## D_VLAN_NET {VLAN_STR:[IP_STR/MASK_STR]}
  33.         SNMP_L_IF_IP_STR(SNMP_PWD, SNMP_HOST)   
  34.         SNMP_L_IF_MASK_STR(SNMP_PWD, SNMP_HOST) 
  35.         SNMP_L_IF_INDEX_STR(SNMP_PWD, SNMP_HOST)
  36.         SNMP_D_IF_DESCR(SNMP_PWD, SNMP_HOST)    
  37. '''
  38.  
  39.  
  40. ## 全局变量 交换机 S5700 要用到的 OID
  41. OID_BIND_IP = '1.3.6.1.4.1.2011.5.25.112.1.14.1.12'         # 静态绑定IP列表
  42. OID_BIND_MAC = '1.3.6.1.4.1.2011.5.25.112.1.14.1.11'        # 静态绑定MAC列表
  43. OID_IF_IP_STR = '1.3.6.1.4.1.2011.5.25.41.1.2.1.1.1'        # 设备接口IP列表（VLAN接口、物理端口、特殊接口）
  44. OID_IF_MASK_STR = '1.3.6.1.4.1.2011.5.25.41.1.2.1.1.3'      # 设备接口IP的掩码列表（VLAN接口、物理端口、特殊接口）
  45. OID_IF_INDEX = '1.3.6.1.4.1.2011.5.25.41.1.2.1.1.2'         # 设备接口编号（VLAN接口、物理端口、特殊接口）
  46. OID_IF_DESCR = 'IF-MIB::ifDescr'                            # 设备接口名称字典（VLAN接口、物理端口、特殊接口）
  47.  
  48.  
  49. ## SNMP获取的MAC地址是 '00 00 00 00 00 00' 形式，需要转成 '0000-0000-0000' 形式
  50. def SNMP_MAC_2_mac(SNMP_MAC):
  51.     MAC = SNMP_MAC.replace(' ', '')
  52.     mac = MAC.lower()
  53.     mac_new = mac[0:4] +'-'+ mac[4:8] +'-'+ mac[8:12]
  54.     return(mac_new)
  55.  
  56.  
  57. ## 获取静态绑定IP列表
  58. def SNMP_L_Bind_IP_STR(SNMP_PWD, SNMP_HOST):
  59.     SNMP_OID = OID_BIND_IP
  60.     (N, R) = SNMP_V2_R(SNMP_PWD, SNMP_HOST, SNMP_OID)
  61.     if N == 0:
  62.         if R.split(' = ')[-1] == 'No Such Object available on this agent at this OID':
  63.             ERROR = '错误 OID ' + SNMP_OID
  64.             return(1, ERROR)
  65.         elif R.split(' = ')[-1] == 'No Such Instance currently exists at this OID':
  66.             ## SNMP查询结果为空
  67.             return(0, [])
  68.         else:
  69.             R_SP = R.split('\n')
  70.             L_IP_STR = [i.split(': ')[-1] for i in R_SP]
  71.             return(0, L_IP_STR)
  72.     else:
  73.         ERROR = 'SNMP命令执行失败：' + str(R)
  74.         return(1, ERROR)
  75.  
  76.  
  77. ## 获取静态绑定MAC列表
  78. def SNMP_L_Bind_MAC_STR(SNMP_PWD, SNMP_HOST):
  79.     SNMP_OID = OID_BIND_MAC
  80.     (N, R) = SNMP_V2_R(SNMP_PWD, SNMP_HOST, SNMP_OID)
  81.     if N == 0:
  82.         if R.split(' = ')[-1] == 'No Such Object available on this agent at this OID':
  83.             ERROR = '错误 OID ' + SNMP_OID
  84.             return(1, ERROR)
  85.         elif R.split(' = ')[-1] == 'No Such Instance currently exists at this OID':
  86.             ## SNMP查询结果为空
  87.             return(0, [])
  88.         else:
  89.             R_SP = R.split('\n')
  90.             L_MAC_STR = [SNMP_MAC_2_mac(i.split(': ')[-1]) for i in R_SP]
  91.             return(0, L_MAC_STR)
  92.     else:
  93.         ERROR = 'SNMP命令执行失败：' + str(R)
  94.         return(1, ERROR)
  95.  
  96.  
  97. ## 获取设备接口IP列表（VLAN接口、物理端口、特殊接口）
  98. def SNMP_L_IF_IP_STR(SNMP_PWD, SNMP_HOST):
  99.     SNMP_OID = OID_IF_IP_STR
  100.     (N, R) = SNMP_V2_R(SNMP_PWD, SNMP_HOST, SNMP_OID)
  101.     if N == 0:
  102.         if R.split(' = ')[-1] == 'No Such Object available on this agent at this OID':
  103.             ERROR = '错误 OID ' + SNMP_OID
  104.             return(1, ERROR)
  105.         elif R.split(' = ')[-1] == 'No Such Instance currently exists at this OID':
  106.             ## SNMP查询结果为空
  107.             return(0, [])
  108.         else:
  109.             R_SP = R.split('\n')                            ## 先用'\n'(换行符)分出每一条记录
  110.             L_IP_STR = [i.split(': ')[-1] for i in R_SP]    ## 再用': '(冒号加一空)分段并提取需要的值(最后一段)
  111.             return(0, L_IP_STR)
  112.     else:
  113.         ERROR = 'SNMP命令执行失败：' + str(R)
  114.         return(1, ERROR)
  115.  
  116.  
  117. ## 获取设备接口IP的掩码列表（VLAN接口、物理端口、特殊接口）
  118. def SNMP_L_IF_MASK_STR(SNMP_PWD, SNMP_HOST):
  119.     SNMP_OID = OID_IF_MASK_STR
  120.     (N, R) = SNMP_V2_R(SNMP_PWD, SNMP_HOST, SNMP_OID)
  121.     if N == 0:
  122.         if R.split(' = ')[-1] == 'No Such Object available on this agent at this OID':
  123.             ERROR = '错误 OID ' + SNMP_OID
  124.             return(1, ERROR)
  125.         elif R.split(' = ')[-1] == 'No Such Instance currently exists at this OID':
  126.             ## SNMP查询结果为空
  127.             return(0, [])
  128.         else:
  129.             R_SP = R.split('\n')
  130.             L_IF_MASK_STR = [i.split(': ')[-1] for i in R_SP]
  131.             return(0, L_IF_MASK_STR)
  132.     else:
  133.         ERROR = 'SNMP命令执行失败：' + str(R)
  134.         return(1, ERROR)
  135.  
  136.  
  137. ## 获取设备接口编号（VLAN接口、物理端口、特殊接口）
  138. def SNMP_L_IF_INDEX_STR(SNMP_PWD, SNMP_HOST):
  139.     SNMP_OID = OID_IF_INDEX
  140.     (N, R) = SNMP_V2_R(SNMP_PWD, SNMP_HOST, SNMP_OID)
  141.     if N == 0:
  142.         if R.split(' = ')[-1] == 'No Such Object available on this agent at this OID':
  143.             ERROR = '错误 OID ' + SNMP_OID
  144.             return(1, ERROR)
  145.         elif R.split(' = ')[-1] == 'No Such Instance currently exists at this OID':
  146.             ## SNMP查询结果为空
  147.             return(0, [])
  148.         else:
  149.             R_SP = R.split('\n')
  150.             L_IF_VLAN_STR = [i.split(': ')[-1] for i in R_SP]
  151.             return(0, L_IF_VLAN_STR)
  152.     else:
  153.         ERROR = 'SNMP命令执行失败：' + str(R)
  154.         return(1, ERROR)
  155.  
  156.  
  157. ## 获取设备接口名称字典（VLAN接口、物理端口、特殊接口）
  158. ## {'1':InLoopBack0, '2':'NULL0', '3':'Console9/0/0', '4':'MEth0/0/1', '5':'Vlanif1', '6':'GigabitEthernet0/0/1'}
  159. def SNMP_D_IF_DESCR(SNMP_PWD, SNMP_HOST):
  160.     SNMP_OID = OID_IF_DESCR
  161.     (N, R) = SNMP_V2_R(SNMP_PWD, SNMP_HOST, SNMP_OID)
  162.     if N == 0:
  163.         if R.split(' = ')[-1] == 'No Such Object available on this agent at this OID':
  164.             ERROR = '错误 OID ' + SNMP_OID
  165.             return(1, ERROR)
  166.         elif R.split(' = ')[-1] == 'No Such Instance currently exists at this OID':
  167.             ## SNMP查询结果为空
  168.             return(0, {})
  169.         else:
  170.             D_IF_DESCR = {}
  171.             R_SP = R.split('\n')                            ## 先用'\n'(换行符)分出每一条记录
  172.             L_IF_DESCR = [i.split(': ')[-1] for i in R_SP]  ## 再用': '(冒号加一空)分段并提取需要的值(最后一段)
  173.             for i in range(0, len(L_IF_DESCR)):
  174.                 D_IF_DESCR[str(i+1)] = L_IF_DESCR[i]
  175.             return(0, D_IF_DESCR)
  176.     else:
  177.         ERROR = 'SNMP命令执行失败：' + str(R)
  178.         return(1, ERROR)
  179.  
  180.  
  181.  
  182. ## D_IP_MAC
  183. ## 以IP为键以MAC地址列表为值的字典
  184. ## {IP_STR:[MAC_STR, MAC_STR]}
  185. ## {'x.x.x.x':['xxxx-xxxx-xxxx', 'xxxx-xxxx-xxxx']}
  186. ## {'10.0.0.1':['0000-0000-000a', '0000-0000-000b']}
  187. def SNMP_生成以IP为键以MAC地址列表为值的字典(SNMP_PWD, SNMP_HOST):
  188.     (N_IP, R_IP) = SNMP_L_Bind_IP_STR(SNMP_PWD, SNMP_HOST)
  189.     (N_MAC, R_MAC) = SNMP_L_Bind_MAC_STR(SNMP_PWD, SNMP_HOST)
  190.     Log.debug('函数 ' + sys._getframe().f_code.co_name + ' 的 SNMP_L_Bind_IP_STR 调用结果：' + str(N_IP) + str(R_IP))
  191.     Log.debug('函数 ' + sys._getframe().f_code.co_name + ' 的 SNMP_L_Bind_MAC_STR 调用结果：' + str(N_MAC) + str(R_MAC))
  192.     if N_IP == 0:
  193.         if N_MAC == 0:
  194.             IP_List = R_IP
  195.             MAC_List = R_MAC
  196.             IP_List_Len = len(IP_List)
  197.             MAC_List_Len = len(MAC_List)
  198.             if IP_List_Len == MAC_List_Len:
  199.                 D_IP_MAC = {}
  200.                 for i in range(0, IP_List_Len):
  201.                     IP = IP_List[i]
  202.                     MAC = MAC_List[i]
  203.                     if IP not in D_IP_MAC:
  204.                         D_IP_MAC[IP] = [MAC]
  205.                     else:
  206.                         D_IP_MAC[IP].append(MAC)
  207.                 return(0, D_IP_MAC)
  208.             else:
  209.                 E = '绑定记录IP和MAC不能一一对应，len(IP_List) != len(MAC_List)'
  210.                 return(1, E)
  211.         else:
  212.             E = '获取IP成功，获取MAC失败：' + R_MAC
  213.             return(1, E)
  214.     else:
  215.         if N_MAC == 0:
  216.             E = '获取MAC成功，获取IP失败：' + R_IP
  217.             return(1, E)
  218.         else:
  219.             E = '获取IP失败：' + R_IP + ' 获取MAC失败：' + R_MAC
  220.             return(1, E)
  221.  
  222.  
  223.  
  224. ## D_VLAN_NET
  225. ## {VLAN_STR:[IP_STR/MASK_STR]}
  226. ## {'VlanifN':['x.x.x.x/x.x.x.x', 'x.x.x.x/x.x.x.x']}
  227. def SNMP_生成以VLAN为键以VLAN_IP_MASK列表为值的字典(SNMP_PWD, SNMP_HOST):
  228.     D_VLAN_NET = {}
  229.     (N_IP, R_IP) = SNMP_L_IF_IP_STR(SNMP_PWD, SNMP_HOST)
  230.     (N_MASK, R_MASK) = SNMP_L_IF_MASK_STR(SNMP_PWD, SNMP_HOST)
  231.     (N_INDEX, R_INDEX) = SNMP_L_IF_INDEX_STR(SNMP_PWD, SNMP_HOST)
  232.     (N_DESCR, R_DESCR) = SNMP_D_IF_DESCR(SNMP_PWD, SNMP_HOST)
  233.     Log.debug('函数 ' + sys._getframe().f_code.co_name + ' 的 SNMP_L_IF_IP_STR 调用结果：' + str(N_IP) + str(R_IP))
  234.     Log.debug('函数 ' + sys._getframe().f_code.co_name + ' 的 SNMP_L_IF_MASK_STR 调用结果：' + str(N_MASK) + str(R_MASK))
  235.     Log.debug('函数 ' + sys._getframe().f_code.co_name + ' 的 SNMP_L_IF_INDEX_STR 调用结果：' + str(N_INDEX) + str(R_INDEX))
  236.     Log.debug('函数 ' + sys._getframe().f_code.co_name + ' 的 SNMP_D_IF_DESCR 调用结果：' + str(N_DESCR) + str(R_DESCR))
  237.     if N_IP == N_MASK == N_INDEX == N_DESCR == 0:
  238.         if len(R_IP) == len(R_MASK) == len(R_INDEX):
  239.             for i in range(0, len(R_IP)):
  240.                 VLAN = R_INDEX[i]
  241.                 IP = R_IP[i]
  242.                 MASK = R_MASK[i]
  243.                 if VLAN in R_DESCR:
  244.                     KEY = R_DESCR[VLAN]
  245.                     VALUE = IP + '/' + MASK
  246.                     if KEY not in D_VLAN_NET:
  247.                         D_VLAN_NET[KEY] = [VALUE]
  248.                     else:
  249.                         D_VLAN_NET[KEY].append(VALUE)
  250.                 else:
  251.                     ERROR = 'VLAN ' + VLAN + ' 在设备中没有找到'
  252.                     return(1, ERROR)
  253.             return(0, D_VLAN_NET)
  254.         else:
  255.             ERROR = 'IP MASK VLAN 数量不一致'
  256.             return(1, ERROR)
  257.     else:
  258.         ERROR = '有错误 '
  259.         if N_IP != 0:
  260.             ERROR += R_IP
  261.         if N_MASK != 0:
  262.             ERROR += R_MASK
  263.         if N_INDEX != 0:
  264.             ERROR += R_INDEX
  265.         if N_DESCR != 0:
  266.             ERROR += R_DESCR
  267.         return(1, ERROR)
  268.  
  269.  
  270.  
  271.  
  272.

 

文件四代码：

  1. #_*_ coding:utf8 _*_
  2. import paramiko         # SSH 操作模块
  3. import time             # 计时
  4.  
  5.  
  6. ## SSH_LOGIN
  7. ## 登录SSH设备成功不关闭会话，返回ssh连接对象和交互子shell对象，后续可以在登录状态继续操作
  8. def SSH_LOGIN(D_LOGIN_INFO):
  9.     SSH_IP = D_LOGIN_INFO['SSH_IP']
  10.     SSH_PORT = D_LOGIN_INFO['SSH_PORT']
  11.     SSH_USER = D_LOGIN_INFO['SSH_USER']
  12.     SSH_PASS = D_LOGIN_INFO['SSH_PASS']
  13.     SSH = paramiko.SSHClient()
  14.     SSH.set_missing_host_key_policy(paramiko.AutoAddPolicy())
  15.     try:
  16.         SSH.connect(SSH_IP, SSH_PORT, SSH_USER, SSH_PASS)       # 尝试登录SSH设备
  17.     except Exception as e:                                      # 登录失败
  18.         E = '函数 SSH_LOGIN() 登录SSH设备失败 '+ str(e)
  19.         return(1, E)                                            # 返回错误代码1和失败原因
  20.     else:                                                       # 登录成功
  21.         SHELL = SSH.invoke_shell()                              # 使用伪终端（子shell）（交互操作界面需要用到）
  22.         return(0, SSH, SHELL)                                   # 返回成功代码0，ssh连接对象，交互子shell对象
  23.  
  24.  
  25. ## 函数 SHELL_CMD() 执行交互命令返回命令回显字符串
  26. def SHELL_CMD(SHELL, CMD, TIME=2, BUFF=10240):                  # 在交互子SHELL里执行操作命令并预设默认参数
  27.     SHELL.sendall(str(CMD) + '\n')                              # 把命令转成字符串，防止类型不同不能相加
  28.     time.sleep(TIME)                                            # 命令执行后等待足够的时间（默认2秒）以接收回显内容
  29.     B_DATA = SHELL.recv(BUFF)                                   # 保存接收到的回显内容（字节码类型）（接收最大值默认为10240字节）
  30.     S_DATA = B_DATA.decode('utf-8')                             # 回显内容转成字符串类型（使用UTF8编码）
  31.     return(S_DATA)
  32.  
  33.  
  34. ## 函数 SHELL_CTRL() 执行控制命令返回命令回显字符串
  35. def SHELL_CTRL(SHELL, CTRL, TIME=2, BUFF=10240):
  36.     SHELL.sendall(CTRL)
  37.     time.sleep(TIME)
  38.     B_DATA = SHELL.recv(BUFF)
  39.     S_DATA = B_DATA.decode('utf-8')
  40.     return(S_DATA)
  41.

 

文件五代码：

  1. #_*_ coding:utf8 _*_
  2. import subprocess       # 调用操作系统命令
  3. import logging          # 日志模块
  4. ## 如果日志实例不存在，就使用本程序日志模块
  5. Log = logging.getLogger("__name__")
  6. if not logging.FileHandler:
  7.     formatter = logging.Formatter('%(asctime)s %(levelname)-8s : %(message)s')  # 指定logger输出格式
  8.     file_handler = logging.FileHandler("DEV_SNMP.log")                          # 日志文件路径
  9.     file_handler.setFormatter(formatter)                                        # 可以通过setFormatter指定输出格式
  10.     Log.addHandler(file_handler)
  11.     Log.setLevel(logging.DEBUG)
  12.  
  13. '''
  14. 说明：以下函数是通过 Python3 subprocess 模块调用系统命令实现操作SNMP的功能
  15. 前提条件1：系统需要先安装好SNMP工具，有查询和修改SNMP的命令
  16. 安装SNMP命令：以 CentOS7 系统为例
  17.     yum install net-snmp-utils  # 安装SNMP工具
  18.     安装后就会有如下命令
  19.     snmpbulkwalk                # 用于SNMP查询值
  20.     snmpset                     # 用于SNMP修改值
  22. 前提条件2：被管理设备上要开启SNMP功能，以华为模拟器S5700交换机为例：
  23.     system-view                         # 进入配置模式
  24.     snmp-agent                          # 配置SNMP
  25.     snmp-agent sys-info version v2c     # 设置SNMP版本
  26.     snmp-agent community read pwd@123   # 设置只读SNMP密码
  27.     snmp-agent community write pwd@456  # 设置修改SNMP密码
  28.     snmp-agent udp-port 161             # 设置SNMP端口，默认就是 UDP 161
  29. '''
  30.  
  31.  
  32. ## SNMP v2c 版本查询功能
  33. def SNMP_V2_R(SNMP_PWD, SNMP_HOST, SNMP_OID):
  34.     SNMP_CMD = 'snmpbulkwalk -v 2c -c ' + SNMP_PWD + ' ' + SNMP_HOST + ' ' + SNMP_OID
  35.     RR = subprocess.getstatusoutput(SNMP_CMD)
  36.     Log.debug('函数 SNMP_V2_R 执行了系统命令 ' + SNMP_CMD)    ## DEBUG
  37.     Log.debug('命令执行结果 ' + str(RR))                      ## DEBUG
  38.     return(RR)
  39.  
  40. ## SNMP v2c 版本设置功能
  41. def SNMP_V2_W(SNMP_PWD, SNMP_HOST, SNMP_OID, SNMP_TYPE, SNMP_VALUE):
  42.     SNMP_CMD = 'snmpset -v 2c -c '+ SNMP_PWD +' '+ SNMP_HOST +' '+ SNMP_OID +' '+ SNMP_TYPE +' '+ SNMP_VALUE
  43.     RR = subprocess.getstatusoutput(SNMP_CMD)
  44.     Log.debug('函数 SNMP_V2_W 执行了系统命令 ' + SNMP_CMD)    ## DEBUG
  45.     Log.debug('命令执行结果 ' + str(RR))                      ## DEBUG
  46.     return(RR)

结构示意图：

 

 

说明文件：

########################################################################################
## （业务层）
## 管理任务实现业务（根据任务结果处理业务逻辑）
## 如WEB端、命令行端、交互控制端等根据实际业务需要调用任务函数完成业务功能
## 调用 DEF_SSH_eNSP_Switch_S5700.py 里的任务函数执行SSH交互操作，获取任务执行状态和结果
## 调用 DEF_SNMP_eNSP_Switch_S5700.py 里的任务函数执行SNMP操作，获取任务执行状态和结果
## 调用 数据库任务，完成数据记录更新
########################################################################################

## 只操作交换机
Main_Switch
    交互操作测试

#############################################################
## （任务层）
## 管理执行实现任务（根据执行结果处理任务逻辑）
## 向上级返回任务完成结果
## 示例：交换机应用功能的实现函数（华为eNSP模拟器S5700交换机）
#############################################################

## 通过SSH交互操作交换机
DEF_SSH_eNSP_Switch_S5700.py
    from DEV_SSH import *   # 需要导入DEV_SSH.py文件里的SNMP操作函数
    import struct           # 用于解析、打包字节码
    import re               # 用于匹配
    import logging          # 日志模块
    import sys              # 本文件中只用于获取函数名方便生成日志内容
    TEST_D_LOGIN_INFO(D_LOGIN_INFO)         # 检查登录信息字典是否合法
    TEST_IP_STR(IP_STR)                     # 检查IP是否合法
    TRY_MASK_2_MASK_INT(MASK)               # 尝试把掩码转成掩码位数
    IP_INT_2_IP_STR(IP_INT)                 # IP_INT 转 IP_STR
    IP_STR_2_IP_INT(IP_STR)                 # IP_STR 转 IP_INT
    根据地址和掩码计算起始和结束地址(IP_STR, MASK_INT)  # 根据地址和掩码计算起始和结束地址
    IP_MASK_2_IP_INT_LIST(IP_STR, MASK_INT)             # 根据IP地址和掩码位数生成IP所在网段的全部IP_INT地址列表（列表从小到大顺序）
    IP_MASK_2_IP_STR_LIST(IP_STR, MASK_INT)             # 根据IP地址和掩码位数生成IP所在网段的全部IP_STR地址列表（列表从小到大顺序）
    MAC缓存信息转成MAC对应VLAN字典(S_DATA)
    VLAN和NET字典(S_DATA)                               # {'Vlanif10': ['192.168.10.1/24'], 'Vlanif20': ['192.168.20.1/24']}
    VLAN和IP字典(S_DATA)                                # {'Vlanif10': ['192.168.10.1'], 'Vlanif20': ['192.168.20.1']}
    TRY_NET_STR_2_IP_MASK(NET_STR)                      # 尝试把网段表示格式：'IP/MASK' 格式转成元组 (IP_STR, MASK_INT)
    TRY_MAC_2_MAC(MAC_STR, 转换格式='xxxx-xxxx-xxxx')   # 尝试把MAC地址转成指定格式
    返回查看模式(S_DATA, SHELL, 最大深度=5)
    IP_MAC_绑定信息转成IP为KEY字典(S_DATA)              # 从查询静态绑定信息命令回显中提取以IP为KEY以MAC为值的字典
    IP_MAC_绑定信息转成MAC为KEY字典(S_DATA)             # 从查询静态绑定信息命令回显中提取以MAC为KEY以IP为值的字典
    判断是否绑定成功(D, IP, MAC)                        # 在IP和MAC对应字典中是否出现IP和MAC绑定记录
    自动查找网段中可用IP_优先自增(NET_IP_STR, NET_MASK_INT, S_DATA, 网段开头保留地址数量=1, 网段末尾保留地址数量=1)
    自动查找网段中可用IP_自动填充(NET_IP_STR, NET_MASK_INT, S_DATA, 网段开头保留地址数量=1, 网段末尾保留地址数量=1)
    ## 任务函数，传入要登录的设备信息和任务必须的参数
    ## 任务函数分2部分
    ## 第1部分 任务控制函数（用于检查参数，控制SSH连接的打开和关闭，调用任务实现函数）
    ## 第2部分 任务实现函数（用于执行交互操作命令，根据回显结果进行处理，返回任务处理状态和处理结果，方便相同功能复用代码）
    保存配置(D_LOGIN_INFO)
        SHELL_SAVE(SSH, SHELL)
    获取IP和MAC绑定信息(D_LOGIN_INFO)
        SHELL_D_IP_MAC(SSH, SHELL)
    绑定指定IP和指定MAC(D_LOGIN_INFO, Bind_IP, Bind_MAC)
        SHELL_Bind_IP_MAC(SSH, SHELL, Bind_IP, Bind_MAC)
    在指定网段自动选择可用IP和指定MAC绑定(D_LOGIN_INFO, Bind_NET, Bind_MAC)
        SHELL_Bind_NET_MAC(SSH, SHELL, Bind_NET_IP_STR, Bind_NET_MASK_INT, Bind_MAC)
    查找MAC地址所在网段(D_LOGIN_INFO, MAC)
        SHELL_MAC_IN_VLAN(SSH, SHELL, MAC)
    在MAC所在网段自动选择可用IP和进行绑定(D_LOGIN_INFO, Bind_MAC)
        SHELL_AUTO_Bind_MAC(SSH, SHELL, Bind_MAC)
    解除指定IP和指定MAC的绑定(D_LOGIN_INFO, Undo_Bind_IP, Undo_Bind_MAC)
        SHELL_UNDO_Bind_IP_MAC(SSH, SHELL, Undo_Bind_IP, Undo_Bind_MAC)
    解除指定IP的全部MAC绑定(D_LOGIN_INFO, Undo_Bind_IP)
        SHELL_UNDO_Bind_IP(SSH, SHELL, Undo_Bind_IP)
    解除指定MAC的全部IP绑定(D_LOGIN_INFO, Undo_Bind_MAC)
        SHELL_UNDO_Bind_MAC(SSH, SHELL, Undo_Bind_MAC)
    


## 通过SNMP操作交换机
DEF_SNMP_eNSP_Switch_S5700.py
    from DEV_SNMP import *      # 需要导入DEV_SNMP.py文件里的SNMP操作函数
    import sys                  # 本文件中只用于获取函数名方便生成日志内容
    import logging              # 日志模块
    SNMP_MAC_2_mac(SNMP_MAC)                                               ## SNMP获取的MAC地址是 '00 00 00 00 00 00' 形式，需要转成 '0000-0000-0000' 形式
    SNMP_L_Bind_IP_STR(SNMP_PWD, SNMP_HOST)                                ## 获取静态绑定IP列表
    SNMP_L_Bind_MAC_STR(SNMP_PWD, SNMP_HOST)                               ## 获取静态绑定MAC列表
    SNMP_L_IF_IP_STR(SNMP_PWD, SNMP_HOST)                                  ## 获取设备接口IP列表（VLAN接口、物理端口、特殊接口）
    SNMP_L_IF_MASK_STR(SNMP_PWD, SNMP_HOST)                                ## 获取设备接口IP的掩码列表（VLAN接口、物理端口、特殊接口）
    SNMP_L_IF_INDEX_STR(SNMP_PWD, SNMP_HOST)                               ## 获取设备接口编号（VLAN接口、物理端口、特殊接口）
    SNMP_D_IF_DESCR(SNMP_PWD, SNMP_HOST)                                   ## 获取设备接口名称字典（VLAN接口、物理端口、特殊接口）## {'1':InLoopBack0, '2':'NULL0', '3':'Console9/0/0', '4':'MEth0/0/1', '5':'Vlanif1', '6':'GigabitEthernet0/0/1'}
    SNMP_生成以IP为键以MAC地址列表为值的字典(SNMP_PWD, SNMP_HOST)          ## 以IP为键以MAC地址列表为值的字典 {IP_STR:[MAC_STR, MAC_STR]}
    SNMP_生成以VLAN为键以VLAN_IP_MASK列表为值的字典(SNMP_PWD, SNMP_HOST)   ## D_VLAN_NET {VLAN_STR:[IP_STR/MASK_STR]}

###################################################
## （执行层）
## 根据任务需要操作具体设备，并返操作状态和操作结果
###################################################

## 操作SSH交互设备
DEV_SSH.py                                      # SSH登录设备执行命令并返回命令结果的函数文件
    import paramiko                             # SSH 操作模块（第三方模块 pip install paramiko 安装）
    import time                                 # 时间模块
    SSH_LOGIN(D_LOGIN_INFO)                     # 尝试登录设备，登录成功返回SSH连接对象和交互子SHELL对象
    SHELL_CMD(SHELL, CMD, TIME=2, BUFF=10240)   # 执行交互命令返回命令回显字符串
    SHELL_CTRL(SHELL, CTRL, TIME=2, BUFF=10240) # 在交互界面发送控制符（未完成）

## 操作SNMP设备
DEV_SNMP.py（目前只完成Linux环境下应用）
    import subprocess                                                   # 调用操作系统命令
    import logging                                                      # 日志模块
    SNMP_V2_R(SNMP_PWD, SNMP_HOST, SNMP_OID)                            # 读取SNMP设备信息
    SNMP_V2_W(SNMP_PWD, SNMP_HOST, SNMP_OID, SNMP_TYPE, SNMP_VALUE)     # 修改SNMP设备配置

##################
## 变量含义说明 ##
##################

## 变量前缀后缀
B       字节
S       字符串
L       列表
T       元组
D       字典
P       集合
INT     数字
STR     字符串
R       接收函数全部返回内容为一个变量 R = 函数()


D_LOGIN_INFO = {SSH_IP:'192.168.0.1', SSH_PORT:22, SSH_USER:'abc', SSH_PASS:'pwd@123'}   # 字典类型登录信息
SSH_IP          # D_LOGIN_INFO 的 KEY 其值为 登录地址（字符串）
SSH_PORT        # D_LOGIN_INFO 的 KEY 其值为 设备端口（数字）
SSH_USER        # D_LOGIN_INFO 的 KEY 其值为 登录用户（字符串）
SSH_PASS        # D_LOGIN_INFO 的 KEY 其值为 登录密码（字符串）

B_DATA          # 执行交互命令后回显的内容（字节）
S_DATA          # 执行交互命令后回显的内容（字符串）

网段开头保留地址数量  # 一般第一个IP做网关，或者前面保留一些IP地址
网段末尾保留地址数量  # 一般最后一个做网关，或者后面保留一些IP地址

D               # 字典，D_IP_MAC 或 D_MAC_IP 字典

IP              # 临时变量名 或 任意格式IP地址（IP_STR 或 IP_INT）
IP_STR          # 点分十进制字符串类型IP地址（字符串）
IP_INT          # 4字节无符号整数类型IP地址（数字）

MASK            # 临时变量名 或 任意格式掩码（MASK_STR 或 MASK_INT）
MASK_STR        # 点分十进制字符串类型掩码（字符串）'255.255.255.0'
MASK_INT        # 掩码长度（掩码位数）（数字）

MAC             # 临时变量名 或 任意格式MAC地址（字符串）3段6段大写小写
mac_H_SP3       # 连字符分3段16进制小写（字符串）'xxxx-xxxx-xxxx'（hyphen）
MAC_H_SP3       # 连字符分3段16进制大写（字符串）'XXXX-XXXX-XXXX'（hyphen）
mac_H_SP6       # 连字符分6段16进制小写（字符串）'xx-xx-xx-xx-xx-xx'（hyphen）
mac_H_SP6       # 连字符分6段16进制大写（字符串）'XX-XX-XX-XX-XX-XX'（hyphen）
mac_C_SP6       # 冒号符分6段16进制小写（字符串）'xx:xx:xx:xx:xx:xx'（colon）
MAC_C_SP6       # 冒号符分6段16进制大写（字符串）'XX:XX:XX:XX:XX:XX'（colon）

D_IP_MAC        # 以 IP_STR 为键以 MAC_STR_SP3 为值的字典
D_MAC_IP        # 以 MAC_STR_SP3 为键以 IP_STR 为值的字典

IP_MASK         # 网段表示格式（字符串）例：'192.168.0.0/255.255.255.0' 或 '192.168.0.0/24'
NET_STR         # 网段表示格式（字符串）例：'192.168.0.0/255.255.255.0' 或 '192.168.0.0/24'
T_NET           (IP_STR, MASK_INT)

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/知新_RL/article/detail/156736
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号