├── .gitattributes
├── .gitignore
├── LICENSE
├── README.md
├── 文档
├── 参考.md
├── 命名规范.md
├── 快速入门指南.md
└── 操作.md
├── 测试
├── 单元测试_中间系统到中间系统.py
├── 文章_网络设备脚本.py
├── 文章_网络设备脚本2.py
├── 文章_网络设备脚本4示例1.py
├── 文章_网络设备脚本4示例2.py
├── 文章_网络设备脚本4题图.py
├── 文章_网络设备脚本5示例1.py
├── 文章_网络设备脚本5题图.py
├── 文章_网络设备脚本8.py
├── 测试_思科密码解密.py
├── 测试_思科网页.py
├── 测试_水星路由器.py
├── 测试_跳板.py
├── 示例_导出设备配置.py
└── 示例_跟踪接口状态.py
└── 网络设备脚本
├── __init__.py
├── 中兴.py
├── 中兴命令行
├── 全局显示.py
├── 全局配置.py
├── 基本表信息.py
├── 实用.py
├── 常量.py
├── 接口.py
├── 时间.py
├── 用户模式.py
├── 设备.py
└── 访问控制列表.py
├── 华三.py
├── 华三命令行
├── 全局显示.py
├── 全局配置.py
├── 基本表信息.py
├── 常量.py
├── 接口.py
├── 数据结构.py
├── 时间.py
├── 时间范围.py
├── 版本.py
├── 用户.py
├── 用户模式.py
├── 登录.py
├── 简单网络管理协议.py
├── 系统信息.py
├── 网络时间协议.py
├── 设备.py
├── 设备模式.py
├── 访问控制列表.py
└── 连接.py
├── 华三版本七命令行
├── 全局显示.py
├── 全局配置.py
├── 启动.py
├── 基本表信息.py
├── 安全外壳.py
├── 接口.py
├── 时间.py
├── 用户.py
├── 用户模式.py
├── 登录.py
├── 硬件信息.py
├── 简单网络管理协议.py
├── 系统信息.py
├── 设备.py
├── 设备模式.py
├── 访问控制列表.py
├── 路由表信息.py
└── 链路层发现协议.py
├── 华为.py
├── 华为命令行
├── 中间系统到中间系统.py
├── 全局显示.py
├── 全局配置.py
├── 前缀列表.py
├── 启动.py
├── 基本表信息.py
├── 安全外壳.py
├── 实用.py
├── 密码.py
├── 常量.py
├── 开放最短路径优先.py
├── 接口.py
├── 时间.py
├── 服务质量.py
├── 生成树.py
├── 用户.py
├── 用户模式.py
├── 登录.py
├── 端口安全.py
├── 简单网络管理协议.py
├── 系统信息.py
├── 网络时间协议.py
├── 网络终端.py
├── 虚拟局域网.py
├── 虚拟路由转发.py
├── 设备.py
├── 设备模式.py
├── 访问控制列表.py
├── 路由策略.py
├── 路由表信息.py
├── 边界网关协议.py
├── 连接.py
├── 链路层发现协议.py
└── 静态路由.py
├── 华为引擎命令行
├── 全局显示.py
├── 全局配置.py
├── 基本表信息.py
├── 接口.py
├── 时间.py
├── 用户模式.py
├── 设备.py
├── 路由表信息.py
└── 链路层发现协议.py
├── 华为简单网管
├── 全局显示.py
├── 全局配置.py
└── 设备.py
├── 博达.py
├── 博达命令行
├── 全局显示.py
├── 全局配置.py
├── 启动.py
├── 基本表信息.py
├── 安全外壳.py
├── 接口.py
├── 用户模式.py
├── 系统信息.py
├── 网络终端.py
└── 设备.py
├── 命令行接口
├── 中间系统到中间系统.py
├── 全局显示.py
├── 全局配置.py
├── 前缀列表.py
├── 启动模式.py
├── 命令.py
├── 地址.py
├── 安全外壳.py
├── 开放最短路径优先.py
├── 接口.py
├── 日志.py
├── 时间范围.py
├── 显示.py
├── 服务质量.py
├── 模式.py
├── 生成树.py
├── 用户.py
├── 用户模式.py
├── 登录.py
├── 等待.py
├── 简单网络管理协议.py
├── 网络时间协议.py
├── 网络终端.py
├── 虚拟局域网.py
├── 虚拟路由转发.py
├── 设备.py
├── 访问控制列表.py
├── 路由.py
├── 路由信息协议.py
├── 路由映射.py
├── 边界网关协议.py
├── 连接.py
├── 链路层发现协议.py
└── 静态路由.py
├── 基础接口
├── 中间系统到中间系统.py
├── 信息.py
├── 全局显示.py
├── 全局配置.py
├── 前缀列表.py
├── 动态主机配置协议.py
├── 区域.py
├── 协议.py
├── 可扩展虚拟局域网.py
├── 启动模式.py
├── 增强内部网关路由协议.py
├── 多协议标签交换.py
├── 安全外壳.py
├── 密码.py
├── 开放最短路径优先.py
├── 异常.py
├── 接口.py
├── 操作.py
├── 数据结构.py
├── 数据表.py
├── 文件.py
├── 无线局域网.py
├── 日志.py
├── 时间.py
├── 时间范围.py
├── 服务质量.py
├── 热备份路由协议.py
├── 生成树.py
├── 用户.py
├── 用户模式.py
├── 登录.py
├── 硬件.py
├── 端口安全.py
├── 策略.py
├── 简单网络管理协议.py
├── 类型.py
├── 网络安全性.py
├── 网络时间协议.py
├── 网络终端.py
├── 虚拟局域网.py
├── 虚拟路由器冗余协议.py
├── 虚拟路由转发.py
├── 设备.py
├── 设备模式.py
├── 访问控制列表.py
├── 路由.py
├── 路由信息协议.py
├── 路由映射.py
├── 边界网关协议.py
├── 连接.py
├── 连接层.py
├── 链路层发现协议.py
├── 链路聚合.py
└── 静态路由.py
├── 山石.py
├── 山石防火墙网页
├── 全局显示.py
├── 全局配置.py
├── 模式.py
├── 用户模式.py
├── 设备.py
└── 设备模式.py
├── 思科.py
├── 思科命令行
├── 中间系统到中间系统.py
├── 全局显示.py
├── 全局配置.py
├── 前缀列表.py
├── 动态主机配置协议.py
├── 基本表信息.py
├── 增强内部网关路由协议.py
├── 安全外壳.py
├── 实用.py
├── 密码.py
├── 常量.py
├── 开放最短路径优先.py
├── 接口.py
├── 日志.py
├── 时间.py
├── 时间范围.py
├── 服务质量.py
├── 热备份路由协议.py
├── 生成树.py
├── 用户.py
├── 用户模式.py
├── 登录.py
├── 硬件信息.py
├── 简单网络管理协议.py
├── 系统信息.py
├── 网络时间协议.py
├── 网络终端.py
├── 虚拟路由器冗余协议.py
├── 虚拟路由转发.py
├── 设备.py
├── 设备模式.py
├── 访问控制列表.py
├── 路由信息协议.py
├── 路由映射.py
├── 路由表信息.py
├── 边界网关协议.py
├── 连接.py
├── 钥匙链.py
├── 链路层发现协议.py
└── 静态路由.py
├── 思科简单网管
├── 全局显示.py
├── 全局配置.py
├── 接口.py
└── 设备.py
├── 思科网页
├── 命令行全局配置.py
├── 命令行用户模式.py
└── 命令行设备.py
├── 思科连结命令行
├── 全局显示.py
├── 全局配置.py
├── 启动.py
├── 基本表信息.py
├── 安全外壳.py
├── 接口.py
├── 日志.py
├── 时间.py
├── 热备份路由协议.py
├── 生成树.py
├── 用户.py
├── 用户模式.py
├── 硬件信息.py
├── 简单网络时间协议.py
├── 系统信息.py
├── 虚拟局域网.py
├── 虚拟路由器冗余协议.py
├── 虚拟路由转发.py
├── 设备.py
├── 设备模式.py
├── 访问控制列表.py
├── 路由表信息.py
└── 静态路由.py
├── 普联.py
├── 普联网页
├── 全局配置.py
├── 接口.py
├── 无线局域网.py
├── 模式.py
├── 用户模式.py
└── 设备.py
├── 水星.py
├── 水星网页
├── 全局配置.py
├── 模式.py
├── 用户模式.py
├── 设备.py
└── 静态路由.py
├── 浪潮.py
├── 深信服.py
├── 深信服应用交付网页
├── 全局显示.py
├── 模式.py
├── 模式.xml
├── 用户模式.py
├── 设备.py
└── 设备模式.py
├── 深信服应用交付网页2
├── 全局显示.py
├── 模式.py
├── 模式.xml
├── 用户模式.py
├── 设备.py
├── 设备模式.py
└── 静态路由.py
├── 深信服防火墙命令行
├── 全局显示.py
├── 全局配置.py
├── 区域.py
├── 常量.py
├── 接口.py
├── 用户模式.py
└── 设备.py
├── 深信服防火墙网页
├── 全局显示.py
├── 全局配置.py
├── 模式.py
├── 用户模式.py
├── 系统信息.py
├── 设备.py
└── 路由表信息.py
├── 深信服防火墙网页2
├── 全局显示.py
├── 全局配置.py
├── 模式.py
├── 模式.xml
├── 用户模式.py
├── 系统信息.py
├── 设备.py
└── 路由表信息.py
├── 深信服防火墙网页2022
├── 全局显示.py
├── 全局配置.py
├── 模式.py
├── 模式.xml
├── 用户模式.py
├── 设备.py
└── 设备模式.py
├── 瑞斯康达命令行
├── 全局显示.py
├── 全局配置.py
├── 基本表信息.py
├── 接口.py
├── 日志.py
├── 时间.py
├── 用户.py
├── 用户模式.py
├── 登录.py
├── 硬件信息.py
├── 简单网络管理协议.py
├── 系统信息.py
├── 网络时间协议.py
├── 设备.py
├── 设备模式.py
├── 访问控制列表.py
└── 路由表信息.py
├── 盛科命令行
├── 全局显示.py
├── 全局配置.py
├── 基本表信息.py
├── 安全外壳.py
├── 常量.py
├── 接口.py
├── 日志.py
├── 时间.py
├── 用户.py
├── 用户模式.py
├── 登录.py
├── 硬件信息.py
├── 简单网络管理协议.py
├── 管理口信息.py
├── 系统信息.py
├── 网络时间协议.py
├── 网络终端.py
├── 虚拟路由器冗余协议.py
├── 设备.py
├── 设备模式.py
├── 访问控制列表.py
├── 路由表信息.py
└── 链路层发现协议.py
├── 盛科网页
├── 全局显示.py
├── 全局配置.py
├── 基本表信息.py
├── 时间.py
├── 模式.py
├── 用户模式.py
└── 设备.py
├── 简单网管接口
├── 信息.py
├── 全局显示.py
├── 全局配置.py
├── 基本表信息.py
├── 接口.py
├── 数据表.py
├── 标识.py
├── 模式.py
└── 设备.py
├── 紫光.py
├── 网页接口
├── 元素.py
├── 图片.py
└── 设备.py
├── 迈普.py
├── 迈普命令行
├── 全局显示.py
├── 全局配置.py
├── 基本表信息.py
├── 用户模式.py
└── 设备.py
├── 锐捷.py
└── 锐捷命令行
├── 全局显示.py
├── 全局配置.py
├── 启动.py
├── 基本表信息.py
├── 用户模式.py
└── 设备.py
/.gitattributes:
--------------------------------------------------------------------------------
1 | # Auto detect text files and perform LF normalization
2 | * text=auto
3 |
--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
1 | MIT License
2 |
3 | Copyright (c) 2019 cflw
4 |
5 | Permission is hereby granted, free of charge, to any person obtaining a copy
6 | of this software and associated documentation files (the "Software"), to deal
7 | in the Software without restriction, including without limitation the rights
8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 |
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 |
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
--------------------------------------------------------------------------------
/文档/命名规范.md:
--------------------------------------------------------------------------------
1 | # 《网络设备脚本》命名规范
2 | 此文档规定了《网络设备脚本》相关名称的用词要求及翻译要求。
3 |
4 | 通用的命名规范见《[中文编程命名法（第2版）](https://blog.csdn.net/acebdo/article/details/80554791)》\[CSDN\]
5 |
6 | ### 网络设备脚本具体命名规范
7 | * 只有根模式（顶级模式）的名称带“模式”：用户模式、启动模式
8 | * 只有全局配置模式接口名和文件名后面带“配置”，其他配置模式接口名带“配置”，文件名不带“配置”
9 | * 例: `用户.py`存放`I用户配置`或对应实现，`用户模式.py`存放`I用户模式`或对应实现
10 | * 所有公开的接口、类、结构名所包含的协议、技术名称为中文全称
11 | * 例: 访问控制列表配置模式接口名为`I访问控制列表配置`，不是`IAclConf`也不是`IAccessControlListConfigurationMode`
12 | * 有广泛认可的中文专有名词则用之
13 | * `Local Area Network`译为`局域网`
14 | * 对于不同包的重名模块，按包来历给模块取别名
15 | * 来自`cflw代码库py`的模块在模块别名前加“库”
16 | * 来自`/基础接口`的模块在模块别名前加“北向”
17 | * 来自`/命令行接口`的模块在模块别名前加“南向”
18 | * 来自具体实现的模块在模块别名前加“实现”或品牌名
19 | * 例: `cflw代码库py.cflw网络连接`别名`库连接`, `网络设备脚本.基础接口.连接`别名`北向连接`, `网络设备脚本.命令行接口.连接`别名`南向连接`, `网络设备脚本.思科命令行.连接`别名`实现连接`或`思科连接`
20 |
21 | ### 项目中一些词的含义
22 | |词|含义|示例|
23 | |-|-|-|
24 | |生成|动词
1.把传入的参数转换成命令|1.`f~地址(a地址)`|
25 | |解析|动词
1.把具体配置转换成网络设备脚本统一值
2.把乱七八糟的参数转换成统一值|1.`f~规则(a规则: str)`
2.`f~操作(a操作)`|
--------------------------------------------------------------------------------
/文档/快速入门指南.md:
--------------------------------------------------------------------------------
1 | # 《网络设备脚本》快速入门指南
2 | 该指南简单地介绍一下《网络设备脚本》的使用的方法。
3 |
4 | ## 第一步：创建连接
5 | 连接可以是命令行连接，也可以是网页连接
6 |
7 | 示例：创建网络终端连接
8 | ```python
9 | import cflw代码库py.cflw网络连接 as 连接
10 | v连接 = 连接.C网络终端("192.168.1.1")
11 | ```
12 |
13 | 示例：创建网页连接
14 | ```python
15 | import selenium.webdriver
16 | v连接 = selenium.webdriver.Firefox()
17 | v连接.get("192.168.1.1")
18 | ```
19 |
20 |
21 | ## 第二步：创建设备
22 | 创建连接后，根据设备的品牌、型号、版本来创建设备
23 | 示例：创建一个思科设备
24 | ```python
25 | import 网络设备脚本.思科 as 思科
26 | v设备 = 思科.f创建设备(v连接, 思科.E型号.c7200, 15.2)
27 | ```
28 |
29 | ## 第三步：创建用户模式
30 |
31 | ```python
32 | v用户模式 = v设备.f模式_用户模式() #进入用户模式
33 | v用户模式.f登录() #检测状态并进入用户模式
34 | ```
35 |
36 | ## 第四步：进入特定模式修改配置
37 |
38 | ```python
39 | v全局配置 = v用户模式.f模式_全局配置() #进入全局配置模式
40 | v接口配置 = v全局配置.f模式_接口配置("f0/0") #进入接口FastEthernet0/0
41 | v接口配置.fs网络地址4("1.1.1.1/24", a操作 = 脚本.E操作.e设置) #设置地址
42 | v接口配置.fs开关(True) #开启接口
43 | ```
--------------------------------------------------------------------------------
/测试/单元测试_中间系统到中间系统.py:
--------------------------------------------------------------------------------
1 | import unittest
2 | import 网络设备脚本.基础接口.中间系统到中间系统 as 中间系统到中间系统
3 | class C测试(unittest.TestCase):
4 | def test网络标识全写(self):
5 | ca参数 = [
6 | "00.0000.0000.0000.0000.00",
7 | "00.0000.192.168.000.001.00",
8 | ]
9 | for v参数 in ca参数:
10 | v网络标识 = 中间系统到中间系统.S网络标识.fc字符串(v参数)
11 | print(v参数, v网络标识)
12 | self.assertTrue(v网络标识)
13 | def test网络标识三段(self):
14 | ca参数 = [
15 | ("1", "1", "0"),
16 | (1, 1, 0),
17 | ("00.0000", "0000.0000.0001", "00"),
18 | ("00.0000", "192.168.000.001", "00"),
19 | ]
20 | for v参数 in ca参数:
21 | v网络标识 = 中间系统到中间系统.S网络标识.fc三段(*v参数)
22 | print(v参数, v网络标识)
23 | self.assertTrue(v网络标识)
24 | if __name__ == "__main__":
25 | unittest.main()
--------------------------------------------------------------------------------
/测试/文章_网络设备脚本.py:
--------------------------------------------------------------------------------
1 | import cflw代码库py.cflw网络连接 as 连接
2 | import cflw代码库py.cflw网络地址 as 地址
3 | import 网络设备脚本 as 设备
4 | import 网络设备脚本.思科 as 思科
5 | import 网络设备脚本.华为 as 华为
6 | import 网络设备脚本.华三 as 华三
7 |
8 | def main():
9 | v连接 = 连接.C网络终端("gns3.localhost", 5000)
10 | v设备 = 思科.f创建设备(v连接, 思科.E型号.c7200, 15.2)
11 | v设备.fs回显(True)
12 | #用户
13 | v用户模式 = v设备.f模式_用户()
14 | v用户模式.f显示_时间()
15 | #全局配置
16 | v全局配置 = v用户模式.f模式_全局配置()
17 | #接口配置l0
18 | v接口配置 = v全局配置.f模式_接口配置("l0")
19 | v接口配置.fs网络地址4("1.1.1.1/32")
20 | #接口配置f0/0
21 | v接口配置 = v全局配置.f模式_接口配置("f0/0")
22 | v接口配置.fs网络地址4("12.0.0.1/24")
23 | #用户配置
24 | v用户配置 = v全局配置.f模式_用户配置("asdf")
25 | v用户配置.fs密码("123456")
26 | #结束
27 | v用户模式.f显示_时间()
28 |
29 | if __name__ == "__main__":
30 | main()
--------------------------------------------------------------------------------
/测试/文章_网络设备脚本2.py:
--------------------------------------------------------------------------------
1 | import cflw代码库py.cflw网络连接 as 连接
2 | import cflw代码库py.cflw网络地址 as 地址
3 | import 网络设备脚本 as 设备
4 | import 网络设备脚本.思科 as 思科
5 | import 网络设备脚本.华为 as 华为
6 | import 网络设备脚本.华三 as 华三
7 |
8 | def main():
9 | v连接 = 连接.C网络终端("gns3.localhost", 5000)
10 | v设备 = 思科.f创建设备(v连接, 思科.E型号.c7200, 15.2)
11 | v设备.fs回显(True)
12 | #用户
13 | v用户模式 = v设备.f模式_用户()
14 | v用户模式.f显示_时间()
15 | #全局配置
16 | v全局配置 = v用户模式.f模式_全局配置()
17 | #接口配置f0/0
18 | v接口配置 = v全局配置.f模式_接口配置("f0/0")
19 | v接口配置.fs网络地址4("12.0.0.1/24")
20 | v接口配置.f开关(True)
21 | v接口配置.f显示_当前模式配置()
22 | #用户配置
23 | v用户配置 = v全局配置.f模式_用户配置("asdf")
24 | v用户配置.fs密码("123456")
25 | v用户配置.f显示_当前模式配置()
26 | #结束
27 | v用户模式.f显示_时间()
28 |
29 | if __name__ == "__main__":
30 | main()
--------------------------------------------------------------------------------
/测试/文章_网络设备脚本4示例1.py:
--------------------------------------------------------------------------------
1 | import cflw代码库py.cflw网络连接 as 连接
2 | import cflw代码库py.cflw网络地址 as 地址
3 | import 网络设备脚本 as 设备
4 | import 网络设备脚本.华为 as 华为
5 | def main():
6 | v连接 = 连接.C网络终端("ensp.localhost", 2000)
7 | v设备 = 华为.f创建设备(v连接, 华为.E型号.s5700)
8 | v设备.fs回显(True)
9 | v用户 = v设备.f模式_用户()
10 | v用户.fs终端监视(False)
11 | v全局配置 = v用户.f模式_全局配置()
12 | v序号 = 10
13 | for i in range(1, 25, 4):
14 | v接口 = 设备.S接口.fc标准(设备.E接口.e千兆以太网, 0, 0, range(i, i+4))
15 | v接口配置0 = v全局配置.f模式_虚拟局域网(v接口)
16 | v接口配置0.fs链路类型(设备.E链路类型.e接入)
17 | v虚拟局域网 = v全局配置.f模式_虚拟局域网(v序号)
18 | v虚拟局域网.fs端口(v接口, a操作 = 设备.E操作.e添加)
19 | v虚拟接口 = 设备.S接口.fc标准(设备.E接口.e虚拟局域网, v序号)
20 | v接口配置1 = v全局配置.f模式_接口配置(v虚拟接口)
21 | v接口配置1.fs网络地址4(地址.S网络地址4.fc四段(10, 0, v序号, 1, 24))
22 | v序号 += 1
23 | if __name__ == "__main__":
24 | main()
--------------------------------------------------------------------------------
/测试/文章_网络设备脚本4示例2.py:
--------------------------------------------------------------------------------
1 | import cflw代码库py.cflw网络连接 as 连接
2 | import 网络设备脚本 as 设备
3 | import 网络设备脚本.中兴 as 中兴
4 | def main():
5 | v连接 = 连接.C网络终端("*.*.*.*")
6 | v设备 = 中兴.f创建设备(v连接, 中兴.E型号.zxr10_m6000)
7 | v设备.fs回显(True)
8 | v用户模式 = v设备.f模式_用户()
9 | v用户模式.f登录("****", "****")
10 | v用户模式.f提升权限()
11 | v全局配置 = v用户模式.f模式_全局配置()
12 | # for v行 in v用户模式.f显示_接口表():
13 | # if not v行.m状态:
14 | # v接口配置 = v全局配置.f模式_接口配置(v行.m接口)
15 | # v接口配置.fs描述("123")
16 | for v行 in v用户模式.f显示_接口表():
17 | if v行.m描述 == "123":
18 | v接口配置 = v全局配置.f模式_接口配置(v行.m接口)
19 | v接口配置.fs描述(a操作 = 设备.E操作.e删除)
20 | if __name__ == "__main__":
21 | main()
--------------------------------------------------------------------------------
/测试/文章_网络设备脚本4题图.py:
--------------------------------------------------------------------------------
1 | import cflw代码库py.cflw网络连接 as 连接
2 | import 网络设备脚本 as 设备
3 | import 网络设备脚本.思科 as 思科
4 | def main():
5 | v连接 = 连接.C网络终端("gns3.localhost", 5000)
6 | v设备 = 思科.f创建设备(v连接, 思科.E型号.c7200)
7 | v设备.fs回显(True)
8 | v用户 = v设备.f模式_用户()
9 | v全局配置 = v用户.f模式_全局配置()
10 | v接口配置 = v全局配置.f模式_接口配置("f0/0-1")
11 | v接口配置.fs描述("12345")
12 | v接口配置 = v全局配置.f模式_接口配置("f0-1/0")
13 | v接口配置.fs描述("54321")
14 | if __name__ == "__main__":
15 | main()
--------------------------------------------------------------------------------
/测试/文章_网络设备脚本5题图.py:
--------------------------------------------------------------------------------
1 | import cflw代码库py.cflw网络连接 as 连接
2 | import 网络设备脚本 as 设备
3 | import 网络设备脚本.思科 as 思科
4 | def main():
5 | v连接 = 连接.C网络终端("gns3.localhost", 5000)
6 | v设备 = 思科.f创建设备(v连接, 思科.E型号.c7200, 15.2)
7 | v用户模式 = v设备.f模式_用户()
8 | v用户模式.f登录()
9 | v设备.fs回显(True)
10 | v全局配置 = v用户模式.f模式_全局配置()
11 | v访问列表 = v全局配置.f模式_访问控制列表("acl0", 设备.E访问控制列表类型.e扩展6)
12 | v访问列表.fs规则(None, 设备.S访问控制列表规则(a允许 = True, a协议 = 设备.E协议.ipv6, a源地址 = "1::1/64", a目的地址 = "2::2/64"))
13 | v访问列表.fs规则(None, 设备.S访问控制列表规则(a允许 = True, a协议 = 设备.E协议.tcp, a目的端口 = 设备.S端口号.fc等于(445)))
14 | v访问列表.fs规则(1, 设备.S访问控制列表规则(a允许 = True, a协议 = 设备.E协议.udp, a源地址 = "1234::1234/128", a源端口 = "<=999", a目的端口 = "[1000,10000)"))
15 | if __name__ == "__main__":
16 | main()
--------------------------------------------------------------------------------
/测试/文章_网络设备脚本8.py:
--------------------------------------------------------------------------------
1 | import cflw代码库py.cflw网页连接 as 网页连接
2 | import 网络设备脚本 as 脚本
3 | import 网络设备脚本.思科 as 思科
4 | def main():
5 | v连接 = 网页连接.f创建连接("http://asdf:123456@192.168.44.129")
6 | v设备 = 思科.f创建设备(v连接, 思科.E型号.c7200, 15.2)
7 | #用户
8 | v用户模式 = v设备.f模式_用户()
9 | v用户模式.f登录()
10 | #全局配置
11 | v全局配置 = v用户模式.f模式_全局配置()
12 | #接口配置l0
13 | v接口配置 = v全局配置.f模式_接口("l0")
14 | v接口配置.fs网络地址4("1.1.1.1/32")
15 | #接口配置f0/0
16 | v接口配置 = v全局配置.f模式_接口("f0/1")
17 | v接口配置.fs网络地址4("12.0.0.1/24")
18 | #用户配置
19 | v用户配置 = v全局配置.f模式_用户("asdf")
20 | v用户配置.fs密码("123456")
21 |
22 | if __name__ == "__main__":
23 | main()
--------------------------------------------------------------------------------
/测试/测试_思科密码解密.py:
--------------------------------------------------------------------------------
1 | import 网络设备.思科命令行.密码 as 思科密码
2 | def main():
3 | v密文 = "08701E1D"
4 | v明文 = 思科密码.f解密7(v密文)
5 | print(v明文)
6 | if __name__ == "__main__":
7 | main()
--------------------------------------------------------------------------------
/测试/测试_思科网页.py:
--------------------------------------------------------------------------------
1 | import time
2 | import selenium.webdriver #selenium
3 | import 网络设备脚本.思科 as 思科
4 | def main():
5 | v连接 = selenium.webdriver.Firefox()
6 | v连接.get("http://asdf:1234@192.168.1.10")
7 | v设备 = 思科.f创建设备(v连接, 思科.E型号.c7200, 15.2)
8 | v用户模式 = v设备.f模式_用户()
9 | v用户模式.f登录()
10 | v全局配置 = v用户模式.f模式_全局配置()
11 | v接口配置 = v全局配置.f模式_接口("l0")
12 | v接口配置.fs网络地址4("1.1.1.1/24")
13 | v接口配置.f显示_当前模式配置()
14 | if __name__ == "__main__":
15 | main()
--------------------------------------------------------------------------------
/测试/测试_水星路由器.py:
--------------------------------------------------------------------------------
1 | from selenium import webdriver
2 | import 网络设备脚本.水星 as 水星
3 | def main():
4 | v连接 = webdriver.Firefox()
5 | v连接.get("http://192.168.1.254")
6 | print("开始")
7 | v设备 = 水星.f创建设备(v连接, 水星.E型号.mw155r)
8 | v用户 = v设备.f模式_用户()
9 | v用户.f登录(a密码 = "12345678")
10 | v全局配置 = v用户.f模式_全局配置()
11 | v静态路由 = v全局配置.f模式_静态路由()
12 | # for v路由 in v静态路由.f显示_路由表():
13 | # print(v路由)
14 | v静态路由.fs路由("192.168.10.0/24", "192.168.1.1")
15 | print("结束")
16 | if __name__ == "__main__":
17 | main()
--------------------------------------------------------------------------------
/测试/测试_跳板.py:
--------------------------------------------------------------------------------
1 | import cflw代码库py.cflw网络连接 as 连接
2 | import cflw代码库py.cflw网络连接_视窗 as 视窗连接
3 | import 网络设备脚本 as 脚本
4 | import 网络设备脚本.思科 as 思科
5 | import 网络设备脚本.华为 as 华为
6 | import 网络设备脚本.华三 as 华三
7 | def f连接(a连接):
8 | v设备 = 思科.f创建设备(a连接, 思科.E型号.c7200, 15.0)
9 | # v设备 = 华为.f创建设备(a连接, 华为.E型号.ar3260, 5.130)
10 | # v设备 = 华三.f创建设备(v连接, 华三.E型号.msr3620, 7.1)
11 | v设备.fs回显(True)
12 | v用户 = v设备.f模式_用户()
13 | v用户.f登录(a用户名 = "asdf", a密码 = "1234")
14 | v用户.f提升权限(a密码 = "123456")
15 | return v设备, v用户
16 | def main():
17 | v连接1 = 连接.C网络终端("gns3.localhost", 5000)
18 | # v连接1 = 连接.C网络终端("ensp.localhost", 2000)
19 | # v连接1 = 视窗连接.C命名管道(r"\\.\pipe\topo1-device1")
20 | v设备1, v用户模式1 = f连接(v连接1)
21 | v全局配置1 = v用户模式1.f模式_全局配置()
22 |
23 | v设备2, v用户模式2 = f连接(v用户模式1.f连接_网络终端("12.0.0.2"))
24 | v全局配置2 = v用户模式2.f模式_全局配置()
25 |
26 | v设备3, v用户模式3 = f连接(v用户模式2.f连接_网络终端("23.0.0.3"))
27 | v全局配置3 = v用户模式3.f模式_全局配置()
28 |
29 | v全局配置1.fs设备名("r1")
30 | v全局配置2.fs设备名("r2")
31 | v全局配置3.fs设备名("r3")
32 |
33 | if __name__ == "__main__":
34 | main()
--------------------------------------------------------------------------------
/测试/示例_导出设备配置.py:
--------------------------------------------------------------------------------
1 | import cflw代码库py.cflw网络连接 as 连接
2 | import 网络设备脚本.华为 as 华为
3 | def main():
4 | #连接到设备,取配置
5 | v连接 = 连接.C网络终端("ensp.localhost", 2000)
6 | v设备 = 华为.f创建设备(v连接, 华为.E型号.ar201)
7 | v用户 = v设备.f模式_用户()
8 | v配置 = str(v用户.f显示_当前配置())
9 | print(v配置)
10 | #保存
11 | v文件 = open("d:/test/a.txt", "w")
12 | v文件.write(v配置)
13 | print("结束")
14 | if __name__ == "__main__":
15 | main()
--------------------------------------------------------------------------------
/测试/示例_跟踪接口状态.py:
--------------------------------------------------------------------------------
1 | import time
2 | import cflw代码库py.cflw网络连接 as 连接
3 | import 网络设备脚本.华为 as 华为
4 | ca设备信息 = [
5 | ("ensp.localhost", 2000, 华为.E型号.ar201),
6 | ("ensp.localhost", 2001, 华为.E型号.ar201),
7 | ("ensp.localhost", 2002, 华为.E型号.ar201),
8 | ("ensp.localhost", 2003, 华为.E型号.ar201),
9 | ]
10 | def main():
11 | #初始化
12 | va设备 = []
13 | for v设备信息 in ca设备信息:
14 | v连接 = 连接.C网络终端(v设备信息[0], v设备信息[1])
15 | v设备 = 华为.f创建设备(v连接, v设备信息[2])
16 | va设备.append(v设备)
17 | v用户 = v设备.f模式_用户()
18 | v设备.m设备名称 = v用户.f显示_设备名称()
19 | #开始监视
20 | va状态 = {}
21 | print("开始监视")
22 | while True:
23 | for v设备 in va设备:
24 | v用户 = v设备.f模式_用户()
25 | v接口表 = v用户.f显示_接口表()
26 | for v行 in v接口表.fe行():
27 | v接口名称 = str(v行.m接口)
28 | v键 = (v设备, v接口名称)
29 | if v键 in va状态:
30 | v状态 = va状态[v键]
31 | if v行.m状态 != v状态:
32 | print("状态变化: %s/%s %s->%s" % (v设备.m设备名称, v接口名称, v状态, v行.m状态))
33 | va状态[v键] = v行.m状态
34 | time.sleep(0.5)
35 | if __name__ == "__main__":
36 | main()
--------------------------------------------------------------------------------
/网络设备脚本/中兴.py:
--------------------------------------------------------------------------------
1 | import enum
2 | import cflw代码库py.cflw网络连接 as 连接
3 | #===============================================================================
4 | # 工厂
5 | #===============================================================================
6 | class E型号(enum.IntEnum):
7 | zxr10_m6000 = 46000
8 | def f创建设备(a连接, a型号, a版本 = 0):
9 | if a连接.c连接特性 & 连接.E连接特性.e命令行:
10 | from .中兴命令行 import 设备
11 | return 设备.C设备(a连接, a型号, a版本)
12 | else:
13 | raise ValueError("参数错误")
--------------------------------------------------------------------------------
/网络设备脚本/中兴命令行/全局显示.py:
--------------------------------------------------------------------------------
1 | from ..命令行接口 import 全局显示
2 | from . import 基本表信息
3 | class C全局显示m6000(全局显示.I全局显示):
4 | def __init__(self, a):
5 | 全局显示.I全局显示.__init__(self, a)
6 | #模式
7 | def f模式_时间(self):
8 | from . import 时间
9 | return 时间.C时间显示(self)
10 | #显示配置
11 | def f显示_启动配置(self):
12 | v输出 = self.m设备.f执行显示命令("show startup-config")
13 | return v输出
14 | def f显示_当前配置(self):
15 | v输出 = self.m设备.f执行显示命令("show running-config")
16 | return v输出
17 | #显示具体
18 | def f显示_接口表(self):
19 | v命令 = "show interface brief"
20 | v输出 = self.m设备.f执行显示命令(v命令)
21 | return 基本表信息.f接口表(v输出)
22 | def f显示_网络接口表4(self):
23 | v命令 = "show ip interface brief"
24 | v输出 = self.m设备.f执行显示命令(v命令)
25 | return 基本表信息.f网络接口表4(v输出)
26 |
--------------------------------------------------------------------------------
/网络设备脚本/中兴命令行/全局配置.py:
--------------------------------------------------------------------------------
1 | from ..命令行接口 import 全局配置
2 | from ..基础接口 import 操作
3 | #===============================================================================
4 | # 模式
5 | #===============================================================================
6 | class C全局配置m6000(全局配置.I全局配置):
7 | def __init__(self, a):
8 | 全局配置.I全局配置.__init__(self, a)
9 | #命令
10 | def fg进入命令(self):
11 | return "configure terminal"
12 | #模式
13 | def f模式_接口(self, a接口, a操作 = 操作.E操作.e设置):
14 | from . import 接口
15 | v接口 = 接口.f创建接口m6000(a接口)
16 | return 接口.C接口m6000(self, v接口)
17 | #数据结构
18 | def f模式_访问控制列表(self, a名称, a类型 = None, a操作 = 操作.E操作.e设置):
19 | from ..基础接口 import 访问控制列表 as 北向列表
20 | from ..命令行接口 import 访问控制列表 as 南向列表
21 | from . import 访问控制列表 as 实现列表
22 | if a类型 in (北向列表.E类型.e标准4, 北向列表.E类型.e扩展4):
23 | v模式 = 实现列表.C扩展4_m6000(self, a名称)
24 | else:
25 | raise ValueError("未知的访问控制列表类型")
26 | return v模式
--------------------------------------------------------------------------------
/网络设备脚本/中兴命令行/实用.py:
--------------------------------------------------------------------------------
1 | from ..命令行接口 import 命令
2 | from .常量 import *
3 | f生成开关命令 = 命令.F生成开关命令(c命令_关闭, False, c不)
4 | f生成描述命令 = 命令.F生成描述命令(c命令_描述, c不)
--------------------------------------------------------------------------------
/网络设备脚本/中兴命令行/常量.py:
--------------------------------------------------------------------------------
1 | c不 = "no"
2 | c提权密码 = "zxr10"
3 | c结束符 = '\x03' #ctrl+c
4 | c命令_关闭 = "shutdown"
5 | c命令_描述 = "description"
--------------------------------------------------------------------------------
/网络设备脚本/中兴命令行/时间.py:
--------------------------------------------------------------------------------
1 | import time
2 | import cflw代码库py.cflw字符串 as 字符串
3 | from ..基础接口 import 时间
4 | from ..命令行接口 import 模式
5 | class C时间显示m6000(时间.I时间显示, 模式.I显示模式):
6 | def __init__(self, a):
7 | 模式.I显示模式.__init__(self, a)
8 | def f显示_时间(self):
9 | v命令 = "show clock"
10 | v输出 = self.m设备.f执行显示命令(v命令) #16:20:09 beijing Tue Mar 12 2019
11 | #解析
12 | v空格位置 = 字符串.f全部找(v输出, " ")
13 | v行结束 = v输出.find("\n")
14 | if v行结束 > 0: #如果有换行符,截取到行结束
15 | v输出 = v输出[0 : v空格位置[0]] + v输出[v空格位置[1] : v行结束]
16 | else: #如果没有换行符,截取到字符串结束
17 | v输出 = v输出[0 : v空格位置[0]] + v输出[v空格位置[1]:] #09:09:36 Thu Sep 29 2016
18 | v时间 = time.strptime(v输出, "%H:%M:%S %a %b %d %Y")
19 | return v时间
20 |
--------------------------------------------------------------------------------
/网络设备脚本/中兴命令行/用户模式.py:
--------------------------------------------------------------------------------
1 | import time
2 | from ..命令行接口 import 用户模式
3 | from ..命令行接口 import 命令
4 | from .常量 import *
5 | class C用户模式m6000(用户模式.I用户模式):
6 | def __init__(self, a):
7 | 用户模式.I用户模式.__init__(self, a)
8 | #模式
9 | def f事件_进入模式后(self):
10 | self.f登录自动刷新()
11 | def f模式_全局配置(self):
12 | from . import 全局配置
13 | return 全局配置.C全局配置m6000(self)
14 | def f模式_全局显示(self):
15 | from . import 全局显示
16 | return 全局显示.C全局显示m6000(self)
17 | #动作
18 | def f登录(self, a用户名 = "", a密码 = ""):
19 | time.sleep(1)
20 | v输出 = self.m设备.f输出()
21 | if "Username:" in v输出:
22 | v输出 = self.m设备.f执行命令(a用户名)
23 | if "Password:" in v输出:
24 | self.m设备.f执行命令(a密码)
25 | def f提升权限(self, a密码 = c提权密码, a级别 = None):
26 | v命令 = 命令.C命令("enable")
27 | if a级别:
28 | v命令 += a级别
29 | elif a密码 == c提权密码: #使用默认的提权密码时,级别固定18
30 | v命令 += 18
31 | self.f执行当前模式命令(v命令)
32 | self.m设备.f执行命令(a密码)
33 |
--------------------------------------------------------------------------------
/网络设备脚本/中兴命令行/设备.py:
--------------------------------------------------------------------------------
1 | import cflw代码库py.cflw网络连接 as 连接
2 | from ..命令行接口 import 设备 as 南向设备
3 | from ..命令行接口 import 用户模式 as 用户模式
4 | from .. import 中兴
5 | from .常量 import *
6 | class C设备(南向设备.I设备):
7 | def __init__(self, a连接, a型号, a版本):
8 | 南向设备.I设备.__init__(self, a连接)
9 | self.m连接.fs编码("gb2312")
10 | self.m型号 = a型号
11 | self.m版本 = a版本
12 | self.fs自动换页("--More--")
13 | #输入输出
14 | def f输入_结束符(self): #ctrl+c
15 | self.f输入(c结束符)
16 | def f处理显示结果(self, a输出):
17 | v输出 = a输出.replace("\r\n", "\n")
18 | v输出 = 南向设备.f去头尾行(v输出)
19 | # if v输出.count("\n") < 10: #输出行数太少,检测是否有异常
20 | # self.f检测命令异常(v输出)
21 | return v输出
22 | #动作
23 | def f退出(self):
24 | self.f执行命令("exit")
25 | #模式
26 | def f模式_用户(self):
27 | if self.m型号 == 中兴.E型号.zxr10_m6000:
28 | from . import 用户模式
29 | v模式 = 用户模式.C用户模式m6000(self)
30 | else:
31 | raise ValueError("不支持的型号")
32 | return v模式
33 |
--------------------------------------------------------------------------------
/网络设备脚本/华三命令行/全局显示.py:
--------------------------------------------------------------------------------
1 | import cflw代码库py.cflw字符串 as 字符串
2 | from ..命令行接口 import 全局显示
3 | from ..命令行接口 import 模式
4 | from . import 基本表信息
5 | class C全局显示(全局显示.I全局显示, 模式.I显示模式):
6 | def __init__(self, a):
7 | 模式.I显示模式.__init__(self, a)
8 | #模式
9 | def f模式_设备(self):
10 | from . import 设备模式
11 | return 设备模式.C设备显示v5(self)
12 | def f模式_时间(self):
13 | from . import 时间
14 | return 时间.C时间显示(self)
15 | #配置
16 | def f显示_当前配置(self): #需重写
17 | from . import 系统信息
18 | v输出 = self.m设备.f执行命令("display current-configuration", a自动换页 = True)
19 | v输出 = 字符串.f去头尾行(v输出)
20 | return 系统信息.C配置信息(v输出)
21 | #基本表信息
22 | def f显示_路由表(self): #未完成
23 | v输出 = self.m设备.f执行命令("display ip routing-table", a自动换页 = True)
24 | v输出 = 字符串.f去头尾行(v输出, a转列表 = True)
25 | raise NotImplementedError()
26 | def f显示_默认路由(self): #需重写
27 | v输出 = self.m设备.f执行命令("display ip routing-table 0.0.0.0")
28 | v输出 = 字符串.f去头尾行(v输出, a转列表 = True)
29 | v输出 = v输出[5]
30 | return (ipaddress.IPv4Network("0.0.0.0/0"), v输出[20:25], int(v输出[27:30]), int(v输出[32:42]), ipaddress.IPv4Address(v输出[45:61]), v输出[61:70])
31 | def f显示_链路层发现协议(self): #未完成
32 | v输出 = self.m设备.f执行命令("display lldp neighbor-information", a自动换页 = True)
33 | raise NotImplementedError()
34 |
--------------------------------------------------------------------------------
/网络设备脚本/华三命令行/常量.py:
--------------------------------------------------------------------------------
1 | c不 = "undo"
2 | c结束符 = '\x1a' #ctrl+z
3 | c回车符 = '\r'
4 | c中断符 = "\x03" #ctrl+c
5 | c不适用 = "N/A"
--------------------------------------------------------------------------------
/网络设备脚本/华三命令行/数据结构.py:
--------------------------------------------------------------------------------
1 | class C网络地址池(设备.I网络协议地址池, 模式.C同级模式):
2 | def __init__(self, a, a名称):
3 | 设备.I网络协议地址池.__init__(self, a, a名称)
4 | def fs地址范围(self, a开始, a结束 = None):
5 | v命令 = self.fg命令前缀()
6 | v命令 += a开始
7 | if a结束:
8 | v命令 += a结束
9 | self.f切换到当前模式()
10 | self.m设备.f执行命令(v命令)
11 | def fs默认网关(self, p网关):
12 | v命令 = self.fg命令前缀()
13 | v命令.f添加("gateway", p网关)
14 | self.f切换到当前模式()
15 | self.m设备.f执行命令(v命令)
16 | def fg命令前缀(self):
17 | return 命令.C命令("ip pool " + self.m名称)
18 |
--------------------------------------------------------------------------------
/网络设备脚本/华三命令行/时间.py:
--------------------------------------------------------------------------------
1 | import time
2 | import cflw代码库py.cflw字符串 as 字符串
3 | from ..基础接口 import 时间
4 | from ..命令行接口 import 模式
5 | #===============================================================================
6 | # 信息
7 | #===============================================================================
8 | def f解析时间(a文本: str):
9 | """display clock
10 | 适用于:"""
11 | #15:14:12 UTC Tue 04/16/2019
12 | #过滤时区
13 | v空格位置 = 字符串.f全部找(a文本, " ")
14 | v行结束 = a文本.find("\n")
15 | if v行结束 > 0: #如果有换行符,截取到行结束
16 | v时间s = a文本[0:v空格位置[0]] + a文本[v空格位置[1]:v行结束]
17 | else: #如果没有换行符,截取到字符串结束
18 | v时间s = a文本[0:v空格位置[0]] + a文本[v空格位置[1]:] #12:06:32 Wed 04/26/2000
19 | v时间 = time.strptime(v时间s, "%H:%M:%S %a %m/%d/%Y")
20 | return v时间
21 | #===============================================================================
22 | # 模式
23 | #===============================================================================
24 | class C时间显示(时间.I时间显示, 模式.I显示模式):
25 | def __init__(self, a):
26 | 模式.I显示模式.__init__(self, a)
27 | def f显示_时间(self):
28 | v命令 = "display clock"
29 | v输出 = self.m设备.f执行显示命令(v命令)
30 | return f解析时间(v输出)
31 |
--------------------------------------------------------------------------------
/网络设备脚本/华三命令行/版本.py:
--------------------------------------------------------------------------------
1 | import cflw代码库py.cflw工具 as 工具
2 | def f解析版本字符串(s: str):
3 | """支持的格式:\n
4 | Version 7.1.070, Release 7734P05\n
5 | v7.1.070 r7734p05\n
6 | 其他 工具.S版本号 支持的格式"""
7 | v = s.lower()
8 | if "version" in v:
9 | v逗号位置 = v.find(",")
10 | va大版本 = v[8 : v逗号位置].split(".")
11 | v补丁位置 = v.find("p", v逗号位置)
12 | if v补丁位置 > 0:
13 | v发行号 = v[v逗号位置+10 : v补丁位置]
14 | v补丁号 = v[v补丁位置+1 :]
15 | return 工具.S版本号.fc分段(*va大版本, v发行号, v补丁号)
16 | else:
17 | v发行号 = v[v逗号位置+10 :]
18 | return 工具.S版本号.fc分段(*va大版本, v发行号)
19 | elif "v" in v:
20 | v空格位置 = v.find(" ")
21 | va大版本 = v[1: v空格位置].split(".")
22 | v补丁位置 = v.find("p", v空格位置)
23 | if v补丁位置 > 0:
24 | v发行号 = v[v空格位置+2 : v补丁位置]
25 | v补丁号 = v[v补丁位置+1 :]
26 | return 工具.S版本号.fc分段(*va大版本, v发行号, v补丁号)
27 | else:
28 | v发行号 = v[v空格位置+2 :]
29 | return 工具.S版本号.fc分段(*va大版本, v发行号)
30 | else:
31 | return 工具.S版本号.fc字符串(v)
--------------------------------------------------------------------------------
/网络设备脚本/华三命令行/用户.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 用户 as 北向用户
2 | from ..基础接口 import 操作
3 | from ..命令行接口 import 模式
4 | from ..命令行接口 import 命令
5 | ca服务类型 = {
6 | 北向用户.E服务类型.e终端: "terminal",
7 | 北向用户.E服务类型.e网络终端: "telnet",
8 | 北向用户.E服务类型.e安全外壳: "ssh",
9 | 北向用户.E服务类型.e网页: "web",
10 | }
11 | class C用户(用户.I用户配置, 模式.I模式):
12 | def __init__(self, a, a用户名: str):
13 | 模式.I模式.__init__(self, a)
14 | self.m用户名 = a用户名
15 | def fg模式参数(self):
16 | return self.m用户名
17 | def fg进入命令(self):
18 | v命令 = 命令.C命令("local-user")
19 | v命令 += self.fg模式参数()
20 | return v命令
21 | def fs密码(self, a密码, a操作 = 操作.E操作.e设置):
22 | v命令 = 命令.C命令("password cipher")
23 | v命令 += a密码
24 | self.f执行当前模式命令(v命令)
25 | def fs权限(self, a权限, a操作 = 操作.E操作.e设置):
26 | raise NotImplementedError()
27 | def fs服务类型(self, a服务类型, a操作 = 操作.E操作.e设置):
28 | raise NotImplementedError()
29 | class C用户s2126(C用户):
30 | def __init__(self, a, a用户名):
31 | C用户.__init__(self, a, a用户名)
32 | class C用户v5(C用户):
33 | def __init__(self, a, a用户名):
34 | C用户.__init__(self, a, a用户名)
35 | def fs权限(self, a权限, a操作 = 操作.E操作.e设置):
36 | v命令 = 命令.C命令("authorization-attribute level")
37 | v命令 += a权限
38 | self.f执行当前模式命令(v命令)
39 | def fs服务类型(self, a服务类型, a操作 = 操作.E操作.e设置):
40 | va服务类型 = 北向用户.f解析服务类型(a服务类型)
41 | v命令 = 命令.C命令("service-type")
42 | v命令 += tuple(ca服务类型[v] for v in va服务类型)
43 | self.f执行当前模式命令(v命令)
44 |
--------------------------------------------------------------------------------
/网络设备脚本/华三命令行/简单网络管理协议.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 操作
2 | from ..基础接口 import 文件
3 | from ..基础接口 import 简单网络管理协议 as 北向协议
4 | from ..命令行接口 import 命令
5 | from ..命令行接口 import 模式
6 | from .常量 import *
7 | class C代理v5(模式.C同级模式, 北向协议.I代理配置):
8 | def __init__(self, a):
9 | 模式.C同级模式.__init__(self, a)
10 | def fs开关(self, a操作 = 操作.E操作.e设置):
11 | """命令: [undo] snmp-agent"""
12 | v操作 = 操作.f解析操作(a操作)
13 | v命令 = 命令.C命令("snmp-agent")
14 | v命令.f前置肯定(操作.fi关操作(v操作), c不)
15 | self.f执行当前模式命令(v命令)
16 | def fs团体字符串(self, a字符串, a权限 = 文件.E访问权限.e只读, a操作 = 操作.E操作.e设置):
17 | """命令: snmp-agent community 权限 团体字"""
18 | v命令 = 命令.C命令("snmp-agent community")
19 | if 文件.fi含写(a权限):
20 | v命令 += "write"
21 | else:
22 | v命令 += "read"
23 | v命令 += a字符串
24 | self.f执行当前模式命令(v命令)
25 | class C陷阱v5(模式.C同级模式, 北向协议.I陷阱配置):
26 | def __init__(self, a):
27 | 模式.C同级模式.__init__(self, a)
28 | def fs开关(self, a操作 = 操作.E操作.e开启):
29 | """命令: snmp-agent trap 启用"""
30 | v操作 = 操作.f解析操作(a操作)
31 | v命令 = 命令.C命令("snmp-agent trap")
32 | v命令 += "enable" if 操作.fi开操作(v操作) else "disable"
33 | v输出 = self.f执行当前模式命令(v命令)
34 | #Warning: All switches of SNMP trap/notification will be open. Continue? [Y/N]:
35 | if "[Y/N]" in v输出:
36 | self.m设备.f执行命令("y")
37 | def fs服务器(self, a地址, a字符串, a操作 = 操作.E操作.e添加):
38 | v命令 = 命令.C命令("snmp-agent target-host trap address udp-domain")
39 | v命令 += a地址
40 | v命令 += "params securityname", a字符串
41 | self.f执行当前模式命令(v命令)
--------------------------------------------------------------------------------
/网络设备脚本/华三命令行/系统信息.py:
--------------------------------------------------------------------------------
1 | #===============================================================================
2 | # 信息
3 | #===============================================================================
4 | class C设备主信息: #2021/2/27:旧代码,需要重新验证是否可用
5 | """display device maininfo
6 | 适用于: ?"""
7 | def __init__(self, a输出):
8 | self.m输出 = a输出
9 | def fg型号名(self):
10 | pass
11 | def fg序列号(self):
12 | pass
13 | def fg生产日期(self):
14 | pass
15 | def fg供应商(self):
16 | pass
17 | #===============================================================================
18 | # 工具
19 | #===============================================================================
20 | class C配置信息: #2021/2/27:旧代码,需要重新验证是否可用
21 | def __init__(self, a配置):
22 | self.m配置 = a配置.replace('\r', '')
23 | def __str__(self):
24 | return self.m配置
25 | def fg设备名称(self):
26 | return C输出分析.f从配置取设备名称(self.m配置)
27 | class C输出分析: #2021/2/27:旧代码,需要重新验证是否可用
28 | def f从配置取设备名称(a配置):
29 | v指定行 = a配置.find(" sysname ")
30 | v结束 = a配置.find('\n', v指定行)
31 | if v结束 == -1:
32 | return a配置[v指定行 + 9 :]
33 | else:
34 | return a配置[v指定行 + 9 : v结束]
--------------------------------------------------------------------------------
/网络设备脚本/华三命令行/设备.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 异常
2 | from ..命令行接口 import 设备 as 南向设备
3 | from .常量 import *
4 | ca错误文本与异常类 = [
5 | ("% Unrecognized command found at '^' position.", 异常.X命令),
6 | ("% Ambiguous command found at '^' position.", 异常.X命令)
7 | ]
8 | class C设备(南向设备.I设备):
9 | def __init__(self, a连接, a型号, a版本):
10 | 南向设备.I设备.__init__(self, a连接)
11 | self.fs自动换页(" ---- More ----")
12 | self.m连接.fs编码("gb2312")
13 | self.m型号 = a型号
14 | self.m版本 = a版本
15 | def f退出(self):
16 | self.f执行命令("quit")
17 | def f输入_结束符(self):
18 | self.f输入(c中断符 + c回车符)
19 | self.f输入(c结束符 + c回车符)
20 | def f模式_用户(self):
21 | from . import 用户模式
22 | return 用户模式.C用户视图(self)
23 | def f处理显示结果(self, a输出):
24 | v输出 = a输出.replace("\r", "") #可能有多个\r,清掉
25 | v输出 = 南向设备.f去头尾行(v输出)
26 | return v输出
27 | def f显示_当前模式配置(self):
28 | v输出 = self.f执行显示命令("display this", a自动换页 = True)
29 | v输出 = 南向设备.f去头尾行(v输出)
30 | return v输出
31 |
--------------------------------------------------------------------------------
/网络设备脚本/华三命令行/连接.py:
--------------------------------------------------------------------------------
1 | from ..命令行接口 import 命令
2 | from ..基础接口 import 连接
3 | class C安全外壳(连接.I命令行连接):
4 | """适用于: msr3620(v7.1)"""
5 | def __init__(self, a模式, a地址, **a参数):
6 | 连接.I命令行连接.__init__(self, a模式)
7 | self.m地址 = a地址
8 | self.m用户名 = a参数.get("a用户名")
9 | if not self.m用户名:
10 | raise ValueError("必需指定 a用户名")
11 | self.m密码 = a参数.get("a密码")
12 | if not self.m密码:
13 | raise ValueError("必需指定 a密码")
14 | self.m端口号 = a参数.get("a端口号")
15 | self.m源地址 = a参数.get("a源地址")
16 | self.m虚拟专用网 = a参数.get("a虚拟专用网")
17 | def fg进入命令(self):
18 | v命令 = 命令.C命令("ssh")
19 | v命令 += self.m地址
20 | v命令 |= self.m端口号
21 | v命令 |= "source", self.m源地址
22 | v命令 |= "vpn-instance", self.m虚拟专用网
23 | return v命令
24 | def f连接(self):
25 | v命令 = self.fg进入命令()
26 | v输出 = self.m模式.f执行当前模式命令(v命令)
27 | # Username: asdf
28 | if "Username:" in v输出:
29 | self.m设备.f执行命令(self.m用户名)
30 | # Press CTRL+C to abort.
31 | # Connecting to 12.0.0.2 port 22.
32 | # The server is not authenticated. Continue? [Y/N]:y
33 | if "[Y/N]" in v输出:
34 | self.m设备.f执行命令("y")
35 | # Do you want to save the server public key? [Y/N]:n
36 | if "[Y/N]" in v输出:
37 | self.m设备.f执行命令("n")
38 | # asdf@12.0.0.2's password:
39 | if "password:" in v输出:
40 | self.m设备.f执行命令(self.m密码)
41 |
--------------------------------------------------------------------------------
/网络设备脚本/华三版本七命令行/启动.py:
--------------------------------------------------------------------------------
1 | import time
2 | import cflw代码库py.cflw时间 as 时间
3 | from ..基础接口 import 操作
4 | from ..命令行接口 import 命令
5 | from ..基础接口 import 协议
6 | from ..基础接口 import 接口 as 北向接口
7 | c启动字符 = '\x02' #ctrl+b
8 | class C启动v7(设备.I启动模式):
9 | """适用于: 华三s3100v3(v7.*)"""
10 | def __init__(self, a):
11 | 设备.I启动模式.__init__(self, a)
12 | def f等待提示符(self, a超时 = 60):
13 | v秒表 = 时间.C秒表()
14 | while True:
15 | v输出 = self.m设备.f输出(a等待 = False)
16 | if "BOOT MENU" in v输出:
17 | break
18 | if v秒表.f滴答() >= a超时:
19 | raise TimeoutError()
20 | def f登录(self, a密码 = "", a超时 = 60):
21 | v秒表 = 时间.C秒表()
22 | while True:
23 | self.m设备.f输入(c启动字符)
24 | time.sleep(1)
25 | v输出 = self.m设备.f输出(a等待 = False)
26 | #继续判断
27 | if "assword" in v输出:
28 | time.sleep(1)
29 | break
30 | #超时判断
31 | if v秒表.f滴答() >= a超时:
32 | raise TimeoutError()
33 | self.m设备.f输入(a密码)
34 | self.m设备.f输入_回车()
35 | self.f等待提示符()
36 | def f清除配置(self):
37 | self.m设备.f输入("7")
38 | self.m设备.f输入_回车()
39 | self.m设备.f输入("y")
40 | self.m设备.f输入_回车()
41 | self.f等待提示符()
42 | def f重新启动(self):
43 | self.m设备.f输入("0")
44 | self.m设备.f输入_回车()
45 |
--------------------------------------------------------------------------------
/网络设备脚本/华三版本七命令行/用户.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 操作
2 | from ..基础接口 import 用户 as 北向用户
3 | from ..命令行接口 import 命令
4 | from ..命令行接口 import 模式
5 | ca服务类型 = {
6 | 北向用户.E服务类型.e终端: "terminal",
7 | 北向用户.E服务类型.e网络终端: "telnet",
8 | 北向用户.E服务类型.e安全外壳: "ssh",
9 | 北向用户.E服务类型.e网页: "web",
10 | }
11 | class C用户v7(北向用户.I用户配置, 模式.I模式):
12 | def __init__(self, a, a用户名: str):
13 | 模式.I模式.__init__(self, a)
14 | self.m用户名 = a用户名
15 | def fg模式参数(self):
16 | return self.m用户名
17 | def fg进入命令(self):
18 | v命令 = 命令.C命令("local-user")
19 | v命令 += self.m用户名
20 | return v命令
21 | def fs密码(self, a密码, a操作 = 操作.E操作.e设置):
22 | v命令 = 命令.C命令("password cipher")
23 | v命令 += a密码
24 | self.f执行当前模式命令(v命令)
25 | def fs权限(self, a权限, a操作 = 操作.E操作.e设置):
26 | #未完成
27 | v命令 = 命令.C命令("authorization-attribute user-role level")
28 | v命令 += a权限
29 | self.f执行当前模式命令(v命令)
30 | def fs服务类型(self, a服务类型, a操作 = 操作.E操作.e设置):
31 | va服务类型 = 北向用户.f解析服务类型(a服务类型)
32 | v命令 = 命令.C命令("service-type")
33 | v命令 += tuple(ca服务类型[v] for v in va服务类型)
34 | self.f执行当前模式命令(v命令)
35 | class C用户v7_1(C用户v7):
36 | def __init__(self, a, a用户名: str):
37 | C用户v7.__init__(self, a, a用户名)
38 | def fs权限(self, a权限, a操作 = 操作.E操作.e设置):
39 | #未完成
40 | v命令 = 命令.C命令("authorization-attribute user-role")
41 | v类型 = type(a权限)
42 | if v类型 == int:
43 | v命令 += "level-%d" % (a权限,)
44 | else:
45 | v命令 += a权限
46 | self.f执行当前模式命令(v命令)
47 |
--------------------------------------------------------------------------------
/网络设备脚本/华三版本七命令行/系统信息.py:
--------------------------------------------------------------------------------
1 | import cflw代码库py.cflw字符串 as 字符串
2 | def f解析中央处理器利用率(a文本: str):
3 | """display cpu-usage
4 | 适用于: 华三s6900(v7.1.070)"""
5 | v数字s = 字符串.f提取字符串之间(a文本, "seconds", "% in last 1 minute")
6 | return int(v数字s)
7 | def f解析内存利用率(a文本: str):
8 | """display memory
9 | 适用于: 华三s6900(v7.1.070)"""
10 | v行s = 字符串.f提取包含行(a文本, "Mem:")
11 | v分割 = v行s.split()
12 | return float(v分割[2]) / float(v分割[1])
--------------------------------------------------------------------------------
/网络设备脚本/华为命令行/中间系统到中间系统.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 操作
2 | from ..基础接口 import 中间系统到中间系统 as 北向路由协议
3 | from ..命令行接口 import 命令
4 | from ..命令行接口 import 中间系统到中间系统 as 南向路由协议
5 | from .常量 import *
6 | from . import 接口 as 实现接口
7 | ca级别 = {
8 | 北向路由协议.E级别.e级别1: "level-1",
9 | 北向路由协议.E级别.e级别2: "level-2",
10 | 北向路由协议.E级别.e级别1和2: "level-1-2",
11 | }
12 | class C进程配置(南向路由协议.I进程配置):
13 | def __init__(self, a, a进程号):
14 | 南向路由协议.I进程配置.__init__(self, a, a进程号)
15 | def fg进入命令(self):
16 | return f"isis {self.fg进程号()}"
17 | def f模式_接口(self, a接口):
18 | v接口 = 实现接口.f创建接口(a接口)
19 | return C接口配置(self.fg上级模式(), self.fg进程号(), v接口)
20 | def fs网络标识(self, a标识, a操作 = 操作.E操作.e设置):
21 | v命令 = f"network-entity {a标识}"
22 | self.f执行当前模式命令(v命令)
23 | def fs通告接口(self, a接口, a操作 = 操作.E操作.e设置):
24 | v接口配置 = self.f模式_接口(a接口)
25 | v接口配置.fs通告接口(a操作)
26 | def fs级别(self, a级别, a操作 = 操作.E操作.e设置):
27 | v命令 = 命令.C命令("is-level")
28 | v命令 += ca级别[a级别]
29 | v操作 = 操作.f解析操作(a操作)
30 | v命令.f前置肯定(操作.fi减操作(v操作), c不)
31 | self.f执行当前模式命令(v命令)
32 | class C接口配置(南向路由协议.I接口配置):
33 | def __init__(self, a, a进程号, a接口):
34 | 南向路由协议.I接口配置.__init__(self, a, a进程号, a接口)
35 | def fs通告接口(self, a操作 = 操作.E操作.e设置):
36 | v命令 = 命令.C命令(f"isis enable {self.fg进程号()}")
37 | v操作 = 操作.f解析操作(a操作)
38 | v命令.f前置肯定(操作.fi减操作(v操作), c不)
39 | self.f执行当前模式命令(v命令)
40 | def fs被动接口(self, a操作 = 操作.E操作.e设置):
41 | v命令 = 命令.C命令("isis slient")
42 | v操作 = 操作.f解析操作(a操作)
43 | v命令.f前置肯定(操作.fi减操作(v操作), c不)
44 | self.f执行当前模式命令(v命令)
45 |
--------------------------------------------------------------------------------
/网络设备脚本/华为命令行/前缀列表.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 操作
2 | from ..命令行接口 import 命令
3 | from ..基础接口 import 协议
4 | from ..基础接口 import 接口 as 北向接口
5 | import cflw代码库py.cflw网络地址 as 地址
6 | from . import 通用_访问控制列表 as 通用
7 | c不 = "undo"
8 | c版本4 = "ip-prefix"
9 | c版本6 = "ipv6-prefix"
10 | c关键字_序号 = "index"
11 | c关键字_大于等于 = "greater-equal"
12 | c关键字_小于等于 = "less-equal"
13 | class C前缀列表(设备.I前缀列表, 模式.C同级模式):
14 | def __init__(self, a, a名称, a版本, t地址):
15 | 设备.I前缀列表.__init__(self, a)
16 | self.m名称 = a名称
17 | self.m版本 = a版本
18 | if not t地址 in (地址.S网络地址4, 地址.S网络地址6):
19 | raise TypeError()
20 | self.t地址 = t地址
21 | self.c最大前缀长度 = t地址.c最大前缀长度
22 | def f生成命令(self, a序号 = None, a规则 = None):
23 | v命令 = 命令.C命令()
24 | v命令 += "ip %s %s" % (self.m版本, self.m名称)
25 | if a序号:
26 | v命令 += "%s %d" % (c关键字_序号, a序号)
27 | if a规则:
28 | if not a序号 and a规则.m序号:
29 | v命令 += "%s %d" % (c关键字_序号, a规则.m序号)
30 | v命令 += "%s %s %d" % (通用.f生成允许(通用.c允许元组, a规则.m允许), a规则.m网络号.fg网络号s(), a规则.m网络号.fg前缀长度())
31 | if a规则.m最小长度:
32 | v命令 += "%s %d" % (c关键字_大于等于, a规则.m最小长度)
33 | if a规则.m最大长度:
34 | v命令 += "%s %d" % (c关键字_小于等于, a规则.m最大长度)
35 | return v命令
36 | def f添加规则(self, a序号, a规则):
37 | v命令 = self.f生成命令(a序号, a规则)
38 | self.f执行当前模式命令(v命令)
39 | def f删除规则(self, a序号):
40 | v命令 = self.f生成命令(a序号)
41 | v命令.f前面添加(c不)
42 | self.f执行当前模式命令(v命令)
43 |
--------------------------------------------------------------------------------
/网络设备脚本/华为命令行/启动.py:
--------------------------------------------------------------------------------
1 | import time
2 | import cflw代码库py.cflw时间 as 时间
3 | from ..基础接口 import 操作
4 | from ..命令行接口 import 命令
5 | from ..基础接口 import 协议
6 | from ..基础接口 import 接口 as 北向接口
7 | c启动字符 = '\x02'
8 | c旧密码 = "huawei"
9 | c新密码 = "Admin@huawei.com"
10 | class C启动(设备.I启动模式):
11 | def __init__(self, a):
12 | 设备.I启动模式.__init__(self, a)
13 | def f登录(self, a密码 = c新密码, a超时 = 60):
14 | v秒表 = 时间.C秒表()
15 | while True:
16 | self.m设备.f输入(c启动字符)
17 | time.sleep(1)
18 | v输出 = self.m设备.f输出(a等待 = False)
19 | #继续判断
20 | if "password:" in v输出:
21 | break
22 | #超时判断
23 | if v秒表.f滴答() >= a超时:
24 | raise TimeoutError()
25 | self.m设备.f输入(a密码)
26 | self.m设备.f输入_回车()
27 |
--------------------------------------------------------------------------------
/网络设备脚本/华为命令行/实用.py:
--------------------------------------------------------------------------------
1 | import cflw代码库py.cflw网络地址 as 地址
2 | from ..基础接口 import 操作
3 | from ..基础接口 import 协议
4 | from ..基础接口 import 异常
5 | from ..基础接口 import 接口 as 北向接口
6 | from ..命令行接口 import 命令
7 | from .常量 import *
8 | def f生成接口范围(a接口: 北向接口.S接口):
9 | """如果不是范围,返回接口字符串.
10 | 如果是范围,返回以"to"连接的接口字符串"""
11 | if a接口.fi范围(): #是范围
12 | if not a接口.fi只有末尾序号是范围():
13 | raise 异常.X接口格式(a接口)
14 | v头接口 = a接口.fg头接口()
15 | return "%s %s to %s" % (v头接口.fg名称(), v头接口.fg序号字符串(), a接口.fg尾接口().fg序号字符串())
16 | else: #不是范围
17 | return str(a接口)
18 | def f生成地址和前缀长度4(a地址):
19 | v地址 = 地址.S网络地址4.fc自动(a地址)
20 | return "%s %d" % (v地址.fg地址s(), v地址.fg前缀长度())
21 | def f生成虚拟局域网范围(a虚拟局域网):
22 | if type(a虚拟局域网) == range:
23 | return "%d to %d" % (a虚拟局域网.start, a虚拟局域网.stop - 1)
24 | else:
25 | return str(a虚拟局域网)
26 | f生成开关命令 = 命令.F生成开关命令(a命令 = c命令_关闭, ai开命令 = False, a不 = c不)
27 | f生成描述命令 = 命令.F生成描述命令(a命令 = c命令_描述, a不 = c不)
--------------------------------------------------------------------------------
/网络设备脚本/华为命令行/密码.py:
--------------------------------------------------------------------------------
1 | from ..命令行接口 import 设备 as 南向设备
2 | from ..命令行接口 import 命令
3 | def f加密等级(a):
4 | if type(a) == str:
5 | v补全 = 命令.f命令补全(a, 'cipher', 'simple')
6 | if v补全:
7 | return v补全
8 | if 南向设备.f参数等级(a加密等级, 1):
9 | return 'cipher'
10 | else:
11 | return 'simple'
12 |
--------------------------------------------------------------------------------
/网络设备脚本/华为命令行/常量.py:
--------------------------------------------------------------------------------
1 | c不 = "undo"
2 | c次 = "sub"
3 | c结束符 = '\x1a' #ctrl+z
4 | c回车符 = '\r'
5 | c中断符 = "\x03" #ctrl+c
6 | c命令_描述 = "description"
7 | c命令_关闭 = "shutdown"
8 |
--------------------------------------------------------------------------------
/网络设备脚本/华为命令行/生成树.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 操作
2 | from ..基础接口 import 生成树 as 北向生成树
3 | from ..命令行接口 import 模式
4 | from ..命令行接口 import 命令
5 | from ..命令行接口 import 生成树 as 南向生成树
6 | from . import 虚拟局域网
7 | from .常量 import *
8 | ca优先级 = {
9 | 北向生成树.E优先级.e主: "primary",
10 | 北向生成树.E优先级.e次: "secondary",
11 | }
12 | ca模式 = {
13 | 北向生成树.E模式.e快速生成树: "rstp",
14 | 北向生成树.E模式.e多生成树: "mstp",
15 | }
16 | class C多生成树(南向生成树.I多生成树配置):
17 | def __init__(self, a):
18 | 南向生成树.I多生成树配置.__init__(self, a)
19 | def fg进入命令(self):
20 | return "stp region-configuration"
21 | #操作
22 | def fs开关(self, a操作 = 操作.E操作.e开启):
23 | v操作 = 操作.f解析操作(a操作)
24 | v命令 = 命令.C命令("stp enable")
25 | v命令.f前置肯定(操作.fi关操作(v操作), c不)
26 | self.fg上级模式().f执行当前模式命令(v命令)
27 | def fs实例映射(self, a实例, a虚拟局域网, a操作 = 操作.E操作.e添加):
28 | v命令 = f"instance {a实例} vlan {虚拟局域网.f生成虚拟局域网(a虚拟局域网)}"
29 | self.f执行当前模式命令(v命令)
30 | def fs实例优先级(self, a实例, a优先级, a操作 = 操作.E操作.e设置):
31 | if a优先级 in 北向生成树.E优先级:
32 | v优先级 = ca优先级[a优先级]
33 | else:
34 | v优先级 = int(a优先级)
35 | v命令 = f"stp instance {a实例} priority {v优先级}"
36 | self.fg上级模式().f执行当前模式命令(v命令)
37 | def fs域名(self, a名称, a操作 = 操作.E操作.e设置):
38 | v命令 = f"region-name {a名称}"
39 | self.f执行当前模式命令(v命令)
40 | def fs版本(self, a版本, a操作 = 操作.E操作.e设置):
41 | v命令 = f"revision-level {a版本}"
42 | self.f执行当前模式命令(v命令)
--------------------------------------------------------------------------------
/网络设备脚本/华为命令行/用户.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 操作
2 | from ..基础接口 import 用户 as 北向用户
3 | from ..命令行接口 import 模式
4 | from ..命令行接口 import 命令
5 | ca服务类型 = {
6 | 北向用户.E服务类型.e终端: "terminal",
7 | 北向用户.E服务类型.e网络终端: "telnet",
8 | 北向用户.E服务类型.e安全外壳: "ssh",
9 | 北向用户.E服务类型.e网页: "web",
10 | }
11 | class C用户配置(北向用户.I用户配置, 模式.I模式):
12 | def __init__(self, a, a用户名: str):
13 | 模式.I模式.__init__(self, a)
14 | self.m用户名 = a用户名
15 | def fg进入命令(self):
16 | return "aaa"
17 | def fg命令前缀(self):
18 | return 命令.C命令(f"local-user {self.m用户名}")
19 | def fs密码(self, a密码, a操作 = 操作.E操作.e设置):
20 | v命令 = self.fg命令前缀()
21 | v命令 += "password cipher", a密码
22 | self.f执行当前模式命令(v命令)
23 | def fs权限(self, a权限, a操作 = 操作.E操作.e设置):
24 | v命令 = self.fg命令前缀()
25 | if a权限 in 北向用户.E用户权限:
26 | v权限 = {
27 | 北向用户.E用户权限.e最低: 0,
28 | 北向用户.E用户权限.e最高: 15,
29 | }[a权限]
30 | else:
31 | v权限 = int(a权限)
32 | v命令 += "privilege level", v权限
33 | self.f执行当前模式命令(v命令)
34 | def fs服务类型(self, a服务类型, a操作 = 操作.E操作.e设置):
35 | va服务类型 = 北向用户.f解析服务类型(a服务类型)
36 | v命令 = self.fg命令前缀()
37 | v命令 += "service-type"
38 | v命令 += tuple(ca服务类型[v] for v in va服务类型)
39 | self.f执行当前模式命令(v命令)
40 |
--------------------------------------------------------------------------------
/网络设备脚本/华为命令行/端口安全.py:
--------------------------------------------------------------------------------
1 | from ..命令行接口 import 接口 as 南向接口
2 | from ..命令行接口 import 端口安全 as 南向端口安全
3 | #端口安全
4 | class C端口安全(南向端口安全.I接口配置):
5 | def __init__(self, a, a接口):
6 | 南向端口安全.I接口配置.__init__(self, a, a接口)
7 | @南向接口.A接口自动展开
8 | def fs开关(self, a开关):
9 | if a开关:
10 | self.f执行当前模式命令("port-security enable")
11 | else:
12 | self.f执行当前模式命令("undo port-security enable")
13 | @南向接口.A接口自动展开
14 | def fs数量(self, a数量):
15 | v命令 = "port-security max-mac-num " + int(a数量)
16 | self.f执行当前模式命令(v命令)
17 | @南向接口.A接口自动展开
18 | def fs动作(self, a动作):
19 | v命令 = "port-security protect-action " + C端口安全.f生成动作(a动作)
20 | self.f执行当前模式命令(v命令)
21 | @staticmethod
22 | def f生成动作(a动作):
23 | v类型 = type(a动作)
24 | if v类型 == str:
25 | return a动作
26 | elif v类型 == int:
27 | return ("shutdown", "restrict", "protect")[a动作]
28 | elif v类型 == bool:
29 | if a动作:
30 | return "restrict"
31 | else:
32 | return "shutdown"
33 | return "restrict"
34 |
--------------------------------------------------------------------------------
/网络设备脚本/华为命令行/简单网络管理协议.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 操作
2 | from ..基础接口 import 文件
3 | from ..基础接口 import 简单网络管理协议 as 北向协议
4 | from ..命令行接口 import 命令
5 | from ..命令行接口 import 模式
6 | class C代理(模式.C同级模式, 北向协议.I代理配置):
7 | def __init__(self, a):
8 | 模式.C同级模式.__init__(self, a)
9 | def fs开关(self, a操作 = 操作.E操作.e设置):
10 | """命令: snmp-agent protocol server ipv几 启用
11 | 关闭后不再监听"""
12 | v操作 = 操作.f解析操作(a操作)
13 | v命令 = 命令.C命令("snmp-agent protocol server ipv4")
14 | v命令 += "enable" if 操作.fi开操作(v操作) else "disable"
15 | self.f执行当前模式命令(v命令)
16 | def fs团体字符串(self, a字符串, a权限 = 文件.E访问权限.e只读, a操作 = 操作.E操作.e设置):
17 | """命令: snmp-agent community 权限 团体字"""
18 | v命令 = 命令.C命令("snmp-agent community")
19 | if 文件.fi含写(a权限):
20 | v命令 += "write"
21 | else:
22 | v命令 += "read"
23 | v命令 += a字符串
24 | self.f执行当前模式命令(v命令)
25 | class C陷阱(模式.C同级模式, 北向协议.I陷阱配置):
26 | def __init__(self, a):
27 | 模式.C同级模式.__init__(self, a)
28 | def fs开关(self, a操作 = 操作.E操作.e开启):
29 | """命令: snmp-agent trap 启用"""
30 | v操作 = 操作.f解析操作(a操作)
31 | v命令 = 命令.C命令("snmp-agent trap")
32 | v命令 += "enable" if 操作.fi开操作(v操作) else "disable"
33 | v输出 = self.f执行当前模式命令(v命令)
34 | #Warning: All switches of SNMP trap/notification will be open. Continue? [Y/N]:
35 | if "[Y/N]" in v输出:
36 | self.m设备.f执行命令("y")
37 | def fs服务器(self, a地址, a字符串, a操作 = 操作.E操作.e添加):
38 | v命令 = 命令.C命令("snmp-agent target-host trap address udp-domain")
39 | v命令 += a地址
40 | v命令 += "params securityname", a字符串
41 | self.f执行当前模式命令(v命令)
--------------------------------------------------------------------------------
/网络设备脚本/华为命令行/系统信息.py:
--------------------------------------------------------------------------------
1 | import cflw代码库py.cflw字符串 as 字符串
2 | #硬件信息
3 | class C板属性:
4 | """display elabel
5 | 适用于: s3700"""
6 | def __init__(self, a):
7 | self.m字符串 = 字符串.f提取字符串之间(a, "[Board Properties]\n", "\n\n")
8 | def fg板类型(self):
9 | v字符串 = 字符串.f提取字符串之间(self.m字符串, "BoardType=", "\n")
10 | return v字符串
11 | def fg板代码(self):
12 | v字符串 = 字符串.f提取字符串之间(self.m字符串, "BarCode=", "\n")
13 | return v字符串
14 | def fg项目(self):
15 | v字符串 = 字符串.f提取字符串之间(self.m字符串, "Item=", "\n")
16 | return v字符串
17 | def fg描述(self):
18 | v字符串 = 字符串.f提取字符串之间(self.m字符串, "Description=", "\n")
19 | v长度 = len(v字符串)
20 | try:
21 | if v长度 == 10: #YYYY-MM-DD
22 | v日期 = time.strptime("%Y-%m-%d")
23 | elif v长度 == 8: #YY-MM-DD
24 | v日期 = time.strptime("%y-%m-%d")
25 | else:
26 | return v字符串
27 | return v日期
28 | except:
29 | return v字符串
30 | def fg生产日期(self):
31 | v字符串 = 字符串.f提取字符串之间(self.m字符串, "Manufactured=", "\n")
32 | def fg厂商名(self):
33 | v字符串 = 字符串.f提取字符串之间(self.m字符串, "VendorName=", "\n")
34 | return v字符串
35 | class C电子标签信息s3700:
36 | """display elabel
37 | 适用于: s3700"""
38 | def __init__(self, a):
39 | self.m主板 = C板属性(a)
40 | def fg序列号(self):
41 | return self.m主板.fg板代码()
42 |
--------------------------------------------------------------------------------
/网络设备脚本/华为命令行/网络终端.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 操作
2 | from ..命令行接口 import 命令
3 | from ..命令行接口 import 模式
4 | from ..命令行接口 import 网络终端 as 南向网络终端
5 | from .常量 import *
6 | class C网络终端配置(南向网络终端.I网络终端配置, 模式.C同级模式):
7 | def __init__(self, a):
8 | 南向网络终端.I网络终端配置.__init__(self, a)
9 | def fs开关(self, a操作 = 操作.E操作.e开启):
10 | v操作 = 操作.f解析操作(a操作)
11 | v命令 = 命令.C命令("telnet server enable")
12 | v命令.f前置否定(操作.fi关操作(v操作), c不)
13 | self.f执行当前模式命令(v命令)
14 | def fs端口号(self, a):
15 | v命令 = 命令.C命令("telnet server port")
16 | v命令 += a
17 | self.f执行当前模式命令(v命令)
18 |
--------------------------------------------------------------------------------
/网络设备脚本/华为命令行/虚拟路由转发.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 操作
2 | from ..命令行接口 import 命令
3 | from ..命令行接口 import 虚拟路由转发 as 南向转发
4 | class C资源配置(南向转发.I资源配置):
5 | def __init__(self, a, a名称):
6 | 南向转发.I资源配置.__init__(self, a, a名称)
7 | def fg进入命令(self):
8 | """命令: ip vpn-instance 实例名"""
9 | return f"ip vpn-instance {self.fg名称()}"
10 | def fs路由区分符(self, a路由区分符, a操作 = 操作.E操作.e设置):
11 | """命令: route-distinguisher ASN:nn"""
12 | v命令 = 命令.C命令("route-distinguisher")
13 | v命令 += a路由区分符
14 | self.f执行当前模式命令(v命令)
15 | def fs路由目标(self, a路由区分符, a方向 = 操作.E方向.e双, a操作 = 操作.E操作.e设置):
16 | """命令: vpn-target ASN:nn(多个) 方向"""
17 | v命令 = 命令.C命令("vpn-target")
18 | v命令 += a路由区分符
19 | v命令 += {
20 | 操作.E方向.e入: "import-extcommunity",
21 | 操作.E方向.e出: "export-extcommunity",
22 | 操作.E方向.e双: "both"
23 | }[a方向]
24 | self.f执行当前模式命令(v命令)
25 | class C接口配置(南向转发.I接口配置):
26 | def __init__(self, a, a接口):
27 | 南向转发.I接口配置.__init__(self, a接口)
28 | def fs虚拟路由转发(self, a名称, a保留地址 = True, a操作 = 操作.E操作.e设置):
29 | """命令: ip binding vpn-instance 实例"""
30 | v命令 = f"ip binding vpn-instance {a名称}"
31 | self.f执行当前模式命令(v命令)
--------------------------------------------------------------------------------
/网络设备脚本/华为命令行/设备.py:
--------------------------------------------------------------------------------
1 | import cflw代码库py.cflw网络连接 as 连接
2 | from ..基础接口 import 异常
3 | from ..基础接口 import 操作
4 | from ..命令行接口 import 设备 as 南向设备
5 | from ..命令行接口 import 命令
6 | from ..命令行接口 import 用户模式
7 | from .. import 华为
8 | from .常量 import *
9 | ca错误文本与异常类 = [
10 | ("Error: Wrong parameter found at '^' position.", 异常.X命令),
11 | ("Error:Too many parameters found at '^' position.", 异常.X命令)
12 | ]
13 | class C设备(南向设备.I设备):
14 | """适用于: 华为s5700(v5.20)"""
15 | def __init__(self, a连接, a型号, a版本):
16 | 南向设备.I设备.__init__(self, a连接)
17 | self.m连接.fs编码("gb2312")
18 | self.m型号 = a型号
19 | self.m版本 = a版本
20 | self.fs自动换页(" ---- More ----")
21 | def f退出(self):
22 | self.f执行命令("quit")
23 | def f输入_结束符(self):
24 | self.f输入(c结束符 + "\r")
25 | def f模式_用户(self):
26 | from . import 用户模式 as 实现
27 | return 实现.C用户视图(self)
28 | def f执行命令(self, a命令):
29 | v输出 = 南向设备.I设备.f执行命令(self, a命令)
30 | self.f检测命令异常(v输出)
31 | return v输出
32 | def f处理显示结果(self, a输出):
33 | v输出 = 南向设备.f去头尾行(a输出)
34 | if v输出.count("\n") < 10:
35 | self.f检测命令异常(v输出)
36 | return v输出
37 | def f显示_当前模式配置(self):
38 | self.fg当前模式().f切换到当前模式()
39 | v输出 = self.f执行显示命令("display this", a自动换页 = True)
40 | return v输出
41 | #助手
42 | def f助手_访问控制列表(self):
43 | return 访问控制列表.C助手()
44 | def f助手_服务质量策略(self, a策略名称, a分类名称, a行为名称, ai自动绑定 = True):
45 | from . import 服务质量
46 | return 服务质量.C助手(a策略名称, a分类名称, a行为名称, ai自动绑定)
47 | #其它
48 | f检测命令异常 = 命令.F检测命令异常(ca错误文本与异常类)
49 |
--------------------------------------------------------------------------------
/网络设备脚本/华为命令行/设备模式.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 设备模式
2 | from ..命令行接口 import 模式
3 | class C设备显示(设备模式.I设备显示, 模式.I显示模式):
4 | def __init__(self, a):
5 | 模式.I显示模式.__init__(self, a)
6 | #基础
7 | def f显示_版本(self):
8 | v命令 = "display version"
9 | v输出 = self.m设备.f执行显示命令(v命令, a自动换页 = True)
10 | return v输出
11 | def f显示_时间(self):
12 | from . import 时间
13 | def f显示_设备名(self):
14 | v命令 = "display current-configuration | include sysname"
15 | v输出 = self.m设备.f执行显示命令(v命令)
16 | return C输出分析.f从配置取设备名称(v输出)
17 | def f显示_运行时间(self):
18 | "从开机到现在所经过的时间"
19 | raise NotImplementedError()
20 | def f显示_开机日期(self):
21 | raise NotImplementedError()
22 | def f显示_序列号(self):
23 | raise NotImplementedError()
24 | def f显示_出厂日期(self):
25 | raise NotImplementedError()
26 |
--------------------------------------------------------------------------------
/网络设备脚本/华为命令行/路由策略.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 操作
2 | from ..基础接口 import 策略
3 | from ..命令行接口 import 模式
4 | from ..命令行接口 import 命令
5 | from ..命令行接口 import 路由映射
6 | from . import 访问控制列表 as 访问列表
7 | class C组(路由映射.I路由映射组, 模式.C同级模式):
8 | def __init__(self, a, a名称):
9 | 路由映射.I路由映射组.__init__(self, a, a名称)
10 | def f模式_节点(self, a序号, a动作 = True, a操作 = 操作.E操作.e设置):
11 | return C节点(self, a序号, a动作)
12 | @策略.A自动策略()
13 | class C节点(路由映射.I路由映射节点):
14 | def __init__(self, a, a序号, a动作):
15 | 路由映射.I路由映射节点.__init__(self, a, a序号, a动作)
16 | def fg进入命令(self):
17 | """命令: route-policy 名称 动作 node 序号"""
18 | return f"route-policy {self.m名称} {访问列表.f生成允许(self.m动作)} node {self.m序号}"
19 | @策略.A匹配(策略.E类型.e访问列表)
20 | def f匹配_访问列表(self, a值, a操作 = 操作.E操作.e设置):
21 | """命令: if-match acl 访问列表"""
22 | v命令 = f"if-match acl {a值}"
23 | self.f执行当前模式命令(v命令)
24 | @策略.A设置(策略.E类型.e下一跳4)
25 | def f设置_下一跳4(self, a值, a操作 = 操作.E操作.e设置):
26 | """命令: apply ip-address next-hop 地址"""
27 | v命令 = f"apply ip-address next-hop {a值}"
28 | self.f执行当前模式命令(v命令)
--------------------------------------------------------------------------------
/网络设备脚本/华为命令行/路由表信息.py:
--------------------------------------------------------------------------------
1 | import cflw代码库py.cflw字符串 as 字符串
2 | import cflw代码库py.cflw网络地址 as 地址
3 | from ..基础接口 import 路由 as 北向路由
4 | from ..基础接口 import 信息
5 | from ..基础接口 import 数据表
6 | from . import 接口 as 实现接口
7 | ca路由类型 = {
8 | "Direct": 北向路由.E路由类型.e直连,
9 | "Static": 北向路由.E路由类型.e静态,
10 | "RIP": 北向路由.E路由类型.e路由信息协议,
11 | "OSPF": 北向路由.E路由类型.e开放最短路径优先,
12 | "BGP": 北向路由.E路由类型.e边界网关协议,
13 | }
14 | class F路由表4(数据表.I解析表格管线):
15 | """display ip routing-table
16 | 适用于: 华为s5700(v5.110), 华为ar201(模拟器)"""
17 | c网络号 = 0
18 | c类型 = 20
19 | c优先级 = 28
20 | c开销 = 33
21 | c标志 = 43
22 | c下一跳 = 49
23 | c接口 = 65
24 | ca列 = 数据表.C切割列(c网络号, c类型, c优先级, c开销, c标志, c下一跳, c接口)
25 | c标题行 = "Destination/Mask Proto Pre Cost Flags NextHop Interface"
26 | def __init__(self):
27 | 数据表.I解析表格管线.__init__(self)
28 | self.f添加字段(数据表.E字段.e目的网络号, F路由表4.ca列[0], 地址.S网络地址4.fc地址前缀长度字符串)
29 | self.f添加字段(数据表.E字段.e目的路由类型, F路由表4.ca列[1], ca路由类型.get)
30 | self.f添加字段(数据表.E字段.e目的管理距离, F路由表4.ca列[2], int)
31 | self.f添加字段(数据表.E字段.e目的度量值, F路由表4.ca列[3], int)
32 | self.f添加字段(数据表.E字段.e目的下一跳, F路由表4.ca列[5], 地址.S网络地址4.fc主机地址字符串)
33 | self.f添加字段(数据表.E字段.e本端出接口, F路由表4.ca列[6], 实现接口.f创建接口)
34 | fi有效行 = staticmethod(数据表.F有效长度(c接口))
35 | f初始处理 = staticmethod(数据表.F去标题行(c标题行))
36 | f路由表4 = F路由表4()
--------------------------------------------------------------------------------
/网络设备脚本/华为命令行/静态路由.py:
--------------------------------------------------------------------------------
1 | import cflw代码库py.cflw网络地址 as 地址
2 | from ..基础接口 import 操作
3 | from ..基础接口 import 协议
4 | from ..基础接口 import 接口 as 北向接口
5 | from ..基础接口 import 路由 as 北向路由
6 | from ..命令行接口 import 命令
7 | from ..命令行接口 import 模式
8 | from ..命令行接口 import 路由 as 南向路由
9 | from ..命令行接口 import 静态路由 as 南向静态路由
10 | from .常量 import *
11 | from . import 接口 as 实现接口
12 | from . import 路由表信息
13 | def f生成静态路由命令4(a网络号, a下一跳, a虚拟路由转发):
14 | """命令: ip route-static [vpn-instance 实例] 网络号 长度|掩码 下一跳"""
15 | v网络号 = 地址.S网络地址4.fc自动(a网络号)
16 | v下一跳 = 南向路由.f生成下一跳4(a下一跳, 实现接口.f创建接口)
17 | v命令 = 命令.C命令("ip route-static")
18 | if a虚拟路由转发:
19 | v命令 += "vpn-instance", a虚拟路由转发
20 | v命令 += v网络号.fg地址s(), v网络号.fg前缀长度()
21 | v命令 += v下一跳
22 | return v命令
23 | class C静态路由4(模式.C同级模式, 南向静态路由.I静态路由配置):
24 | def __init__(self, a, a虚拟路由转发 = None):
25 | 南向静态路由.I静态路由配置.__init__(self, a)
26 | self.m虚拟路由转发 = a虚拟路由转发
27 | def f显示_路由表(self):
28 | v命令 = 路由表信息.f生成显示路由表命令(协议.E协议.e网络协议4, 北向路由.E路由类型.e静态)
29 | v输出 = self.m设备.f执行显示命令(v命令)
30 | return 路由表信息.C路由表4(v输出)
31 | def fs路由(self, a网络号, a下一跳, a操作 = 操作.E操作.e添加):
32 | v命令 = f生成静态路由命令4(a网络号, a下一跳, self.m虚拟路由转发)
33 | if a操作 == 操作.E操作.e删除:
34 | v命令.f前面添加(c不)
35 | self.f执行当前模式命令(v命令)
36 | def fs默认路由(self, a下一跳, a操作 = 操作.E操作.e添加):
37 | self.fs路由("0.0.0.0/0", a下一跳, a操作)
--------------------------------------------------------------------------------
/网络设备脚本/华为引擎命令行/全局显示.py:
--------------------------------------------------------------------------------
1 | from ..华为命令行 import 全局显示 as 旧全局显示
2 | class C全局显示ne(旧全局显示.C全局显示):
3 | """适用于: 华为ne40e(v8.180)"""
4 | def f显示_时间(self):
5 | from . import 时间
6 | v命令 = "display clock"
7 | v输出 = self.m设备.f执行显示命令(v命令)
8 | return 时间.f解析时间(v输出)
9 | class C全局显示ce(C全局显示ne):
10 | """适用于:"""
11 | pass
--------------------------------------------------------------------------------
/网络设备脚本/华为引擎命令行/全局配置.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 操作
2 | from ..命令行接口 import 命令
3 | from ..华为命令行 import 全局配置 as 旧全局配置
4 | class C系统视图ne(旧全局配置.C系统视图):
5 | """适用于: 华为ne40e(v8.180)"""
6 | def fg进入命令(self):
7 | v命令 = 命令.C命令("system-view")
8 | if self.m设备.m自动提交 == 操作.E自动提交.e立即:
9 | v命令 += "immediately"
10 | return v命令
11 | def f事件_退出模式前(self):
12 | self.m设备.f自动提交(操作.E自动提交.e退出配置模式时)
13 | class C系统视图ce(C系统视图ne):
14 | """适用于:"""
15 | pass
--------------------------------------------------------------------------------
/网络设备脚本/华为引擎命令行/接口.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 北向接口
2 | from ..命令行接口 import 命令
3 | from ..命令行接口 import 接口 as 南向接口
4 | from ..华为命令行 import 实用
5 | from ..华为命令行 import 接口 as 旧接口
6 | from ..华为命令行.常量 import *
7 | class C接口视图(旧接口.C接口视图):
8 | """适用于: 华为ne40e(v8.180)"""
9 | @南向接口.A接口自动展开
10 | def fs开关(self, a操作):
11 | """命令: [undo] shutdown
12 | 不能关闭的口: loopback, """
13 | if self.m接口.m类型 == 北向接口.E类型.e环回:
14 | return
15 | v命令 = 实用.f生成开关命令(a操作)
16 | self.f执行当前模式命令(v命令)
17 |
--------------------------------------------------------------------------------
/网络设备脚本/华为引擎命令行/时间.py:
--------------------------------------------------------------------------------
1 | import time
2 | def f解析时间(a文本: str):
3 | """display clock
4 | 适用于: 华为ne40e(v8.180)"""
5 | #2021-02-27 18:48:20
6 | #Saturday
7 | #Time Zone(DefaultZoneName) : UTC
8 | v时间s = a文本.split("\n")[0]
9 | v时间 = time.strptime(v时间s, "%Y-%m-%d %H:%M:%S")
10 | return v时间
11 |
--------------------------------------------------------------------------------
/网络设备脚本/华为引擎命令行/设备.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 异常
2 | from ..命令行接口 import 命令
3 | from ..华为命令行 import 设备 as 旧设备
4 | ca错误文本与异常类 = [
5 | ("Error: Unrecognized command found at '^' position.", 异常.X命令),
6 | ("Error: Wrong parameter found at '^' position.", 异常.X命令),
7 | ("Error: Ambiguous command found at '^' position.", 异常.X命令),
8 | ]
9 | class C设备ne(旧设备.C设备):
10 | """适用于: 华为ne40e(v8.180)"""
11 | def __init__(self, a连接, a型号, a版本):
12 | 旧设备.C设备.__init__(self, a连接, a型号, a版本)
13 | def f提交(self):
14 | self.f执行命令("commit")
15 | def f模式_用户(self):
16 | from . import 用户模式
17 | return 用户模式.C用户视图ne(self)
18 | #其它
19 | f检测命令异常 = 命令.F检测命令异常(ca错误文本与异常类)
20 | class C设备ce(C设备ne):
21 | """适用于: """
22 | def __init__(self, a连接, a型号, a版本):
23 | C设备ne.__init__(self, a连接, a型号, a版本)
24 | def f提交(self):
25 | self.f执行命令("commit")
26 | def f模式_用户(self):
27 | from . import 用户模式
28 | return 用户模式.C用户视图ce(self)
29 | #其它
30 | f检测命令异常 = 命令.F检测命令异常(ca错误文本与异常类)
31 |
--------------------------------------------------------------------------------
/网络设备脚本/华为引擎命令行/路由表信息.py:
--------------------------------------------------------------------------------
1 | import cflw代码库py.cflw字符串 as 字符串
2 | import cflw代码库py.cflw网络地址 as 地址
3 | from ..基础接口 import 路由 as 北向路由
4 | from ..基础接口 import 信息
5 | from ..基础接口 import 数据表
6 | from ..华为命令行 import 接口 as 实现接口
7 | ca路由类型 = {
8 | "Direct": 北向路由.E路由类型.e直连,
9 | "Static": 北向路由.E路由类型.e静态,
10 | "RIP": 北向路由.E路由类型.e路由信息协议,
11 | "OSPF": 北向路由.E路由类型.e开放最短路径优先,
12 | "BGP": 北向路由.E路由类型.e边界网关协议,
13 | }
14 | class F路由表4(数据表.I解析表格管线):
15 | """display ip routing-table
16 | 适用于: 华为ne40e(v8.180), 华为ne9000(模拟器), 华为ce6800(模拟器)"""
17 | c网络号 = 0
18 | c协议 = 20
19 | c优先级 = 28
20 | c开销 = 33
21 | c标志 = 45
22 | c下一跳 = 51
23 | c接口 = 67
24 | ca列 = 数据表.C切割列(c网络号, c协议, c优先级, c开销, c标志, c下一跳, c接口)
25 | c标题行 = "Destination/Mask Proto Pre Cost Flags NextHop Interface"
26 | def __init__(self):
27 | 数据表.I解析表格管线.__init__(self)
28 | self.f添加字段(数据表.E字段.e目的网络号, F路由表4.ca列[0], 地址.S网络地址4.fc地址前缀长度字符串)
29 | self.f添加字段(数据表.E字段.e目的路由类型, F路由表4.ca列[1], ca路由类型.get)
30 | self.f添加字段(数据表.E字段.e目的管理距离, F路由表4.ca列[2], int)
31 | self.f添加字段(数据表.E字段.e目的度量值, F路由表4.ca列[3], int)
32 | self.f添加字段(数据表.E字段.e目的下一跳, F路由表4.ca列[5], 地址.S网络地址4.fc主机地址字符串)
33 | self.f添加字段(数据表.E字段.e本端出接口, F路由表4.ca列[6], 实现接口.f创建接口)
34 | fi有效行 = staticmethod(数据表.F有效长度(c接口))
35 | f初始处理 = staticmethod(数据表.F去标题行(c标题行))
36 | f路由表4 = F路由表4()
--------------------------------------------------------------------------------
/网络设备脚本/华为简单网管/全局显示.py:
--------------------------------------------------------------------------------
1 | from ..简单网管接口 import 全局显示
2 | class C全局显示(全局显示.I全局显示):
3 | pass
--------------------------------------------------------------------------------
/网络设备脚本/华为简单网管/全局配置.py:
--------------------------------------------------------------------------------
1 | from ..简单网管接口 import 全局配置
2 | class C全局配置(全局配置.I全局配置):
3 | pass
--------------------------------------------------------------------------------
/网络设备脚本/华为简单网管/设备.py:
--------------------------------------------------------------------------------
1 | from ..简单网管接口 import 设备
2 | class C设备(设备.I设备):
3 | def __init__(self, a连接, a型号, a版本):
4 | 设备.I设备.__init__(self, a连接)
5 | self.m型号 = a型号
6 | self.m版本 = a版本
7 | def f模式_配置(self):
8 | from . import 全局配置
9 | return 全局配置.C全局配置(self)
10 | def f模式_显示(self):
11 | from . import 全局显示
12 | return 全局显示.C全局显示(self)
--------------------------------------------------------------------------------
/网络设备脚本/博达.py:
--------------------------------------------------------------------------------
1 | import enum
2 | #===============================================================================
3 | # 工厂
4 | #===============================================================================
5 | class E型号(enum.IntEnum):
6 | s3956 = 3956
7 | def f创建设备(a连接, a型号, a版本 = 0):
8 | from .博达命令行 import 设备
9 | return 设备.C设备(a连接, a型号, a版本)
10 |
--------------------------------------------------------------------------------
/网络设备脚本/博达命令行/全局显示.py:
--------------------------------------------------------------------------------
1 | from ..命令行接口 import 全局显示
2 | from . import 基本表信息
3 | class C全局显示(全局显示.I全局显示):
4 | """适用于: s3956(v2.2.0B)"""
5 | #显示
6 | def f显示_版本(self):
7 | v输出 = self.m设备.f执行显示命令("show version")
8 | return 系统信息.C版本(v输出)
9 | def f显示_启动配置(self):
10 | v输出 = self.m设备.f执行显示命令("show configuration")
11 | return v输出
12 | def f显示_当前配置(self):
13 | v输出 = self.m设备.f执行显示命令("show running-config")
14 | return v输出
15 | def f显示_时间(self):
16 | v版本 = self.f显示_版本()
17 | return v版本.fg当前时间()
18 | def f显示_设备名(self):
19 | v命令 = "show running-config | include hostname"
20 | v输出 = self.m设备.f执行显示命令(v命令)
21 | v位置 = v输出.find("hostname")
22 | v行结束 = v输出.find("\n", v位置)
23 | return v输出[v位置 + 9 : v行结束]
24 | #显示具体
25 | def f显示_接口表(self):
26 | v命令 = "show interface brief"
27 | v输出 = self.m设备.f执行显示命令(v命令)
28 | return 基本表信息.C接口表(v输出)
29 | def f显示_网络接口表4(self):
30 | v命令 = "show ip interface brief"
31 | v输出 = self.m设备.f执行显示命令(v命令)
32 | return 基本表信息.C网络接口表4(v输出)
33 |
--------------------------------------------------------------------------------
/网络设备脚本/博达命令行/全局配置.py:
--------------------------------------------------------------------------------
1 | from ..命令行接口 import 全局配置
2 | from . import 接口
3 | from ..基础接口 import 操作
4 | class C全局配置(全局配置.I全局配置):
5 | """适用于: s3956(v2.2.0B)"""
6 | def __init__(self, a):
7 | 全局配置.I全局配置.__init__(self, a)
8 | #命令
9 | def fg进入命令(self):
10 | return "configure"
11 | #模式
12 | def f模式_接口(self, a接口, a操作 = 操作.E操作.e设置):
13 | v接口 = 接口.f创建接口(a接口)
14 | return 接口.C接口(self, v接口)
15 | #服务
16 | def f模式_网络终端(self):
17 | from . import 网络终端
18 | return 网络终端.C网络终端配置(self)
19 | def f模式_安全外壳(self):
20 | from . import 安全外壳
21 | return 安全外壳.C安全外壳配置(self)
22 |
--------------------------------------------------------------------------------
/网络设备脚本/博达命令行/启动.py:
--------------------------------------------------------------------------------
1 | import time
2 | import cflw代码库py.cflw时间 as 时间
3 | from ..基础接口 import 操作
4 | from ..命令行接口 import 命令
5 | from ..基础接口 import 协议
6 | from ..基础接口 import 接口 as 北向接口
7 | c启动字符 = '\x10'
8 | class C启动(设备.I启动模式):
9 | def __init__(self, a):
10 | 设备.I启动模式.__init__(self, a)
11 | def f登录(self, a密码 = "", a超时 = 60):
12 | v秒表 = 时间.C秒表()
13 | while True:
14 | self.m设备.f输入(c启动字符)
15 | time.sleep(1)
16 | v输出 = self.m设备.f输出(a等待 = False)
17 | #继续判断
18 | if "monitor#" in v输出:
19 | break
20 | #超时判断
21 | if v秒表.f滴答() >= a超时:
22 | raise TimeoutError()
23 | # self.m设备.f输入(a密码)
24 | self.m设备.f输入_回车()
25 | def f清除配置(self):
26 | self.m设备.f输入("delete startup-config")
27 | self.m设备.f输入_回车()
28 | def f重新启动(self):
29 | self.m设备.f输入("reboot")
30 | self.m设备.f输入_回车()
--------------------------------------------------------------------------------
/网络设备脚本/博达命令行/安全外壳.py:
--------------------------------------------------------------------------------
1 | import time
2 | from ..基础接口 import 操作
3 | from ..命令行接口 import 命令
4 | from ..命令行接口 import 模式
5 | from ..命令行接口 import 安全外壳 as 南向安全外壳
6 | from ..思科命令行.常量 import *
7 | class C安全外壳配置(南向安全外壳.I安全外壳配置, 模式.C同级模式):
8 | def __init__(self, a):
9 | 南向安全外壳.I安全外壳配置.__init__(self, a)
10 | def fs开关(self, a操作 = 操作.E操作.e设置):
11 | v操作 = 操作.f解析操作(a操作)
12 | v命令 = 命令.C命令("ip sshd enable")
13 | if 操作.fi关操作(v操作):
14 | v命令.f前面添加(c不)
15 | self.f执行当前模式命令(v命令)
16 | time.sleep(2)
17 | self.m设备.f输出(a等待 = True)
18 | def f生成密钥(self, a长度 = 1024, a操作 = 操作.E操作.e设置):
19 | pass #没命令
20 | def fs会话超时(self, a时间, a操作 = 操作.E操作.e设置):
21 | v操作 = 操作.f解析操作(a操作)
22 | v命令 = 命令.C命令("ip sshd timeout")
23 | v命令 += a时间
24 | if 操作.fi减操作(v操作):
25 | v命令.f前面添加(c不)
26 | self.f执行当前模式命令(v命令)
--------------------------------------------------------------------------------
/网络设备脚本/博达命令行/接口.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 操作
2 | from ..命令行接口 import 命令
3 | from ..基础接口 import 协议
4 | from ..基础接口 import 接口 as 北向接口
5 | ca接口名称 = 北向接口.ca接口名称 | {
6 | 北向接口.E类型.e虚拟局域网: "VLAN",
7 | }
8 | ca接口缩写 = {
9 | 北向接口.E类型.e快速以太网: "f",
10 | 北向接口.E类型.e吉以太网: "g",
11 | 北向接口.E类型.e十吉以太网: "tg",
12 | 北向接口.E类型.e空: "n",
13 | 北向接口.E类型.e环回: "l",
14 | 北向接口.E类型.e虚拟局域网: "v",
15 | }
16 | f生成接口 = 北向接口.F生成接口(ca接口名称)
17 | f创建接口 = 北向接口.F创建接口(ca接口名称, f生成接口)
18 | f创建接口缩写 = 北向接口.F创建接口(ca接口缩写, f生成接口)
--------------------------------------------------------------------------------
/网络设备脚本/博达命令行/用户模式.py:
--------------------------------------------------------------------------------
1 | import time
2 | from ..命令行接口 import 用户模式
3 | from ..命令行接口 import 命令
4 | class C用户模式(用户模式.I用户模式):
5 | """适用于: s3956(v2.2.0B)"""
6 | def __init__(self, a):
7 | 用户模式.I用户模式.__init__(self, a)
8 | #模式
9 | def f事件_进入模式后(self):
10 | self.m设备.f刷新()
11 | self.m设备.f输入_结束符()
12 | self.m设备.f输入_回车(-1, 5)
13 | def f模式_全局配置(self):
14 | from . import 全局配置
15 | return 全局配置.C全局配置(self)
16 | def f模式_全局显示(self):
17 | from . import 全局显示
18 | return 全局显示.C全局显示(self)
19 | #动作
20 | def f登录(self, a用户名 = "", a密码 = ""):
21 | time.sleep(1)
22 | v输出 = self.m设备.f输出()
23 | if "Username:" in v输出:
24 | v输出 = self.m设备.f执行命令(a用户名)
25 | if "Password:" in v输出:
26 | self.m设备.f执行命令(a密码)
27 | def f提升权限(self, a密码 = "", a级别 = None):
28 | v命令 = 命令.C命令("enable")
29 | if a级别:
30 | v命令 += a级别
31 | v输出 = self.f执行当前模式命令(v命令)
32 | if "assword" in v输出:
33 | self.m设备.f执行命令(a密码)
34 |
--------------------------------------------------------------------------------
/网络设备脚本/博达命令行/系统信息.py:
--------------------------------------------------------------------------------
1 | import time
2 | import cflw代码库py.cflw字符串 as 字符串
3 | class C版本信息:
4 | """show version
5 | 适用于: s3956(v2.2.0B)"""
6 | def __init__(self, a文本):
7 | self.m文本
8 | def fg当前时间(self):
9 | v字符串 = 字符串.f提取字符串之间(self.m文本, "The current time: ", "\n") #2019-4-8 10:7:21
10 | v时间 = time.strptime(v字符串, "%Y-%m-%d %H:%M:%S")
11 | return v时间
--------------------------------------------------------------------------------
/网络设备脚本/博达命令行/网络终端.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 操作
2 | from ..命令行接口 import 命令
3 | from ..命令行接口 import 模式
4 | from ..命令行接口 import 网络终端 as 南向网络终端
5 | from ..思科命令行.常量 import *
6 | from . import 接口 as 实现接口
7 | class C网络终端配置(南向网络终端.I网络终端配置, 模式.C同级模式):
8 | def __init__(self, a):
9 | 南向网络终端.I网络终端配置.__init__(self, a)
10 | def fs开关(self, a操作 = 操作.E操作.e设置):
11 | v操作 = 操作.f解析操作(a操作)
12 | if 操作.fi开操作(v操作):
13 | self.fs连接数(a操作 = 操作.E操作.e删除)
14 | else:
15 | self.fs连接数(0)
16 | def fs端口号(self, a端口号, a操作 = 操作.E操作.e设置):
17 | v操作 = 操作.f解析操作(a操作)
18 | v命令 = 命令.C命令("ip telnet listen-port")
19 | v命令 += a端口号
20 | if 操作.fi减操作(v操作):
21 | v命令.f前面添加(c不)
22 | self.f执行当前模式命令(v命令)
23 | def fs源接口(self, a接口, a操作 = 操作.E操作.e设置):
24 | v操作 = 操作.f解析操作(a操作)
25 | v命令 = 命令.C命令("ip telnet source-interface")
26 | if 操作.fi加操作(v操作):
27 | v接口 = 实现接口.f创建接口(a接口)
28 | v命令 += v接口
29 | else:
30 | v命令.f前面添加(c不)
31 | self.f执行当前模式命令(v命令)
32 | def fs连接数(self, a数量 = 5, a操作 = 操作.E操作.e设置):
33 | v操作 = 操作.f解析操作(a操作)
34 | v命令 = 命令.C命令("ip telnet max-user")
35 | if 操作.fi加操作(v操作):
36 | v命令 += a数量
37 | else:
38 | v命令.f前面添加(c不)
39 | self.f执行当前模式命令(v命令)
40 |
--------------------------------------------------------------------------------
/网络设备脚本/博达命令行/设备.py:
--------------------------------------------------------------------------------
1 | import cflw代码库py.cflw网络连接 as 连接
2 | from ..命令行接口 import 设备 as 南向设备
3 | from ..思科命令行.常量 import *
4 | class C设备(南向设备.I设备):
5 | """适用于: s3956(v2.2.0B)"""
6 | def __init__(self, a连接, a型号, a版本):
7 | 南向设备.I设备.__init__(self)
8 | if a连接.c连接特性 & 连接.E连接特性.e命令行:
9 | self.m连接 = a连接
10 | self.m连接.fs编码("gb2312")
11 | else:
12 | raise TypeError("a连接 必须是 I连接 类型")
13 | self.m型号 = a型号
14 | self.m版本 = a版本
15 | self.fs自动换页("--More--")
16 | def f输入_结束符(self): #ctrl+c
17 | self.f输入(c结束符)
18 | def f处理显示结果(self, a输出):
19 | v输出 = a输出.replace("\r\n", "\n")
20 | v输出 = 南向设备.f去头尾行(v输出)
21 | return v输出
22 | #动作
23 | def f退出(self):
24 | self.f执行命令("exit")
25 | #模式
26 | def f模式_用户(self):
27 | from . import 用户模式
28 | v模式 = 用户模式.C用户模式(self)
29 | return v模式
30 | def f模式_启动(self):
31 | from . import 启动
32 | v模式 = 启动.C启动(self)
33 | return v模式
34 |
--------------------------------------------------------------------------------
/网络设备脚本/命令行接口/中间系统到中间系统.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 中间系统到中间系统
2 | from . import 模式
3 | from . import 接口
4 | class I进程配置(模式.I模式, 中间系统到中间系统.I进程配置):
5 | def __init__(self, a, a进程号):
6 | 模式.I模式.__init__(self, a)
7 | self.m进程号 = a进程号
8 | def fg进程号(self):
9 | return self.m进程号
10 | class I接口配置(接口.I接口配置基础, 中间系统到中间系统.I接口配置):
11 | def __init__(self, a, a进程号, a接口):
12 | 接口.I接口配置基础.__init__(self, a, a接口)
13 | self.m进程号 = a进程号
14 | def fg进程号(self):
15 | return self.m进程号
16 |
--------------------------------------------------------------------------------
/网络设备脚本/命令行接口/全局显示.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 全局显示
2 | from . import 模式
3 | class I全局显示(模式.C同级模式, 模式.I模式, 全局显示.I全局显示):
4 | def __init__(self, a):
5 | 模式.I模式.__init__(self, a)
--------------------------------------------------------------------------------
/网络设备脚本/命令行接口/全局配置.py:
--------------------------------------------------------------------------------
1 | #内部
2 | from ..基础接口 import 全局配置
3 | from . import 模式
4 | #接口
5 | class I全局配置(模式.I模式, 全局配置.I全局配置):
6 | def __init__(self, a):
7 | 模式.I模式.__init__(self, a)
8 |
--------------------------------------------------------------------------------
/网络设备脚本/命令行接口/前缀列表.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 前缀列表
2 | from . import 模式
3 | class I前缀列表配置(模式.I模式, 前缀列表.I列表配置):
4 | def __init__(self, a):
5 | 模式.I模式.__init__(self, a)
6 |
--------------------------------------------------------------------------------
/网络设备脚本/命令行接口/启动模式.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 启动模式
2 | class I启动模式(启动模式.I模式):
3 | def __init__(self, a):
4 | I模式.__init__(self, a)
--------------------------------------------------------------------------------
/网络设备脚本/命令行接口/地址.py:
--------------------------------------------------------------------------------
1 | import cflw代码库py.cflw网络地址 as 地址
2 | def f解析地址4(a行):
3 | v地址 = 地址.c网络地址4正则.search(a行)
4 | if not v地址:
5 | return None
6 | v掩码 = 地址.c网络地址4正则.search(a行, v地址.endpos)
7 | if not v掩码:
8 | return None
9 | return 地址.S网络地址4.fc地址掩码(v地址[0], v掩码[0])
--------------------------------------------------------------------------------
/网络设备脚本/命令行接口/安全外壳.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 安全外壳
2 | from . import 模式
3 | class I安全外壳配置(模式.I模式, 安全外壳.I安全外壳配置):
4 | def __init__(self, a):
5 | 模式.I模式.__init__(self, a)
6 |
--------------------------------------------------------------------------------
/网络设备脚本/命令行接口/开放最短路径优先.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 开放最短路径优先
2 | from . import 模式
3 | from . import 接口
4 | #===============================================================================
5 | # 基础
6 | #===============================================================================
7 | #===============================================================================
8 | # 配置
9 | #===============================================================================
10 | class I进程配置(模式.I模式, 开放最短路径优先.I进程配置):
11 | def __init__(self, a, a进程号):
12 | 模式.I模式.__init__(self, a)
13 | self.m进程号 = a进程号
14 | def fg模式参数(self):
15 | "返回进程号"
16 | return (self.m进程号,)
17 | def fg进程号(self):
18 | return self.m进程号
19 | class I区域配置(模式.I模式, 开放最短路径优先.I区域配置):
20 | def __init__(self, a, a进程号, a区域号):
21 | 模式.I模式.__init__(self, a)
22 | self.m进程号 = a进程号
23 | self.m区域号 = a区域号
24 | def fg进程号(self):
25 | return self.m进程号
26 | def fg区域号(self):
27 | return self.m区域号
28 | class I接口配置(接口.I接口配置基础, 开放最短路径优先.I接口配置):
29 | def __init__(self, a, a进程号, a接口):
30 | 接口.I接口配置基础.__init__(self, a, a接口)
31 | self.m进程号 = a进程号
32 | def fg进程号(self):
33 | return self.m进程号
34 | class I虚链路配置(模式.I模式, 开放最短路径优先.I虚链路配置):
35 | def __init__(self, a, a进程号, a区域号, a对端):
36 | I模式.__init__(self, a)
37 | self.m区域号 = a区域号
38 | self.m对端 = a对端
39 |
--------------------------------------------------------------------------------
/网络设备脚本/命令行接口/日志.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 日志
2 | from . import 模式
3 | class I日志配置(模式.I模式, 日志.I日志配置):
4 | def __init__(self, a):
5 | 模式.I模式.__init__(self, a)
6 |
--------------------------------------------------------------------------------
/网络设备脚本/命令行接口/时间范围.py:
--------------------------------------------------------------------------------
1 | from . import 模式
2 | from ..基础接口 import 时间范围
3 | class I时间范围配置(模式.I模式, 时间范围.I时间范围配置):
4 | def __init__(self, a):
5 | 模式.I模式.__init__(self, a)
6 |
--------------------------------------------------------------------------------
/网络设备脚本/命令行接口/服务质量.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 策略
2 | from ..基础接口 import 服务质量
3 | from . import 模式
4 | class I流量分类(策略.I匹配, 模式.I模式):
5 | def __init__(self, a, a名称, ai匹配全部):
6 | 模式.I模式.__init__(self, a)
7 | self.m名称 = a名称
8 | self.mi匹配全部 = ai匹配全部
9 | class I流量行为(策略.I设置, 模式.I模式):
10 | def __init__(self, a, a名称):
11 | 模式.I模式.__init__(self, a)
12 | self.m名称 = a名称
13 | class I流量策略(模式.I模式):
14 | def __init__(self, a, a名称):
15 | 模式.I模式.__init__(self, a)
16 | self.m名称 = a名称
17 | def fs绑定(self, a类, a行为, a操作):
18 | raise NotImplementedError()
19 |
--------------------------------------------------------------------------------
/网络设备脚本/命令行接口/生成树.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 生成树
2 | from . import 模式
3 | from . import 接口 as 南向接口
4 | class I多生成树配置(模式.I模式, 生成树.I多生成树配置):
5 | def __init__(self, a):
6 | 模式.I模式.__init__(self, a)
7 | class I接口配置(南向接口.I接口配置基础, 生成树.I接口配置):
8 | def __init__(self, a, a接口):
9 | 南向接口.I接口配置基础.__init__(self, a, a接口)
10 |
--------------------------------------------------------------------------------
/网络设备脚本/命令行接口/用户.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 用户
2 | from . import 模式 as 模式
3 | def f生成服务类型(a字典, a值):
4 | v列表 = []
5 | v类型 = type(a值)
6 | if v类型 in (list, tuple):
7 | for v in a值:
8 | v列表.append(a字典[v])
9 | elif v类型 == int:
10 | for v in range(10):
11 | n = 2 ** v
12 | if a值 & n:
13 | v列表.append(a字典[n])
14 | else:
15 | raise TypeError("无法解析的类型")
16 | return " ".join(v列表)
17 | class I用户配置(模式.I模式, 用户.I用户配置):
18 | def __init__(self, a, a用户名):
19 | 模式.I模式.__init__(self, a)
20 | self.m用户名 = str(a用户名)
--------------------------------------------------------------------------------
/网络设备脚本/命令行接口/用户模式.py:
--------------------------------------------------------------------------------
1 | from . import 模式
2 | from ..基础接口 import 用户模式
3 | from ..基础接口 import 文件
4 | class I用户模式(模式.I模式, 用户模式.I用户模式):
5 | c模式名 = "用户模式"
6 | def __init__(self, a):
7 | 模式.I模式.__init__(self, a)
8 | self.m登录用户名 = ""
9 | self.m登录密码 = ""
10 | self.m提权级别 = 0
11 | self.m提权密码 = ""
12 | #模式
13 | def fg进入命令(self): #用户模式不需要进入命令
14 | return ""
15 | def fg提交命令(self): #用户模式不需要提交命令
16 | return ""
17 | def fg退出命令(self): #用户模式不需要命令
18 | return ""
19 | #动作
20 | def f导出配置(self, a目录 = "", a文件名 = ""):
21 | import pathlib
22 | if not a文件名:
23 | raise ValueError("文件名不能为空")
24 | v全局显示 = self.f模式_全局显示()
25 | v输出 = v全局显示.f显示_当前配置()
26 | v路径 = pathlib.PurePath(a目录) / a文件名
27 | v文件 = open(str(v路径), "w")
28 | v文件.write(v输出)
29 | #其它
30 | def f记住登录(self, a用户名 = None, a密码 = None):
31 | if a用户名:
32 | self.m登录用户名 = str(a用户名)
33 | if a密码:
34 | self.m登录密码 = str(a密码)
35 | def f记住提权(self, a级别 = None, a密码 = None):
36 | if a级别:
37 | self.m提权级别 = a级别
38 | if a密码:
39 | self.m提权密码 = a密码
40 | def f登录自动刷新(self): #建议登录完进入模式后调用
41 | if self.m设备.m访问权限 & 文件.E访问权限.e读:
42 | self.m设备.f刷新()
43 | self.m设备.f输入_结束符()
44 | self.m设备.f输入_回车(-1, 5)
--------------------------------------------------------------------------------
/网络设备脚本/命令行接口/登录.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 登录
2 | from . import 模式
3 | class I登录配置(模式.I模式, 登录.I登录配置):
4 | def __init__(self, a):
5 | 模式.I模式.__init__(self, a)
6 | def f生成范围(a登录, a范围):
7 | return " ".join(f生成范围元组(a登录, a范围))
8 | def f生成范围元组(a登录, a范围):
9 | if a登录 == 登录.E登录方式.e控制台:
10 | return (0,)
11 | elif a登录 == 登录.E登录方式.e虚拟终端:
12 | v范围类型 = type(a范围)
13 | if v范围类型 == int:
14 | return (a范围,)
15 | elif v范围类型 == range:
16 | return (a范围.start, a范围.stop - 1)
17 | else:
18 | return (0, 4)
19 | else:
20 | return (0,)
21 |
--------------------------------------------------------------------------------
/网络设备脚本/命令行接口/简单网络管理协议.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 简单网络管理协议
2 | from . import 模式
3 | class I代理配置(模式.I模式, 简单网络管理协议.I代理配置):
4 | def __init__(self, a):
5 | 模式.I模式.__init__(self, a)
6 | class I陷阱配置(模式.I模式, 简单网络管理协议.I陷阱配置):
7 | def __init__(self, a):
8 | 模式.I模式.__init__(self, a)
9 |
--------------------------------------------------------------------------------
/网络设备脚本/命令行接口/网络时间协议.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 网络时间协议
2 | from . import 模式
3 | class I服务器配置(模式.I模式, 网络时间协议.I服务器配置):
4 | def __init__(self, a):
5 | 模式.I模式.__init__(self, a)
6 | class I客户端配置(模式.I模式, 网络时间协议.I客户端配置):
7 | def __init__(self, a):
8 | 模式.I模式.__init__(self, a)
9 | class I远端配置(模式.I模式, 网络时间协议.I远端配置):
10 | def __init__(self, a, a地址):
11 | 模式.I模式.__init__(self, a)
12 | self.m地址 = a地址
13 | def fg地址(self):
14 | return self.m地址
--------------------------------------------------------------------------------
/网络设备脚本/命令行接口/网络终端.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 网络终端
2 | from . import 模式
3 | class I网络终端配置(模式.I模式, 网络终端.I网络终端配置):
4 | def __init__(self, a):
5 | 模式.I模式.__init__(self, a)
6 |
--------------------------------------------------------------------------------
/网络设备脚本/命令行接口/虚拟局域网.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 虚拟局域网
2 | from . import 命令
3 | from . import 模式
4 | from . import 接口
5 | #===============================================================================
6 | # 基础
7 | #===============================================================================
8 | c虚拟局域网范围 = range(1, 4095) #可用范围
9 | def f生成一个(a虚拟局域网):
10 | v类型 = type(a虚拟局域网)
11 | if v类型 == str:
12 | if not a虚拟局域网.isdigit():
13 | raise ValueError("a虚拟局域网 必须是数字")
14 | v数字 = int(a虚拟局域网)
15 | if not fi范围内(v数字):
16 | raise ValueError("a虚拟局域网 超出范围")
17 | return str(v数字)
18 | elif v类型 == int:
19 | if not fi范围内(a虚拟局域网):
20 | raise ValueError("a虚拟局域网 超出范围")
21 | return str(a虚拟局域网)
22 | else:
23 | raise TypeError("无法识别的类型")
24 | def fi范围内(a虚拟局域网: int):
25 | return a虚拟局域网 in c虚拟局域网范围
26 | #===============================================================================
27 | # 模式
28 | #===============================================================================
29 | class I虚拟局域网配置(模式.I模式):
30 | def __init__(self, a, a编号):
31 | 模式.I模式.__init__(self, a)
32 | self.m编号 = a编号
33 | def fg模式参数(self):
34 | return (self.m编号,)
35 | def fg进入命令(self):
36 | return 命令.C命令("vlan") + self.fg模式参数()
37 | class I接口配置(接口.I接口配置基础):
38 | def __init__(self, a, a接口):
39 | 接口.I接口配置基础.__init__(self, a, a接口)
40 |
--------------------------------------------------------------------------------
/网络设备脚本/命令行接口/虚拟路由转发.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 虚拟路由转发
2 | from . import 模式
3 | from . import 接口
4 | class I资源配置(模式.I模式, 虚拟路由转发.I资源配置):
5 | def __init__(self, a, a名称):
6 | 模式.I模式.__init__(self, a)
7 | self.m名称 = a名称
8 | def fg名称(self):
9 | return self.m名称
10 | class I接口配置(接口.I接口配置基础, 虚拟路由转发.I接口配置):
11 | def __init__(self, a, a接口):
12 | 接口.I接口配置基础.__init__(self, a, a接口)
--------------------------------------------------------------------------------
/网络设备脚本/命令行接口/路由信息协议.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 路由信息协议
2 | from . import 模式
3 | from . import 接口配置
4 | class I路由信息协议(模式.I模式, 路由信息协议.I路由信息协议):
5 | def __init__(self, a):
6 | 模式.I模式.__init__(self, a)
7 | class I路由信息协议接口(南向接口.I接口配置基础, 路由信息协议.I路由信息协议接口):
8 | def __init__(self, a, a接口):
9 | 南向接口.I接口配置基础.__init__(self, a, a接口)
10 |
--------------------------------------------------------------------------------
/网络设备脚本/命令行接口/路由映射.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 路由映射
2 | from . import 模式
3 | class I路由映射组(路由映射.I路由映射组, 模式.I模式):
4 | def __init__(self, a, a名称):
5 | 模式.I模式.__init__(self, a)
6 | self.m名称 = a名称
7 | class I路由映射节点(路由映射.I路由映射节点, 模式.I模式):
8 | def __init__(self, a, a序号, a动作):
9 | 模式.I模式.__init__(self, a)
10 | self.m名称 = a.m名称
11 | self.m动作 = a动作
12 | self.m序号 = a序号
--------------------------------------------------------------------------------
/网络设备脚本/命令行接口/边界网关协议.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 边界网关协议
2 | from . import 模式
3 | class I进程配置(模式.I模式, 边界网关协议.I进程配置):
4 | def __init__(self, a, a自治系统号):
5 | 模式.I模式.__init__(self, a)
6 | self.m自治系统号 = int(a自治系统号)
7 | def fg模式参数(self):
8 | "返回自治系统号"
9 | return (self.m自治系统号,)
10 | def fg自治系统号(self):
11 | return self.m自治系统号
12 | class I地址族配置(模式.I模式, 边界网关协议.I地址族配置):
13 | def __init__(self, a, *aa参数):
14 | 模式.I模式.__init__(self, a)
15 | self.ma参数 = aa参数
16 | def fg模式参数(self):
17 | return self.ma参数
18 | class I对等体配置(模式.I模式, 边界网关协议.I对等体配置):
19 | def __init__(self, a, a对等体):
20 | 模式.I模式.__init__(self, a)
21 | self.m对等体 = a对等体
22 | def __str__(self):
23 | return str(self.m对等体)
24 | def fg对等体名(self):
25 | return str(self.m对等体)
--------------------------------------------------------------------------------
/网络设备脚本/命令行接口/连接.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 连接
2 | class I命令行连接(连接.I命令行连接):
3 | def __init__(self, a模式):
4 | 连接.I命令行连接.__init__(self, a模式)
5 | def fg进入命令(self):
6 | raise NotImplementedError()
7 | def f连接(self):
8 | v命令 = self.fg进入命令()
9 | self.m模式.f执行当前模式命令(v命令)
--------------------------------------------------------------------------------
/网络设备脚本/命令行接口/链路层发现协议.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 链路层发现协议
2 | from . import 模式
3 | from . import 接口
4 | class I进程配置(模式.I模式, 链路层发现协议.I进程配置):
5 | def __init__(self, a):
6 | 模式.I模式.__init__(self, a)
7 | class I接口配置(接口.I接口配置基础, 链路层发现协议.I接口配置):
8 | def __init__(self, a, a接口):
9 | 接口.I接口配置基础.__init__(self, a, a接口)
--------------------------------------------------------------------------------
/网络设备脚本/命令行接口/静态路由.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 静态路由
2 | from . import 模式
3 | class I静态路由配置(模式.I模式, 静态路由.I静态路由配置):
4 | def __init__(self, a):
5 | 模式.I模式.__init__(self, a)
--------------------------------------------------------------------------------
/网络设备脚本/基础接口/全局显示.py:
--------------------------------------------------------------------------------
1 | class I全局显示:
2 | #系统
3 | def f模式_设备(self): #系统&硬件信息
4 | raise NotImplementedError()
5 | def f模式_日志(self):
6 | raise NotImplementedError()
7 | def f模式_时间(self):
8 | raise NotImplementedError()
9 | #显示配置
10 | def f显示_启动配置(self):
11 | raise NotImplementedError()
12 | def f显示_当前配置(self):
13 | raise NotImplementedError()
14 | #显示全局表格
15 | def f显示_路由表4(self):
16 | raise NotImplementedError()
17 | def f显示_默认路由4(self):
18 | raise NotImplementedError()
19 | def f显示_接口表(self):
20 | raise NotImplementedError()
21 | def f显示_网络接口表4(self):
22 | raise NotImplementedError()
23 | def f显示_网络接口表6(self):
24 | raise NotImplementedError()
25 | def f显示_接口详细(self):
26 | raise NotImplementedError()
27 | def f显示_网络接口详细4(self):
28 | raise NotImplementedError()
29 | def f显示_网络接口详细6(self):
30 | raise NotImplementedError()
31 | def f显示_物理地址表(self): #mac表
32 | raise NotImplementedError()
33 | def f显示_地址解析表(self): #arp表
34 | raise NotImplementedError()
--------------------------------------------------------------------------------
/网络设备脚本/基础接口/前缀列表.py:
--------------------------------------------------------------------------------
1 | class S规则:
2 | def __init__(self, **a):
3 | self.m序号 = None
4 | self.m允许 = True
5 | self.m网络号 = None
6 | self.m最小长度 = None
7 | self.m最大长度 = None
8 | self.f更新(**a)
9 | def __str__(self):
10 | v = ""
11 | #序号
12 | if self.m序号 >= 0:
13 | v += "序号%d, " % (self.m序号,)
14 | #允许
15 | if self.m允许:
16 | v += "允许, "
17 | else:
18 | v += "拒绝, "
19 | #地址
20 | if self.m网络号:
21 | v += "网络号%s, " % (self.m网络号,)
22 | if self.m最小长度:
23 | v += "最小%s, " % (self.m最小长度,)
24 | if self.m最大长度:
25 | v += "最大%s, " % (self.m最大长度,)
26 | return v
27 | def f更新(self, **a):
28 | for k, v in S规则.ca更新函数.items():
29 | if k in a:
30 | v(self, a[k])
31 | def fs序号(self, a):
32 | self.m序号 = a
33 | def fs允许(self, a):
34 | self.m允许 = a
35 | def fs网络号(self, a):
36 | self.m网络号 = a
37 | def fs最小长度(self, a):
38 | self.m最小长度 = a
39 | def fs最大长度(self, a):
40 | self.m最大长度 = a
41 | ca更新函数 = {
42 | "a允许": fs允许,
43 | "a网络号": fs网络号,
44 | "a最小长度": fs最小长度,
45 | "a最大长度": fs最大长度,
46 | }
47 | class I列表配置:
48 | c模式名 = "前缀列表配置模式"
49 | def fs规则(self, a序号, a规则, a操作):
50 | raise NotImplementedError()
51 | def fe规则(self):
52 | raise NotImplementedError()
53 | def fg规则(self, a序号):
54 | raise NotImplementedError()
55 | def f应用到(self, a):
56 | raise NotImplementedError()
57 |
--------------------------------------------------------------------------------
/网络设备脚本/基础接口/动态主机配置协议.py:
--------------------------------------------------------------------------------
1 | class I动态主机配置协议地址池(I模式):
2 | def __init__(self, a, a名称):
3 | I模式.__init__(self, a)
4 | self.m名称 = a名称
5 | def fs网络范围(self, a网络号, a掩码):
6 | raise NotImplementedError()
7 | def fs默认网关(self, a网关):
8 | raise NotImplementedError()
9 | def fs租期(self, a时间):
10 | raise NotImplementedError()
11 | def fs域名服务器(self, a地址):
12 | raise NotImplementedError()
13 | class I动态主机配置协议(I模式):
14 | def __init__(self, a):
15 | I模式.__init__(self, a)
16 | def f显示_已分配地址(self):
17 | raise NotImplementedError()
18 | def f模式_地址池(self, a名称):
19 | raise NotImplementedError()
20 | def fs开关(self, a操作 = E操作.e设置):
21 | raise NotImplementedError()
22 |
--------------------------------------------------------------------------------
/网络设备脚本/基础接口/区域.py:
--------------------------------------------------------------------------------
1 | import enum
2 | class E类型(enum.IntEnum):
3 | e二层 = enum.auto()
4 | e三层 = enum.auto()
5 | e虚拟 = enum.auto()
6 | class I区域显示:
7 | def fg名称(self):
8 | """当前区域名称"""
9 | raise NotImplementedError()
10 | def fg接口(self):
11 | """该区域有哪些接口"""
12 | raise NotImplementedError()
13 | class I区域配置: #表示一个接口区域
14 | def fs类型(self, a类型, a操作):
15 | """当前区域类型"""
16 | raise NotImplementedError()
17 | def fs接口(self, a接口, a操作):
18 | """区域包含哪些接口"""
19 | raise NotImplementedError()
--------------------------------------------------------------------------------
/网络设备脚本/基础接口/可扩展虚拟局域网.py:
--------------------------------------------------------------------------------
1 | class I接口配置:
2 | c模式名 = "网络虚拟边缘接口配置模式"
3 | def fs源地址(self, a地址, a操作):
4 | raise NotImplementedError()
5 | def fs目的地址(self, a网络标识, a地址, a操作):
6 | raise NotImplementedError()
--------------------------------------------------------------------------------
/网络设备脚本/基础接口/启动模式.py:
--------------------------------------------------------------------------------
1 | class I启动模式:
2 | def f登录(self, a密码 = "", a超时 = 60):
3 | "尝试进入设备启动模式,有密码输密码,超时抛异常"
4 | raise NotImplementedError()
5 | def f更新系统(self, a文件):
6 | raise NotImplementedError()
7 | def f清除配置(self):
8 | raise NotImplementedError()
9 | def f重新启动(self):
10 | raise NotImplementedError()
11 |
--------------------------------------------------------------------------------
/网络设备脚本/基础接口/增强内部网关路由协议.py:
--------------------------------------------------------------------------------
1 | class I增强内部网关路由协议(I模式):
2 | def __init__(self, a, a自制系统号):
3 | I模式.__init__(self, a)
4 | self.m自制系统号 = a自制系统号
5 | #显示
6 | def f显示_路由表(self):
7 | raise NotImplementedError()
8 | def f显示_邻居表(self):
9 | raise NotImplementedError()
10 | #操作
11 | def fs开关(self, a操作 = E操作.e设置):
12 | raise NotImplementedError()
13 | def fs路由器号(self, a路由器号):
14 | raise NotImplementedError()
15 | def fs通告网络(self, a网络号, a操作 = E操作.e设置):
16 | raise NotImplementedError()
17 | def fs通告接口(self, a接口, a操作 = E操作.e设置):
18 | raise NotImplementedError()
19 | def fs自动汇总(self, a操作 = E操作.e设置):
20 | raise NotImplementedError()
21 | #度量值
22 | def fs带宽(self, a带宽, a操作 = E操作.e设置):
23 | raise NotImplementedError()
24 | def fs延迟(self, a延迟, a操作 = E操作.e设置):
25 | raise NotImplementedError()
26 | class I增强内部网关路由协议接口(I接口配置基础):
27 | def __init__(self, a, a接口, a自制系统号):
28 | I接口配置基础.__init__(self, a, a接口)
29 | self.m自制系统号 = a自制系统号
30 | def fs通告接口(self, a操作 = E操作.e设置):
31 | raise NotImplementedError()
32 | def fs被动(self, a操作 = E操作.e设置):
33 | raise NotImplementedError()
34 | def fs水平分割(self, a操作 = E操作.e设置):
35 | raise NotImplementedError()
36 | def fs汇总(self, a网络号, a操作 = E操作.e设置):
37 | raise NotImplementedError()
38 |
--------------------------------------------------------------------------------
/网络设备脚本/基础接口/多协议标签交换.py:
--------------------------------------------------------------------------------
1 | class I多协议标签交换(I模式):
2 | def __init__(self, a):
3 | I模式.__init__(self, a)
4 |
--------------------------------------------------------------------------------
/网络设备脚本/基础接口/安全外壳.py:
--------------------------------------------------------------------------------
1 | c密钥长度 = 1024
2 | class I安全外壳配置:
3 | "SSH"
4 | c模式名 = "安全外壳配置模式"
5 | def fs开关(self, a操作):
6 | raise NotImplementedError()
7 | def f生成密钥(self, a长度, a操作):
8 | raise NotImplementedError()
9 | def fs端口号(self, a端口号, a操作):
10 | raise NotImplementedError()
11 | def fs源接口(self, a接口, a操作):
12 | raise NotImplementedError()
13 | def fs版本(self, a版本, a操作):
14 | raise NotImplementedError()
15 | def fs连接数(self, a数量, a操作):
16 | raise NotImplementedError()
17 | def fs认证重试(self, a次数, a操作):
18 | raise NotImplementedError()
19 | def fs认证超时(self, a时间, a操作):
20 | raise NotImplementedError()
21 | def fs访问列表(self, a访问列表, a操作):
22 | raise NotImplementedError()
23 | class I安全外壳显示:
24 | def fg开关(self):
25 | """ssh服务是否开启"""
26 | raise NotImplementedError()
27 | def fg端口号(self):
28 | """返回ssh端口号"""
29 | raise NotImplementedError()
30 | def fg版本(self):
31 | """返回ssh版本号(1或2)"""
32 | raise NotImplementedError()
33 | def fg认证重试(self):
34 | """返回ssh认证次数"""
35 | raise NotImplementedError()
36 | def fg认证超时(self):
37 | """返回ssh认证时间. 单位:秒"""
38 | raise NotImplementedError()
39 | def fg访问列表(self): #返回的值应能直接传入 fs访问列表、f模式_访问控制列表
40 | """返回ssh绑定的acl"""
41 | raise NotImplementedError()
42 |
--------------------------------------------------------------------------------
/网络设备脚本/基础接口/密码.py:
--------------------------------------------------------------------------------
1 | class I密码助手:
2 | @staticmethod
3 | def f生成密码(a密码, a加密级别):
4 | raise NotImplementedError()
5 | @staticmethod
6 | def f提取密码(a字符串):
7 | raise NotImplementedError()
8 |
--------------------------------------------------------------------------------
/网络设备脚本/基础接口/异常.py:
--------------------------------------------------------------------------------
1 | class X设备(RuntimeError):
2 | "所有设备异常的基类"
3 | def __init__(self, a消息):
4 | self.m消息 = str(a消息)
5 | def __str__(self):
6 | return self.m消息
7 | class X命令(X设备):
8 | """无法解析的命令,一般是命令写错"""
9 | def __init__(self, a消息):
10 | X设备.__init__(self, a消息)
11 | class X执行(X设备):
12 | "无法正确执行的命令"
13 | def __init__(self, a消息):
14 | X设备.__init__(self, a消息)
15 | class X模式(X设备):
16 | "在错误的模式执行命令"
17 | def __init__(self, a消息):
18 | if hasattr(a消息, "c模式名"):
19 | X设备.__init__(self, "无法在%s执行命令" % (a消息.c模式名,))
20 | elif type(a消息) == str:
21 | X设备.__init__(self, a消息)
22 | else:
23 | X设备.__init__(self, "无法执行命令")
24 | class X输出(X设备):
25 | "无法解析设备输出信息"
26 | def __init__(self, a消息):
27 | X设备.__init__(self, a消息)
28 | class X操作(X设备):
29 | """操作无效
30 | 设备不支持的操作
31 | 设备没有可以实现相关操作的命令"""
32 | def __init__(self, a操作, a消息 = ""):
33 | X设备.__init__(self, "操作 %s 无效: %s" % (a操作, a消息))
34 | self.m操作 = a操作
35 | class X接口格式(X设备):
36 | """设备不支持接口格式,需要展开"""
37 | def __init__(self, a接口):
38 | X设备.__init__(self, "不支持接口格式 %s" % (a接口,))
39 | class X登录(X设备):
40 | """登录失败"""
41 | def __init__(self, a消息):
42 | X设备.__init__(self, a消息)
43 | class X连接(X设备):
44 | """连接失败"""
45 | def __init__(self, a消息):
46 | X设备.__init__(self, a消息)
--------------------------------------------------------------------------------
/网络设备脚本/基础接口/数据结构.py:
--------------------------------------------------------------------------------
1 | class I网络协议地址池(I模式):
2 | def __init__(self, a, a名称):
3 | I模式.__init__(self, a)
4 | self.m名称 = a名称
5 | def fs地址范围(self, a开始, a结束 = None):
6 | raise NotImplementedError()
7 | def fs默认网关(self, a网关):
8 | raise NotImplementedError()
9 |
--------------------------------------------------------------------------------
/网络设备脚本/基础接口/文件.py:
--------------------------------------------------------------------------------
1 | import enum
2 | #===============================================================================
3 | # 读写权限
4 | #===============================================================================
5 | class E访问权限(enum.IntEnum):
6 | e读 = 1
7 | e只读 = 1
8 | e写 = 2
9 | e只写 = 2
10 | e读写 = 3
11 | def fi含读(a权限):
12 | if a权限 in E访问权限:
13 | return bool(a权限 & E访问权限.e只读)
14 | else:
15 | return False
16 | def fi含写(a权限):
17 | if a权限 in E访问权限:
18 | return bool(a权限 & E访问权限.e只写)
19 | else:
20 | return False
--------------------------------------------------------------------------------
/网络设备脚本/基础接口/无线局域网.py:
--------------------------------------------------------------------------------
1 | import enum
2 | import cflw代码库py.cflw字符串 as 字符串
3 | class E模式(enum.IntEnum):
4 | """802.11标准"""
5 | #单模式
6 | a = 0x0001
7 | b = 0x0002
8 | g = 0x0004
9 | n = 0x0008
10 | ac = 0x0010
11 | ax = 0x0020
12 | #混合
13 | bg = b | g
14 | bgn = b | g | n
15 | class S主机表项:
16 | def __init__(self, a名称, a物理地址, a接口 = None):
17 | self.m名称 = a名称
18 | self.m物理地址 = a物理地址
19 | self.m接口 = a接口
20 | def __str__(self):
21 | return 字符串.ft字符串(self.m名称, self.m物理地址, self.m接口)
22 | class I接口配置:
23 | c模式名 = "无线局域网无线电接口配置模式"
24 | def f显示_主机表(self):
25 | raise NotImplementedError()
26 | def fs开关(self, a操作):
27 | "是否发射信号"
28 | raise NotImplementedError()
29 | def fs服务集标识广播(self, a操作):
30 | "是否广播ssid"
31 | raise NotImplementedError()
32 | def fs服务集标识号(self, a号, a操作):
33 | "ssid名称"
34 | raise NotImplementedError()
35 | class I接入点配置:
36 | c模式名 = "无线局域网接入点配置模式"
37 | def f显示_主机表(self):
38 | raise NotImplementedError()
39 | class I控制器配置:
40 | c模式名 = "无线局域网接入控制器配置模式"
41 | def f显示_支持型号表(self):
42 | raise NotImplementedError()
43 |
--------------------------------------------------------------------------------
/网络设备脚本/基础接口/日志.py:
--------------------------------------------------------------------------------
1 | import enum
2 | class E严重级别(enum.IntEnum):
3 | e紧急 = 0
4 | e警报 = 1
5 | e关键 = 2
6 | e错误 = 3
7 | e警告 = 4
8 | e通知 = 5
9 | e信息 = 6
10 | e调试 = 7
11 | class I日志配置:
12 | """全局日志配置"""
13 | c模式名 = "日志配置模式"
14 | #显示
15 | def f显示_日志(self, a数量, a升序):
16 | """显示日志内容"""
17 | raise NotImplementedError()
18 | #操作
19 | def fs开关(self, a操作):
20 | """全局日志开关,开启后设备才会收集日志"""
21 | raise NotImplementedError()
22 | def fs缓冲大小(self, a字节, a操作):
23 | """设备最多可记录的日志字节数"""
24 | raise NotImplementedError()
25 | def fs服务器开关(self, a操作):
26 | raise NotImplementedError()
27 | def fs服务器地址(self, a地址, a操作):
28 | raise NotImplementedError()
29 | def fs服务器严重级别(self, a级别, a操作):
30 | raise NotImplementedError()
--------------------------------------------------------------------------------
/网络设备脚本/基础接口/时间范围.py:
--------------------------------------------------------------------------------
1 | import enum
2 | class E日子(enum.IntEnum):
3 | e一 = 0
4 | e二 = 1
5 | e三 = 2
6 | e四 = 3
7 | e五 = 4
8 | e六 = 5
9 | e日 = 6
10 | e工作日 = 8
11 | e周末 = 9
12 | e每天 = 7
13 | class S时间范围:
14 | def __init__(self, a开始时间, a结束时间):
15 | self.m绝对 = True
16 | self.m开始时间 = a开始时间
17 | self.m结束时间 = a结束时间
18 | @staticmethod
19 | def fc定期(a日子, a开始时间, a结束时间):
20 | """
21 | a日子: E日子\n
22 | a开始时间: str, tuple(时, 分)\n
23 | a结束时间: str, tuple(时, 分)
24 | """
25 | v = S时间范围(a开始时间, a结束时间)
26 | v.m绝对 = False
27 | v.m日子 = a日子
28 | return v
29 | @staticmethod
30 | def fc绝对(a开始时间, a结束时间):
31 | v = S时间范围(a开始时间, a结束时间)
32 | return v
33 | class I时间范围配置:
34 | def fs值(self, a时间范围, a操作):
35 | raise NotImplementedError()
36 |
--------------------------------------------------------------------------------
/网络设备脚本/基础接口/服务质量.py:
--------------------------------------------------------------------------------
1 | from . import 策略
2 | class I流量分类(策略.I匹配):
3 | pass
4 | class I流量行为(策略.I设置):
5 | def fs允许(self, a允许: bool):
6 | raise NotImplementedError()
7 | class I助手:
8 | """服务质量助手包含设备和策略名称,在设备中自动绑定类和行为,统一不同设备的操作"""
9 | def fg分类名称(self):
10 | raise NotImplementedError()
11 | def fg行为名称(self):
12 | raise NotImplementedError()
13 | def fg策略名称(self):
14 | raise NotImplementedError()
15 |
--------------------------------------------------------------------------------
/网络设备脚本/基础接口/热备份路由协议.py:
--------------------------------------------------------------------------------
1 | class I冗余路由:
2 | c模式名 = "热备份路由协议配置模式"
3 | #显示
4 | def fg组号(self):
5 | raise NotImplementedError()
6 | #配置
7 | def fs版本(self, a版本, a操作):
8 | raise NotImplementedError()
9 | def fs网络地址4(self, a地址, a操作):
10 | raise NotImplementedError()
11 | def fs抢占(self, a操作):
12 | raise NotImplementedError()
13 | def fs优先级(self, a优先级, a操作):
14 | raise NotImplementedError()
15 | def fs问候时间(self, a秒, a操作):
16 | raise NotImplementedError()
17 | def fs维持时间(self, a秒, a操作):
18 | raise NotImplementedError()
19 | def fs跟踪(self, a接口, a优先级, a操作):
20 | raise NotImplementedError()
21 | def fs认证(self, a密码, a操作):
22 | raise NotImplementedError()
--------------------------------------------------------------------------------
/网络设备脚本/基础接口/用户.py:
--------------------------------------------------------------------------------
1 | import enum
2 | import cflw代码库py.cflw工具_运算 as 运算
3 | #===============================================================================
4 | # 枚举
5 | #===============================================================================
6 | class E服务类型(enum.IntEnum):
7 | e无 = 0x00
8 | e终端 = 0x01
9 | e网络终端 = 0x02
10 | e安全外壳 = 0x04
11 | e网页 = 0x08
12 | e全部 = 0xff
13 | def f解析服务类型(a):
14 | """把参数转换成 E服务类型 列表"""
15 | v类型 = type(a)
16 | if v类型 == int:
17 | return 运算.f位拆分(a)
18 | elif v类型 in (tuple, list):
19 | return a
20 | else:
21 | raise ValueError("无法解析的类型")
22 | class E用户权限(enum.IntEnum):
23 | e最低 = 0
24 | e最高 = 1
25 | #===============================================================================
26 | # 模式
27 | #===============================================================================
28 | class I用户配置:
29 | c模式名 = "用户配置模式"
30 | def fs密码(self, a密码, a操作):
31 | raise NotImplementedError()
32 | def fs权限(self, a权限, a操作):
33 | raise NotImplementedError()
34 | def fs服务类型(self, a服务类型, a操作):
35 | raise NotImplementedError()
36 |
--------------------------------------------------------------------------------
/网络设备脚本/基础接口/用户模式.py:
--------------------------------------------------------------------------------
1 | class I用户模式:
2 | def f模式_全局配置(self):
3 | raise NotImplementedError()
4 | def f模式_全局显示(self):
5 | raise NotImplementedError()
6 | #连接
7 | def f连接_网络终端(self, a地址, **a参数):
8 | raise NotImplementedError()
9 | def f连接_安全外壳(self, a地址, **a参数):
10 | raise NotImplementedError()
11 | def f连接_集群(self, a名称):
12 | raise NotImplementedError()
13 | #动作
14 | def f登录(self, a用户名, a密码):
15 | raise NotImplementedError()
16 | def f提升权限(self, a密码, a级别):
17 | raise NotImplementedError()
18 | def f重新启动(self):
19 | "该函数只重启设备, 不保存配置. 要在重启前保存配置应调用 f保存配置"
20 | raise NotImplementedError()
21 | def f保存配置(self):
22 | "把当前配置保存到设备"
23 | raise NotImplementedError()
24 | def f导出配置(self, a目录 = "", a文件名 = ""):
25 | "把当前配置保存到本地电脑"
26 | raise NotImplementedError()
27 | def f清除配置(self, a重启 = False):
28 | "清除启动配置, 重启生效"
29 | raise NotImplementedError()
30 | def fs终端监视(self, a开关):
31 | "terminal monitor"
32 | raise NotImplementedError()
33 |
--------------------------------------------------------------------------------
/网络设备脚本/基础接口/硬件.py:
--------------------------------------------------------------------------------
1 | import enum
2 | #===============================================================================
3 | # 风扇
4 | #===============================================================================
5 | class E风扇方向(enum.Enum):
6 | e从前到后 = enum.auto()
7 | e从后到前 = enum.auto()
8 | #===============================================================================
9 | # 电源
10 | #===============================================================================
11 | class E电源类型(enum.Enum):
12 | e直流 = enum.auto()
13 | e交流 = enum.auto()
14 | ca电源类型 = {
15 | "DC": E电源类型.e直流,
16 | "AC": E电源类型.e交流,
17 | }
--------------------------------------------------------------------------------
/网络设备脚本/基础接口/端口安全.py:
--------------------------------------------------------------------------------
1 | import enum
2 | class E端口安全动作(enum.IntEnum):
3 | e丢弃包 = 12
4 | e丢弃并警告 = 11
5 | e关闭端口 = 0
6 | e暂时关闭端口 = 1
7 | class I端口安全(I模式):
8 | def __init__(self, a):
9 | I模式.__init__(self, a)
10 | def fs开关(self, a操作 = E操作.e设置):
11 | raise NotImplementedError()
12 | def f模式_接口(self, a接口):
13 | raise NotImplementedError()
14 | def f应用到接口(self, a接口):
15 | raise NotImplementedError()
16 | def fs自动恢复时间(self, a时间):
17 | raise NotImplementedError()
18 | def fs地址老化时间(self, a时间):
19 | raise NotImplementedError()
20 | class I端口安全接口(I接口配置基础):
21 | def __init__(self, a, a接口):
22 | I接口配置基础.__init__(self, a, a接口)
23 | def fs开关(self, a操作 = E操作.e设置):
24 | raise NotImplementedError()
25 | def fs地址(self, a地址, a操作 = E操作.e设置):
26 | raise NotImplementedError()
27 | def fs最大地址数(self, a数量, a操作 = E操作.e设置):
28 | raise NotImplementedError()
29 | def fs自动恢复时间(self, a时间, a操作 = E操作.e设置):
30 | raise NotImplementedError()
31 | def fs地址老化时间(self, a时间, a操作 = E操作.e设置):
32 | raise NotImplementedError()
33 | def fs端口安全动作(self, a动作, a操作 = E操作.e设置):
34 | raise NotImplementedError()
35 |
--------------------------------------------------------------------------------
/网络设备脚本/基础接口/简单网络管理协议.py:
--------------------------------------------------------------------------------
1 | class I代理配置:
2 | def fs开关(self, a操作 = None):
3 | raise NotImplementedError()
4 | def fs团体字符串(self, a字符串, a权限 = None, a操作 = None):
5 | raise NotImplementedError()
6 | class I陷阱配置:
7 | def fs开关(self, a操作 = None):
8 | raise NotImplementedError()
9 | def fs服务器(self, a地址, a操作 = None):
10 | """主动往服务器发消息"""
11 | raise NotImplementedError()
12 | def fs源(self, a源, a操作 = None):
13 | """发包源地址"""
14 | raise NotImplementedError()
--------------------------------------------------------------------------------
/网络设备脚本/基础接口/类型.py:
--------------------------------------------------------------------------------
1 | import cflw代码库py.cflw字符串 as 字符串
2 | #===============================================================================
3 | # 内置类型
4 | #===============================================================================
5 | def f解析范围(a范围):
6 | v类型 = type(a范围)
7 | if v类型 == range:
8 | return a范围
9 | elif v类型 == int:
10 | return range(a范围, a范围 + 1)
11 | elif v类型 == str:
12 | return 字符串.ft范围(a范围)
13 | else:
14 | raise TypeError("无法解析的类型")
--------------------------------------------------------------------------------
/网络设备脚本/基础接口/网络安全性.py:
--------------------------------------------------------------------------------
1 | import enum
2 | class E网络安全性工作模式(enum.IntEnum):
3 | e默认 = 0
4 | e传输 = 1
5 | e隧道 = 2
6 | class I网络密钥交换策略(I模式):
7 | def __init__(self, a):
8 | I模式.__init__(self, a)
9 | def fs散列方式(self, a):
10 | raise NotImplementedError()
11 | def fs加密方式(self, a):
12 | raise NotImplementedError()
13 | def fs认证方式(self, a):
14 | raise NotImplementedError()
15 | class I网络密钥交换密钥链(I模式): #思科ike keyring,华三ike keychain
16 | def __init__(self, a):
17 | I模式.__init__(self, a)
18 | def fs预共享密钥(self, a地址, a密码, a操作 = E操作.e设置):
19 | raise NotImplementedError()
20 | class I网络安全性变更集(I模式): #ipsec transform set
21 | def __init__(self, a):
22 | I模式.__init__(self, a)
23 | def fs加密方式(self, a):
24 | raise NotImplementedError()
25 | def fs认证方式(self, a):
26 | raise NotImplementedError()
27 | def fs变更方式(self, a):
28 | raise NotImplementedError()
29 | def fs压缩方式(self, a):
30 | raise NotImplementedError()
31 | def fs工作模式(self, a):
32 | raise NotImplementedError()
33 | class I网络安全性配置(I模式):
34 | def __init__(self, a):
35 | I模式.__init__(self, a)
36 |
--------------------------------------------------------------------------------
/网络设备脚本/基础接口/网络时间协议.py:
--------------------------------------------------------------------------------
1 | class I服务器配置:
2 | def fs开关(self, a操作):
3 | raise NotImplementedError()
4 | def fs层数(self, a层数, a操作):
5 | raise NotImplementedError()
6 | def fs版本(self, a版本, a操作):
7 | raise NotImplementedError()
8 | def fs源地址(self, a地址, a操作):
9 | raise NotImplementedError()
10 | def fs发送广播(self, a操作):
11 | raise NotImplementedError()
12 | class I客户端配置:
13 | def f模式_远端(self, a地址, a端, a操作):
14 | """指定服务器"""
15 | raise NotImplementedError()
16 | def fs开关(self, a操作):
17 | raise NotImplementedError()
18 | def fs接收广播(self, a操作):
19 | raise NotImplementedError()
20 | def f显示_同步信息(self):
21 | raise NotImplementedError()
22 | class I远端配置:
23 | def fg地址(self):
24 | raise NotImplementedError()
25 | def fs版本(self, a版本, a操作):
26 | raise NotImplementedError()
27 | def fs优先(self, a操作):
28 | raise NotImplementedError()
29 | def fs认证(self, a钥匙, a操作):
30 | raise NotImplementedError()
31 | def fs源(self, a源, a操作):
32 | raise NotImplementedError()
--------------------------------------------------------------------------------
/网络设备脚本/基础接口/网络终端.py:
--------------------------------------------------------------------------------
1 | class I网络终端配置:
2 | "Telnet"
3 | c模式名 = "网络终端配置模式"
4 | def fs开关(self, a操作):
5 | raise NotImplementedError()
6 | def fs端口号(self, a端口号, a操作):
7 | raise NotImplementedError()
8 | def fs源接口(self, a接口, a操作):
9 | raise NotImplementedError()
10 | def fs连接数(self, a数量, a操作):
11 | raise NotImplementedError()
12 |
--------------------------------------------------------------------------------
/网络设备脚本/基础接口/虚拟局域网.py:
--------------------------------------------------------------------------------
1 | import enum
2 | class E链路类型(enum.Enum):
3 | e无 = 0 #不是二层口
4 | e接入 = 1
5 | e中继 = 2
6 | e混合 = 3
7 | class I虚拟局域网配置:
8 | #模式
9 | def f模式_接口(self, a接口, a操作):
10 | raise NotImplementedError()
11 | #动作
12 | def fs描述(self, a描述, a操作):
13 | raise NotImplementedError()
14 | def fs端口(self, a接口, a操作):
15 | raise NotImplementedError()
16 | class I接口配置:
17 | def fs链路类型(self, a类型, a操作):
18 | raise NotImplementedError()
19 | def fg链路类型(self):
20 | raise NotImplementedError()
21 | #中继(trunk)
22 | def f中继_s通过(self, a虚拟局域网, a操作):
23 | raise NotImplementedError()
24 | def f中继_s封装协议(self, a协议, a操作):
25 | raise NotImplementedError()
26 | def f中继_s本征(self, a虚拟局域网, a操作):
27 | raise NotImplementedError()
28 | #接入(access)
29 | def f接入_s绑定(self, a虚拟局域网, a操作):
30 | raise NotImplementedError()
31 | #混合(hybrid)
32 | def f混合_s无标记(self, a虚拟局域网, a操作):
33 | raise NotImplementedError()
34 | def f混合_s有标记(self, a虚拟局域网, a操作):
35 | raise NotImplementedError()
36 |
--------------------------------------------------------------------------------
/网络设备脚本/基础接口/虚拟路由器冗余协议.py:
--------------------------------------------------------------------------------
1 | class I冗余路由:
2 | #显示
3 | def fg组号(self):
4 | raise NotImplementedError()
5 | #配置
6 | def fs网络地址4(self, a地址, a操作):
7 | raise NotImplementedError()
8 | def fs网络地址6(self, a地址, a操作):
9 | raise NotImplementedError()
10 | def fs优先级(self, a优先级, a操作):
11 | raise NotImplementedError()
12 | def fs抢占(self, a操作):
13 | raise NotImplementedError()
--------------------------------------------------------------------------------
/网络设备脚本/基础接口/虚拟路由转发.py:
--------------------------------------------------------------------------------
1 | class S路由区分符:
2 | def __init__(self, a号, a数):
3 | self.m号 = int(a号)
4 | self.m数 = int(a数)
5 | def __str__(self):
6 | return f"{self.m号}:{self.m数}"
7 | class I资源配置:
8 | c模式名 = "虚拟路由转发资源配置模式"
9 | def fs路由区分符(self, a路由区分符, a操作):
10 | raise NotImplementedError()
11 | def fs路由目标(self, a路由区分符, a方向, a操作):
12 | raise NotImplementedError()
13 | class I接口配置:
14 | c模式名 = "虚拟路由转发接口配置模式"
15 | def fs虚拟路由转发(self, a名称, a保留地址, a操作):
16 | raise NotImplementedError()
--------------------------------------------------------------------------------
/网络设备脚本/基础接口/设备.py:
--------------------------------------------------------------------------------
1 | class I设备:
2 | def __init__(self):
3 | self.m回显 = False
4 | self.m等待回显 = False
5 | self.m检测异常 = False
6 | self.m访问权限 = 3 #读|写,读权限指示脚本可以获取网络设备信息，写权限指示脚本可以修改网络设备配置
7 | def fs回显(self, a回显 = True, a等待回显 = True):
8 | self.m回显 = a回显
9 | self.m等待回显 = a等待回显
10 | def fs检测异常(self, a异常 = True):
11 | self.m检测异常 = a异常
12 | def fs访问权限(self, a权限):
13 | self.m访问权限 = a权限
14 | def f模式_用户(self): #要求：ma模式[0]总是用户模式，没有则创建。不能创建多个用户模式对象。
15 | "用户模式只能查看信息,做一些基本操作,不能配置"
16 | raise NotImplementedError()
17 | def f模式_启动(self):
18 | "在交换机开机阶段执行操作的模式,需要串口连接"
19 | raise NotImplementedError()
20 | def f模式_配置(self):
21 | "直接进入配置模式, 用于不需要用户名密码登录, 没有状态的连接方式"
22 | raise NotImplementedError()
23 | def f模式_显示(self):
24 | "直接进入显示模式"
25 | raise NotImplementedError()
26 | def f助手_访问控制列表(self):
27 | raise NotImplementedError()
28 | def f助手_密码(self):
29 | raise NotImplementedError()
30 | def f助手_服务质量策略(self, a策略名称: str, a分类名称: str, a行为名称: str, ai自动绑定: bool):
31 | raise NotImplementedError()
--------------------------------------------------------------------------------
/网络设备脚本/基础接口/设备模式.py:
--------------------------------------------------------------------------------
1 | class I设备显示:
2 | #系统信息
3 | def f显示_版本(self):
4 | raise NotImplementedError()
5 | def f显示_设备名(self):
6 | "返回字符串"
7 | raise NotImplementedError()
8 | def f显示_系统版本(self):
9 | "返回 S版本 对象"
10 | raise NotImplementedError()
11 | #系统状态
12 | def f显示_运行时间(self):
13 | "从开机到现在所经过的时间, 返回datetime.timedelta对象"
14 | raise NotImplementedError()
15 | def f显示_开机日期(self):
16 | "返回time.struct_time对象"
17 | raise NotImplementedError()
18 | def f显示_中央处理器利用率(self):
19 | raise NotImplementedError()
20 | def f显示_内存利用率(self):
21 | "返回数字"
22 | raise NotImplementedError()
23 | #硬件信息
24 | def f显示_序列号(self):
25 | "返回字符串"
26 | raise NotImplementedError()
27 | def f显示_出厂日期(self):
28 | "返回time.struct_time对象"
29 | raise NotImplementedError()
30 | def f显示_资产(self):
31 | """返回表"""
32 | raise NotImplementedError()
33 | #硬件状态
34 | def f显示_温度(self):
35 | """返回表"""
36 | raise NotImplementedError()
37 | def f显示_风扇(self):
38 | """返回表"""
39 | raise NotImplementedError()
40 | def f显示_电源(self):
41 | """返回表"""
42 | raise NotImplementedError()
43 | class I设备配置:
44 | def fs设备名(self, a名称):
45 | raise NotImplementedError()
--------------------------------------------------------------------------------
/网络设备脚本/基础接口/路由.py:
--------------------------------------------------------------------------------
1 | import enum
2 | import cflw代码库py.cflw字符串 as 字符串
3 | import cflw代码库py.cflw工具_运算 as 运算
4 | class E路由类型(enum.Enum):
5 | e无 = 0
6 | #网络层
7 | e本地 = 1
8 | e直连 = 2
9 | e静态 = 3
10 | e邻居发现协议 = 4 #ndp
11 | e热备份路由协议 = 5 #hsrp
12 | #动态路由协议
13 | e路由信息协议 = 10 #rip
14 | e开放最短路径优先 = 11 #ospf
15 | e边界网关协议 = 12 #bgp
16 | e增强内部网关路由协议 = 13 #eigrp
17 | e中间系统到中间系统 = 14 #isis
18 | #其它
19 | e按需路由 = 20 #odr
20 | e下一跳解析协议 = 21 #nhrp
21 | e移动 = 22 #nemo
22 | e定位与身份分离协议 = 23 #lisp
--------------------------------------------------------------------------------
/网络设备脚本/基础接口/路由信息协议.py:
--------------------------------------------------------------------------------
1 | class I路由信息协议(I模式):
2 | def f显示_路由表(self):
3 | raise NotImplementedError()
4 | def f显示_数据库(self):
5 | raise NotImplementedError()
6 | def fs通告网络(self, a网络号, a操作):
7 | raise NotImplementedError()
8 | def fs通告接口(self, a接口, a操作):
9 | raise NotImplementedError()
10 | class I路由信息协议接口:
11 | def fs通告接口(self, a接口, a操作):
12 | raise NotImplementedError()
13 | def fs认证(self, a认证方式, a密码, a操作):
14 | raise NotImplementedError()
15 |
--------------------------------------------------------------------------------
/网络设备脚本/基础接口/路由映射.py:
--------------------------------------------------------------------------------
1 | from . import 策略
2 | class I路由映射组:
3 | def f模式_节点(self, a序号, a动作, a操作):
4 | raise NotImplementedError()
5 | class I路由映射节点(策略.I匹配, 策略.I设置):
6 | pass
--------------------------------------------------------------------------------
/网络设备脚本/基础接口/边界网关协议.py:
--------------------------------------------------------------------------------
1 | import enum
2 | class E地址族(enum.IntEnum):
3 | e单播4 = 0
4 | e虚拟路由4 = 1 #vrf
5 | e虚专网4 = 2 #vpn
6 | e单播6 = 10
7 | e虚拟路由6 = 11
8 | e虚专网6 = 12
9 | class I进程配置:
10 | c模式名 = "边界网关协议进程配置模式"
11 | #模式
12 | def f模式_对等体(self, a对等体, a操作):
13 | raise NotImplementedError()
14 | def f模式_对等体组(self, a名称, a操作):
15 | raise NotImplementedError()
16 | def f模式_地址族(self, *a地址族, a操作):
17 | raise NotImplementedError()
18 | #显示
19 | def f显示_路由表(self):
20 | raise NotImplementedError()
21 | def f显示_邻居表(self):
22 | raise NotImplementedError()
23 | #操作
24 | def fs路由器号(self, a):
25 | raise NotImplementedError()
26 | class I地址族配置:
27 | c模式名 = "边界网关协议地址族配置模式"
28 | def f模式_对等体(self, a名称):
29 | raise NotImplementedError()
30 | def f模式_对等体组(self, a名称, a操作):
31 | raise NotImplementedError()
32 | def f显示_路由表(self):
33 | raise NotImplementedError()
34 | def fs通告网络(self, a网络号, a操作):
35 | raise NotImplementedError()
36 | def fs通告接口(self, a接口, a操作):
37 | raise NotImplementedError()
38 | class I对等体配置:
39 | c模式名 = "边界网关协议对等体(组)配置模式"
40 | #操作
41 | def fs激活(self, a操作):
42 | raise NotImplementedError()
43 | def fs远端自治系统号(self, a自治系统号, a操作):
44 | raise NotImplementedError()
45 | def fs本端自治系统号(self, a自治系统号, a操作):
46 | raise NotImplementedError()
47 | def fs更新源地址(self, a源, a操作):
48 | raise NotImplementedError()
49 | def fs对等体组(self, a对等体组, a操作):
50 | raise NotImplementedError()
51 |
--------------------------------------------------------------------------------
/网络设备脚本/基础接口/连接.py:
--------------------------------------------------------------------------------
1 | import cflw代码库py.cflw网络连接 as 连接
2 | #===============================================================================
3 | # 连接包装
4 | #===============================================================================
5 | class I连接包装:
6 | def __init__(self, a模式):
7 | self.m模式 = a模式
8 | self.m设备 = a模式.m设备
9 | self.m连接 = a模式.m设备.m连接
10 | def f连接(self):
11 | raise NotImplementedError()
12 | def f关闭(self):
13 | pass
14 | class I命令行连接(I连接包装):
15 | "一台设备连接到其它设备时使用"
16 | c连接特性 = 连接.I命令行连接.c连接特性
17 | def f读_最新(self):
18 | return self.m连接.f读_最新()
19 | def f读_最近(self, a数量):
20 | return self.m连接.f读_最近(a数量)
21 | def f读_直到(self, a文本 = "", a时间 = 5):
22 | return self.m连接.f读_直到(a文本, a时间)
23 | def f写(self, a文本):
24 | self.m连接.f写(a文本)
25 | def fs编码(self, a编码):
26 | self.m连接.fs编码(a编码)
27 |
--------------------------------------------------------------------------------
/网络设备脚本/基础接口/连接层.py:
--------------------------------------------------------------------------------
1 | """在不导入其他模块的情况下处理各种连接"""
2 | def fi连接特性(a连接, a位):
3 | if hasattr(a连接, "c连接特性"):
4 | return a连接.c连接特性 & a位
5 | return False
6 | def fi命令行(a连接):
7 | if fi连接特性(a连接, 0x0001):
8 | return True
9 | return False
10 | def fi网页(a连接):
11 | if fi连接特性(a连接, 0x0002):
12 | return True
13 | elif "selenium" in str(a连接.__class__): #selenium
14 | return True
15 | return False
16 | def fi简单网管(a连接):
17 | if fi连接特性(a连接, 0x0004):
18 | return True
19 | if "简单网管" in str(a连接.__class__):
20 | return True
21 | return False
--------------------------------------------------------------------------------
/网络设备脚本/基础接口/链路层发现协议.py:
--------------------------------------------------------------------------------
1 | import enum
2 | class E邻居信息(enum.IntEnum):
3 | "用于：链路层发现协议"
4 | e邻居名称 = 1
5 | e邻居描述 = 2
6 | e更新时间 = 3
7 | e本端接口 = 10
8 | e本端接口描述 = 11
9 | e对端接口 = 20
10 | e对端接口描述 = 21
11 | e管理地址类型 = 30
12 | e管理地址 = 31
13 | class I进程配置:
14 | def f模式_接口(self, a接口):
15 | raise NotImplementedError()
16 | def f显示_邻居表(self):
17 | raise NotImplementedError()
18 | def fs开关(self, a操作):
19 | raise NotImplementedError()
20 | class I接口配置:
21 | def fs开关(self, a操作):
22 | raise NotImplementedError()
--------------------------------------------------------------------------------
/网络设备脚本/基础接口/链路聚合.py:
--------------------------------------------------------------------------------
1 | import enum
2 | class E链路聚合协议(enum.Enum):
3 | e无 = enum.auto()
4 | e静态 = enum.auto()
5 | e端口聚合协议 = enum.auto() #pagp
6 | e链路聚合控制协议 = enum.auto() #lacp
7 | ca链路聚合协议 = {
8 | "none": E链路聚合协议.e无,
9 | "on": E链路聚合协议.e静态,
10 | "pagp": E链路聚合协议.e端口聚合协议,
11 | "lacp": E链路聚合协议.e链路聚合控制协议,
12 | }
--------------------------------------------------------------------------------
/网络设备脚本/基础接口/静态路由.py:
--------------------------------------------------------------------------------
1 | class I静态路由配置:
2 | def f显示_路由表(self):
3 | raise NotImplementedError()
4 | def fs路由(self, a网络号, a下一跳, a操作):
5 | raise NotImplementedError()
6 | def fs默认路由(self, a下一跳, a操作):
7 | raise NotImplementedError()
--------------------------------------------------------------------------------
/网络设备脚本/山石.py:
--------------------------------------------------------------------------------
1 | import enum
2 | import cflw代码库py.cflw工具 as 工具
3 | from .基础接口 import 连接层
4 | class E型号(enum.IntEnum):
5 | c防火墙 = 0x10000000
6 | sg6000p1412 = c防火墙 + 6412 #灰色界面
7 | sg6000a5100 = c防火墙 + 5100 #蓝色界面
8 | def f创建设备(a连接, a型号, a版本 = 0):
9 | v版本 = 工具.S版本号.fc自动(a版本)
10 | if 连接层.fi网页(a连接): #网页
11 | if a型号 & E型号.c防火墙:
12 | from .山石防火墙网页 import 设备
13 | if a型号 == E型号.sg6000p1412:
14 | t设备 = 设备.C设备_p
15 | elif a型号 == E型号.sg6000a5100:
16 | t设备 = 设备.C设备_a
17 | else:
18 | raise ValueError("不支持的型号")
19 | return t设备(a连接, a型号, v版本)
20 | raise ValueError("不支持的连接,型号,版本")
--------------------------------------------------------------------------------
/网络设备脚本/山石防火墙网页/全局显示.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 全局显示
2 | from . import 模式
3 | class C全局显示_p(全局显示.I全局显示):
4 | """适用于: 山石SG-6000-P1242(v5.5)"""
5 | t模式 = 模式.C模式_sg6000p1242
6 | def __init__(self, a设备):
7 | self.m设备 = a设备
8 | def f模式_设备(self):
9 | from . import 设备模式
10 | return 设备模式.C设备显示_p(self.m设备)
11 | class C全局显示_a(全局显示.I全局显示):
12 | """适用于: 山石SG-6000-A5100(v5.5)"""
13 | t模式 = 模式.C模式_sg6000a5100
14 | def __init__(self, a设备):
15 | self.m设备 = a设备
16 | def f模式_设备(self):
17 | from . import 设备模式
18 | return 设备模式.C设备显示_a(self.m设备)
19 |
--------------------------------------------------------------------------------
/网络设备脚本/山石防火墙网页/全局配置.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 全局配置
2 | class C全局配置_p(全局配置.I全局配置):
3 | """适用于: 山石SG-6000-P1242(v5.5)"""
4 | def __init__(self, a设备):
5 | self.m设备 = a设备
6 | class C全局配置_a(全局配置.I全局配置):
7 | """适用于: 山石SG-6000-A5100(v5.5)"""
8 | def __init__(self, a设备):
9 | self.m设备 = a设备
--------------------------------------------------------------------------------
/网络设备脚本/山石防火墙网页/用户模式.py:
--------------------------------------------------------------------------------
1 | import time
2 | from ..基础接口 import 用户模式
3 | class C用户模式(用户模式.I用户模式):
4 | def __init__(self, a设备):
5 | self.m设备 = a设备
6 | def f登录(self, a用户名, a密码):
7 | w用户名 = self.m设备.f查找('//*[@id="login_username"]')
8 | w用户名.f输入(a用户名)
9 | w密码 = self.m设备.f查找('//*[@id="login_passwd"]')
10 | w密码.f输入(a密码)
11 | w登录 = self.m设备.f查找('//*[@id="login_button"]')
12 | w登录.f点击()
13 | self.m设备.f等待存在("/html/body/div[1]/div/div/div/div[1]/div/div[2]/div")
14 | time.sleep(1)
15 | self.m设备.f等待可用()
16 | class C用户模式_p(C用户模式):
17 | """适用于: 山石SG-6000-P1242(v5.5)"""
18 | def f模式_全局配置(self):
19 | from . import 全局配置
20 | return 全局配置.C全局配置_a(self.m设备)
21 | def f模式_全局显示(self):
22 | from . import 全局显示
23 | return 全局显示.C全局显示_p(self.m设备)
24 | class C用户模式_a(C用户模式):
25 | """适用于: 山石SG-6000-A5100(v5.5)"""
26 | def f模式_全局配置(self):
27 | from . import 全局配置
28 | return 全局配置.C全局配置_a(self.m设备)
29 | def f模式_全局显示(self):
30 | from . import 全局显示
31 | return 全局显示.C全局显示_a(self.m设备)
32 |
--------------------------------------------------------------------------------
/网络设备脚本/山石防火墙网页/设备模式.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 设备模式 as 北向设备模式
2 | from . import 模式
3 | class C设备显示_p(北向设备模式.I设备显示):
4 | """适用于: 山石SG-6000-P1242(v5.5)"""
5 | t模式 = 模式.C模式_sg6000p1242
6 | def __init__(self, a设备):
7 | self.m设备 = a设备
8 | def f显示_序列号(self):
9 | c序列号路径 = "/html/body/div[4]/div/div[2]/div/div/div/div/div/div/span/div/table[1]/tbody/tr/td[2]/div"
10 | self.m设备.f切换模式(self.t模式.c系统_系统信息)
11 | w序列号 = self.m设备.f查找_直到(c序列号路径)
12 | return w序列号.fg文本()
13 | class C设备显示_a(北向设备模式.I设备显示):
14 | """适用于: 山石SG-6000-A5100(v5.5)"""
15 | t模式 = 模式.C模式_sg6000a5100
16 | def __init__(self, a设备):
17 | self.m设备 = a设备
18 | def f显示_序列号(self):
19 | c序列号路径 = "/html/body/div[3]/div[2]/div[2]/div/span/div/div[1]/div[2]/span/div/div/div/span/div/table[1]/tbody/tr/td[2]/div[1]"
20 | self.m设备.f切换模式(self.t模式.c系统_系统信息)
21 | w序列号 = self.m设备.f查找_直到(c序列号路径)
22 | return w序列号.fg文本()
23 |
--------------------------------------------------------------------------------
/网络设备脚本/思科命令行/中间系统到中间系统.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 操作
2 | from ..基础接口 import 中间系统到中间系统 as 北向路由协议
3 | from ..命令行接口 import 命令
4 | from ..命令行接口 import 中间系统到中间系统 as 南向路由协议
5 | from ..命令行接口 import 接口 as 南向接口
6 | from . import 接口 as 实现接口
7 | from .常量 import *
8 | ca级别 = {
9 | 北向路由协议.E级别.e级别1: "level-1",
10 | 北向路由协议.E级别.e级别2: "level-2",
11 | 北向路由协议.E级别.e级别1和2: "level-1-2",
12 | }
13 | class C进程配置(南向路由协议.I进程配置):
14 | def __init__(self, a, a进程号):
15 | 南向路由协议.I进程配置.__init__(self, a, a进程号)
16 | def fg进入命令(self):
17 | v命令 = 命令.C命令("router isis")
18 | v命令 += self.fg进程号()
19 | return v命令
20 | def f模式_接口(self, a接口, a操作 = 操作.E操作.e设置):
21 | if isinstance(a接口, C接口配置):
22 | return a接口
23 | v接口 = 实现接口.f创建接口(a接口)
24 | return C接口配置(self.fg上级模式(), self.fg进程号(), v接口)
25 | def fs网络标识(self, a标识, a操作 = 操作.E操作.e设置):
26 | v标识 = 北向路由协议.S网络标识.fc自动(a标识)
27 | v命令 = 命令.C命令("net")
28 | v命令 += v标识
29 | self.f执行当前模式命令(v命令)
30 | def fs通告接口(self, a接口, a操作 = 操作.E操作.e设置):
31 | v接口配置 = self.f模式_接口(a接口)
32 | v接口配置.fs通告接口(a操作)
33 | def fs级别(self, a级别, a操作 = 操作.E操作.e设置):
34 | v命令 = 命令.C命令("is-type")
35 | v命令 += ca级别[a级别]
36 | v操作 = 操作.f解析操作(a操作)
37 | v命令.f前置肯定(操作.fi减操作(v操作), c不)
38 | self.f执行当前模式命令(v命令)
39 | class C接口配置(南向路由协议.I接口配置):
40 | def __init__(self, a, a进程号, a接口):
41 | 南向路由协议.I接口配置.__init__(self, a, a进程号, a接口)
42 | def fs通告接口(self, a操作 = 操作.E操作.e设置):
43 | v命令 = 命令.C命令("ip router isis")
44 | v命令 += self.fg进程号()
45 | self.f执行当前模式命令(v命令)
46 |
47 |
--------------------------------------------------------------------------------
/网络设备脚本/思科命令行/常量.py:
--------------------------------------------------------------------------------
1 | c不 = "no "
2 | c做 = "do "
3 | c默认 = "default "
4 | c结束符 = '\x03' #ctrl+c
5 | c注释1 = "!"
6 | c注释2 = "#"
7 | c命令_关闭 = "shutdown"
8 | c命令_描述 = "description"
--------------------------------------------------------------------------------
/网络设备脚本/思科命令行/日志.py:
--------------------------------------------------------------------------------
1 | import cflw代码库py.cflw网络地址 as 地址
2 | from ..基础接口 import 操作
3 | from ..基础接口 import 日志 as 北向日志
4 | from ..命令行接口 import 模式
5 | from ..命令行接口 import 命令
6 | from ..命令行接口 import 日志 as 南向日志
7 | class C日志配置(模式.C同级模式, 南向日志.I日志配置):
8 | def __init__(self, a):
9 | 南向日志.I日志配置.__init__(self, a)
10 | def fs开关(self, a操作 = 操作.E操作.e开启):
11 | v命令 = 命令.C命令("logging on")
12 | self.f执行当前模式命令(v命令)
13 | def fs大小(self, a字节, a操作 = 操作.E操作.e设置):
14 | v命令 = 命令.C命令("logging buffer")
15 | v命令 += int(a字节)
16 | self.f执行当前模式命令(v命令)
17 | def fs服务器地址(self, a地址, a操作 = 操作.E操作.e添加):
18 | v地址 = 地址.fc网络地址(a地址)
19 | v命令 = 命令.C命令("logging host")
20 | v命令 += v地址.fg地址s()
21 | self.f执行当前模式命令(v命令)
22 | def fs服务器严重级别(self, a级别, a操作 = 操作.E操作.e设置):
23 | v命令 = 命令.C命令(f"logging trap {int(a级别)}")
24 | self.f执行当前模式命令(v命令)
--------------------------------------------------------------------------------
/网络设备脚本/思科命令行/时间.py:
--------------------------------------------------------------------------------
1 | import time
2 | import cflw代码库py.cflw时间 as 时间
3 | import cflw代码库py.cflw字符串 as 字符串
4 | from ..基础接口 import 时间 as 时间
5 | from ..命令行接口 import 模式
6 | from ..命令行接口 import 命令
7 | def f解析时间(a文本):
8 | #由于时区名可以设置成奇怪的名字,为了避免奇怪的问题,解析时过滤掉时区
9 | #*09:09:36.935 UTC Thu Sep 29 2016
10 | v文本 = 字符串.f提取字符串之间(a文本, "*" if "*" in a文本 else None, "\n", a结束严谨 = False)
11 | v文本 = 字符串.f去词(v文本, 1)
12 | return time.strptime(v文本, "%H:%M:%S.%f %a %b %d %Y")
13 | class C时间显示(时间.I时间显示, 模式.I显示模式):
14 | def __init__(self, a):
15 | 模式.I显示模式.__init__(self, a)
16 | def f显示_时间(self):
17 | v命令 = "show clock"
18 | v输出 = self.m设备.f执行显示命令(v命令)
19 | return f解析时间(v输出)
20 | class C时间(模式.C同级模式, 时间.I时间配置):
21 | def __init__(self, a):
22 | 模式.C同级模式.__init__(self, a)
23 | def fs日期时间(self, a日期时间):
24 | v时间 = 时间.f解析日期时间(a日期时间)
25 | v时间文本 = time.strftime("%H:%M:%S %b %d %Y", v时间)
26 | v命令 = "clock set " + v时间文本
27 | self.m设备.f执行用户命令(v命令)
28 | def fs时区(self, a时区):
29 | v时区 = 时间.f解析时区(a时区)
30 | v时区名, v符号, v时, v分 = 时间.f拆分时区(v时区)
31 | v命令 = 命令.C命令("clock timezone")
32 | v命令 += v时区名
33 | v命令 += "+" if v符号 else "-"
34 | v命令 -= v时
35 | if v分:
36 | v命令 += v分
37 | self.f执行当前模式命令(v命令)
--------------------------------------------------------------------------------
/网络设备脚本/思科命令行/热备份路由协议.py:
--------------------------------------------------------------------------------
1 | import cflw代码库py.cflw网络地址 as 地址
2 | from ..基础接口 import 操作
3 | from ..基础接口 import 热备份路由协议 as 北向协议
4 | from ..命令行接口 import 命令
5 | from .常量 import *
6 | from . import 接口 as 实现接口
7 | class C配置(北向协议.I冗余路由, 实现接口.I接口配置):
8 | def __init__(self, a, a接口, a组号):
9 | 实现接口.I接口配置.__init__(self, a, a接口)
10 | self.m组号 = int(a组号)
11 | def fg前置命令(self):
12 | return 命令.C命令(f"stanby {self.fg组号()}")
13 | #显示
14 | def fg组号(self):
15 | return self.m组号
16 | #配置
17 | def fs版本(self, a版本, a操作 = 操作.E操作.e设置):
18 | v命令 = f"standby version {a版本}"
19 | self.f执行当前模式命令(v命令)
20 | def fs网络地址4(self, a地址, a操作 = 操作.E操作.e设置):
21 | v地址 = 地址.S网络地址4.fc自动(a地址)
22 | v命令 = self.fg前置命令()
23 | v命令 += "ip", v地址.fg地址s()
24 | self.f执行当前模式命令(v命令)
25 | def fs抢占(self, a操作 = 操作.E操作.e开启):
26 | v操作 = 操作.f解析操作(a操作)
27 | v命令 = self.fg前置命令()
28 | v命令 += "preempt"
29 | v命令.f前置肯定(操作.fi关操作(v操作), c不)
30 | self.f执行当前模式命令(v命令)
31 | def fs优先级(self, a优先级, a操作 = 操作.E操作.e设置):
32 | v命令 = self.fg前置命令()
33 | v命令 += "priority", a优先级
34 | self.f执行当前模式命令(v命令)
35 | def fs问候时间(self, a秒, a操作 = 操作.E操作.e设置):
36 | raise NotImplementedError()
37 | def fs维持时间(self, a秒, a操作 = 操作.E操作.e设置):
38 | raise NotImplementedError()
39 | def fs跟踪(self, a接口, a优先级, a操作 = 操作.E操作.e设置):
40 | v接口 = 实现接口.f创建接口(a接口)
41 | v命令 = self.fg前置命令()
42 | v命令 += "track", v接口, -a优先级
43 | self.f执行当前模式命令(v命令)
44 | def fs认证(self, a密码, a操作 = 操作.E操作.e设置):
45 | v命令 = self.fg前置命令()
46 | v命令 += "authentication md5 key-string", a密码
47 | self.f执行当前模式命令(v命令)
48 |
--------------------------------------------------------------------------------
/网络设备脚本/思科命令行/简单网络管理协议.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 操作
2 | from ..基础接口 import 文件
3 | from ..基础接口 import 简单网络管理协议 as 北向协议
4 | from ..命令行接口 import 命令
5 | from ..命令行接口 import 模式
6 | from .常量 import *
7 | class C代理配置(模式.C同级模式, 北向协议.I代理配置):
8 | def __init__(self, a):
9 | 模式.C同级模式.__init__(self, a)
10 | def fs开关(self, a操作 = None):
11 | """没有命令"""
12 | pass
13 | def fs团体字符串(self, a字符串, a权限 = 文件.E访问权限.e只读, a操作 = 操作.E操作.e设置):
14 | """命令: snmp-server community 团体字 访问权限
15 | 删除命令: no snmp-server community 团体字"""
16 | v操作 = 操作.f解析操作(a操作)
17 | v命令 = 命令.C命令("snmp-server community")
18 | v命令 += a字符串
19 | if 操作.fi加操作(v操作):
20 | v命令 += "rw" if 文件.fi含写(a权限) else "ro"
21 | elif 操作.fi减操作(v操作):
22 | v命令.f前面添加(c不)
23 | else:
24 | raise ValueError("未知的操作")
25 | self.f执行当前模式命令(v命令)
26 | def fi团体字符串(self, a字符串, a权限 = None):
27 | pass
28 | class C陷阱配置(模式.C同级模式, 北向协议.I陷阱配置):
29 | def __init__(self, a):
30 | 模式.C同级模式.__init__(self, a)
31 | def fs开关(self, a操作 = 操作.E操作.e开启):
32 | """命令: [no] snmp-server enable traps"""
33 | v操作 = 操作.f解析操作(a操作)
34 | v命令 = 命令.C命令("snmp-server enable traps")
35 | v命令.f前置肯定(操作.fi关操作(v操作), c不)
36 | self.f执行当前模式命令(v命令)
37 | def fs服务器(self, a地址, a字符串, a操作 = 操作.E操作.e添加):
38 | """命令: snmp-server host 地址 字符串"""
39 | v命令 = 命令.C命令("snmp-server host")
40 | v命令 += a地址, a字符串
41 | self.f执行当前模式命令(v命令)
--------------------------------------------------------------------------------
/网络设备脚本/思科命令行/网络终端.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 操作
2 | from ..命令行接口 import 命令
3 | from ..命令行接口 import 模式
4 | from ..命令行接口 import 网络终端 as 南向网络终端
5 | from .常量 import *
6 | from . import 接口 as 实现接口
7 | class C网络终端配置(南向网络终端.I网络终端配置, 模式.C同级模式):
8 | def __init__(self, a):
9 | 南向网络终端.I网络终端配置.__init__(self, a)
10 | def fs开关(self, a操作 = 操作.E操作.e开启):
11 | pass
12 | def fs源接口(self, a接口, a操作 = 操作.E操作.e设置):
13 | v操作 = 操作.f解析操作(a操作)
14 | v命令 = 命令.C命令("ip telnet source-interface")
15 | if 操作.fi加操作(v操作):
16 | v接口 = 实现接口.f创建接口(a接口)
17 | v命令 += v接口
18 | else:
19 | v命令.f前面添加(c不)
20 | self.f执行当前模式命令(v命令)
21 |
--------------------------------------------------------------------------------
/网络设备脚本/思科命令行/虚拟路由器冗余协议.py:
--------------------------------------------------------------------------------
1 | import cflw代码库py.cflw网络地址 as 地址
2 | from ..基础接口 import 虚拟路由器冗余协议 as 北向协议
3 | from ..基础接口 import 操作
4 | from ..命令行接口 import 命令
5 | from . import 接口 as 实现接口
6 | from .常量 import *
7 | class C冗余路由(北向协议.I冗余路由, 实现接口.I接口配置):
8 | def __init__(self, a, a接口, a组号):
9 | 实现接口.I接口配置.__init__(self, a, a接口)
10 | self.m组号 = int(a组号)
11 | def fg命令前缀(self):
12 | return 命令.C命令(f"vrrp {self.m组号}")
13 | def fg组号(self):
14 | return self.m组号
15 | #配置
16 | def fs网络地址4(self, a地址, a操作 = 操作.E操作.e设置):
17 | """命令: vrrp 组号 ip 地址"""
18 | v地址 = 地址.S网络地址4.fc自动(a地址)
19 | v命令 = self.fg命令前缀()
20 | v命令 += "ip", v地址.fg地址s()
21 | self.f执行当前模式命令(v命令)
22 | def fs网络地址6(self, a地址, a操作 = 操作.E操作.e设置):
23 | """命令: vrrp 组号 ipv6 地址"""
24 | v地址 = 地址.S网络地址6.fc自动(a地址)
25 | v命令 = self.fg命令前缀()
26 | v命令 += "ipv6", v地址.fg地址s()
27 | self.f执行当前模式命令(v命令)
28 | def fs抢占(self, a开关 = True):
29 | """命令: [no] vrrp 组号 preempt [delay minimum 抢占延时]"""
30 | v操作 = 操作.f解析操作(a开关)
31 | v命令 = self.fg命令前缀()
32 | v命令 += "preempt"
33 | v命令.f前置否定(操作.fi关操作(v操作), c不)
34 | self.f执行当前模式命令(v命令)
35 | def fs优先级(self, a优先级, a操作 = 操作.E操作.e设置):
36 | """命令: vrrp 组号 priority 优先级"""
37 | v操作 = 操作.f解析操作(a操作)
38 | v优先级 = int(a优先级)
39 | v命令 = self.fg命令前缀()
40 | v命令 += "priority", v优先级
41 | v命令.f前置否定(操作.fi关操作(v操作), c不)
42 | self.f执行当前模式命令(v命令)
--------------------------------------------------------------------------------
/网络设备脚本/思科命令行/虚拟路由转发.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 操作
2 | from ..基础接口 import 虚拟路由转发 as 北向虚拟路由转发
3 | from ..命令行接口 import 命令
4 | from ..命令行接口 import 模式
5 | from ..命令行接口 import 虚拟路由转发 as 南向虚拟路由转发
6 | from .常量 import *
7 | ca方向 = {
8 | 操作.E方向.e入: "import",
9 | 操作.E方向.e出: "export",
10 | 操作.E方向.e双: "both"
11 | }
12 | class C资源配置(南向虚拟路由转发.I资源配置):
13 | def __init__(self, a, a名称):
14 | 南向虚拟路由转发.I资源配置.__init__(self, a, a名称)
15 | def fg进入命令(self):
16 | return f"ip vrf {self.fg名称()}"
17 | def fs路由区分符(self, a路由区分符, a操作 = 操作.E操作.e设置):
18 | v命令 = 命令.C命令("rd")
19 | v命令 += a路由区分符
20 | self.f执行当前模式命令(v命令)
21 | def fs路由目标(self, a路由区分符, a方向 = 操作.E方向.e双, a操作 = 操作.E操作.e设置):
22 | v命令 = 命令.C命令("route-target")
23 | v命令 += ca方向[a方向]
24 | v命令 += a路由区分符
25 | self.f执行当前模式命令(v命令)
26 | class C接口配置(南向虚拟路由转发.I接口配置):
27 | def __init__(self, a, a接口):
28 | 南向虚拟路由转发.I接口配置.__init__(self, a, a接口)
29 | def fs虚拟路由转发(self, a名称, a保留地址 = True, a操作 = 操作.E操作.e设置):
30 | v命令 = f"ip vrf forwarding {a名称}"
31 | self.f执行当前模式命令(v命令)
--------------------------------------------------------------------------------
/网络设备脚本/思科命令行/设备模式.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 设备模式
2 | from ..命令行接口 import 模式
3 | from . import 硬件信息
4 | from . import 系统信息
5 | class C设备显示(设备模式.I设备显示, 模式.I显示模式):
6 | def __init__(self, a):
7 | 模式.I显示模式.__init__(self, a)
8 | self.m版本信息 = None
9 | def fg版本信息(self):
10 | if self.m版本信息 == None:
11 | v输出 = self.m设备.f执行显示命令("show version")
12 | self.m版本信息 = 系统信息.C版本信息(v输出)
13 | return self.m版本信息
14 | #硬件
15 | def f显示_风扇(self):
16 | v输出 = self.m设备.f执行显示命令("show environment fan")
17 | return 硬件信息.f风扇信息(v输出)
18 | def f显示_电源(self):
19 | v输出 = self.m设备.f执行显示命令("show environment power")
20 | return 硬件信息.f电源信息(v输出)
21 | def f显示_温度(self):
22 | v输出 = self.m设备.f执行显示命令("show environment temperature")
23 | return 硬件信息.f温度信息(v输出)
24 | #系统
25 | def f显示_系统版本(self):
26 | return self.fg版本信息()
27 | def f显示_中央处理器利用率(self):
28 | v输出 = self.m设备.f执行显示命令("show processes cpu", a自动换页 = False)
29 | return 系统信息.f解析中央处理器利用率(v输出)
30 | def f显示_内存利用率(self):
31 | v输出 = self.m设备.f执行显示命令("show processes memory", a自动换页 = False)
32 | return 系统信息.f解析内存利用率(v输出)
33 | class C设备配置(设备模式.I设备配置, 模式.C同级模式, C设备显示):
34 | def __init__(self, a):
35 | 模式.C同级模式.__init__(self, a)
36 | C设备显示.__init__(self, a)
37 | def fs设备名(self, a名称):
38 | v命令 = "hostname " + str(a名称)
39 | self.f执行当前模式命令(v命令)
40 | def fs域名(self, a名称 = "a"):
41 | v命令 = "ip domain-name " + str(a名称)
42 | self.f执行当前模式命令(v命令)
43 |
--------------------------------------------------------------------------------
/网络设备脚本/思科命令行/路由信息协议.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 操作
2 | from ..命令行接口 import 命令
3 | from ..基础接口 import 协议
4 | from ..基础接口 import 接口 as 北向接口
5 | class C当代(设备.I路由信息协议):
6 | def __init__(self, a):
7 | 设备.I路由信息协议.__init__(self, a)
8 | def fg进入命令(self):
9 | return "router rip"
10 | def f执行通告网络命令(self, a命令, a网络号):
11 | if not 地址.S网络地址4.fi地址格式(a网络号):
12 | raise ValueError()
13 | v命令 = 命令.C命令(a命令)
14 | v命令.f添加(a网络号)
15 | self.f切换到当前模式()
16 | self.m设备.f执行命令(v命令)
17 | def f通告网络(self, a网络号):
18 | self.f执行通告网络命令("network", a网络号)
19 | def f删除网络(self, a网络号):
20 | self.f执行通告网络命令("no network", a网络号)
21 | def f通告接口(self, a接口):
22 | raise NotImplementedError()
23 | def f删除接口(self, a接口):
24 | raise NotImplementedError()
25 | class C下代(设备.I路由信息协议):
26 | def __init__(self, a, a名称):
27 | 设备.I路由信息协议.__init__(self, a)
28 | self.m名称 = str(a名称)
29 | def fg进入命令(self):
30 | return "ipv6 router " + self.fg模式参数()
31 | def fg模式参数(self):
32 | return self.m名称
33 | def fg通告接口命令(self):
34 | return "ipv6 rip %s enable" % (self.fg模式参数(),)
35 | def f执行通告接口命令(self, a接口):
36 | if not 地址.S网络地址6.fi地址格式(a网络号):
37 | raise ValueError()
38 | v上级模式 = self.fg上级模式()
39 | v接口配置模式 = v上级模式.f模式_接口(a接口)
40 | v接口配置模式.f执行当前模式命令(self.fg通告接口命令())
41 | def f通告接口(self, a接口):
42 | raise NotImplementedError()
43 | def f删除接口(self, a接口):
44 | raise NotImplementedError()
45 |
--------------------------------------------------------------------------------
/网络设备脚本/思科命令行/路由映射.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 操作
2 | from ..基础接口 import 策略
3 | from ..命令行接口 import 模式
4 | from ..命令行接口 import 命令
5 | from ..命令行接口 import 路由映射
6 | from . import 访问控制列表 as 访问列表
7 | class C路由映射组(路由映射.I路由映射组, 模式.C同级模式):
8 | def __init__(self, a, a名称):
9 | 路由映射.I路由映射组.__init__(self, a, a名称)
10 | def f模式_节点(self, a序号 = 10, a动作 = True, a操作 = None):
11 | return C路由映射节点(self, a序号, a动作)
12 | @策略.A自动策略()
13 | class C路由映射节点(路由映射.I路由映射节点):
14 | def __init__(self, a, a序号, a动作):
15 | 路由映射.I路由映射节点.__init__(self, a, a序号, a动作)
16 | def fg进入命令(self):
17 | """route-map 名称 [动作] [序号]"""
18 | return f"route-map {self.m名称} {访问列表.f生成允许(self.m动作)} {self.m序号}"
19 | #匹配
20 | @策略.A匹配(策略.E类型.e访问列表)
21 | def f匹配_访问列表(self, a访问列表, a操作 = 操作.E操作.e添加):
22 | if isinstance(a访问列表, 访问列表.I访问控制列表):
23 | v命令 = f"match {a访问列表.m协议} address {a访问列表.m名称}"
24 | else:
25 | v命令 = f"match ip address {str(a访问列表)}"
26 | self.f执行当前模式命令(v命令)
27 | #设置
28 | @策略.A设置(策略.E类型.e下一跳4)
29 | def f设置_下一跳4(self, a地址, a操作 = 操作.E操作.e添加):
30 | v命令 = f"set ip next-hop {a地址}"
31 | self.f执行当前模式命令(v命令)
32 | @策略.A设置(策略.E类型.e默认下一跳4)
33 | def f设置_默认下一跳4(self, a地址, a操作 = 操作.E操作.e添加):
34 | v命令 = f"set ip default next-hop {a地址}"
35 | self.f执行当前模式命令(v命令)
36 | @策略.A设置(策略.E类型.e出接口)
37 | def f设置_出接口(self, a接口, a操作 = 操作.E操作.e添加):
38 | v命令 = f"set interface {a接口}"
39 | self.f执行当前模式命令(v命令)
40 | @策略.A设置(策略.E类型.e默认出接口)
41 | def f设置_默认出接口(self, a接口, a操作 = 操作.E操作.e添加):
42 | v命令 = f"set default interface {a接口}"
43 | self.f执行当前模式命令(v命令)
44 |
--------------------------------------------------------------------------------
/网络设备脚本/思科命令行/连接.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 异常
2 | from ..命令行接口 import 命令
3 | from ..命令行接口 import 连接
4 | class C网络终端(连接.I命令行连接):
5 | def __init__(self, a模式, a地址, **a参数):
6 | 连接.I命令行连接.__init__(self, a模式)
7 | self.m地址 = a地址
8 | def fg进入命令(self):
9 | v命令 = 命令.C命令("telnet")
10 | v命令 += self.m地址
11 | return v命令
12 | def f连接(self):
13 | v命令 = self.fg进入命令()
14 | v输出 = self.m模式.f执行当前模式命令(v命令)
15 | # % Destination unreachable; gateway or host down
16 | if "Destination unreachable" in v输出: #没路由
17 | raise 异常.X连接(v输出)
18 | # % Connection timed out; remote host not responding
19 | if "Connection timed out" in v输出: #连接超时
20 | raise 异常.X连接(v输出)
21 | class C安全外壳(连接.I命令行连接):
22 | def __init__(self, a模式, a地址, **a参数):
23 | 连接.I命令行连接.__init__(self, a模式)
24 | self.m地址 = a地址
25 | self.m用户名 = a参数.get("a用户名")
26 | if not self.m用户名:
27 | raise ValueError("必需指定 a用户名")
28 | self.m密码 = a参数.get("a密码")
29 | if not self.m密码:
30 | raise ValueError("必需指定 a密码")
31 | self.m端口号 = a参数.get("a端口号")
32 | self.m虚拟专用网 = a参数.get("a虚拟专用网")
33 | self.m版本 = a参数.get("a版本")
34 | def fg进入命令(self):
35 | """命令: ssh [参数] 地址"""
36 | v命令 = 命令.C命令("ssh")
37 | v命令 += "-l", self.m用户名
38 | v命令 |= "-p", self.m端口号
39 | v命令 |= "-v", self.m版本
40 | v命令 |= "-vrf", self.m虚拟专用网
41 | v命令 += self.m地址
42 | return v命令
43 | def f连接(self):
44 | v命令 = self.fg进入命令()
45 | v输出 = self.m模式.f执行当前模式命令(v命令)
46 | #Password:
47 | if "Password:" in v输出:
48 | v输出 = self.m设备.f执行命令(self.m密码)
49 |
--------------------------------------------------------------------------------
/网络设备脚本/思科命令行/钥匙链.py:
--------------------------------------------------------------------------------
1 | import time
2 | from ..基础接口 import 操作
3 | from ..命令行接口 import 命令
4 | from ..命令行接口 import 模式
5 | def f生成时间(a时间):
6 | return time.strftime("%H:%M:%S %d %b %Y", a时间)
7 | class C钥匙链(模式.I模式):
8 | def __init__(self, a, a名称):
9 | 模式.I模式.__init__(self, a)
10 | self.m名称 = a名称
11 | def fg模式参数(self):
12 | return self.m名称
13 | def fg进入命令(self):
14 | v命令 = 命令.C命令("key chain")
15 | v命令 += self.fg模式参数()
16 | return v命令
17 | def f模式_钥匙(self, a钥匙号: int, a操作 = 操作.E操作.e设置):
18 | return C钥匙(self, a钥匙号)
19 | def f显示_当前模式配置():
20 | v命令 = 命令.C命令("show key chain")
21 | v命令 += self.fg模式参数()
22 | return self.m设备.f执行显示命令(v命令)
23 | class C钥匙(模式.I模式):
24 | def __init__(self, a, a号码):
25 | 模式.I模式.__init__(self, a)
26 | self.m号码 = a号码
27 | def fg模式参数(self):
28 | return self.m号码
29 | def fg进入命令(self):
30 | v命令 = 命令.C命令("key")
31 | v命令 += self.fg模式参数()
32 | return v命令
33 | def fs密码(self, a密码, a操作 = 操作.E操作.e设置):
34 | v命令 = 命令.C命令("key-string")
35 | v命令 += a密码
36 | self.f执行当前模式命令(v命令)
37 | def f执行时间命令(self, a命令, a开始时间, a结束时间):
38 | v命令 = 命令.C命令(a命令)
39 | v命令 += f生成时间(a开始时间)
40 | v命令 += f生成时间(a结束时间)
41 | self.f执行当前模式命令(v命令)
42 | def fs发送时间(self, a开始时间, a结束时间):
43 | self.f执行时间命令("send-lifetime", a开始时间, a结束时间)
44 | def fs接收时间(self, a开始时间, a结束时间):
45 | self.f执行时间命令("accept-lifetime", a开始时间, a结束时间)
46 |
--------------------------------------------------------------------------------
/网络设备脚本/思科命令行/静态路由.py:
--------------------------------------------------------------------------------
1 | import cflw代码库py.cflw网络地址 as 地址
2 | from ..基础接口 import 操作
3 | from ..基础接口 import 协议
4 | from ..基础接口 import 路由 as 北向路由
5 | from ..命令行接口 import 模式
6 | from ..命令行接口 import 命令
7 | from ..命令行接口 import 路由 as 南向路由
8 | from ..命令行接口 import 静态路由 as 南向静态路由
9 | from .常量 import *
10 | from . import 接口 as 实现接口
11 | from . import 路由表信息
12 | def f生成静态路由命令4(a网络号, a下一跳, a虚拟路由转发 = None):
13 | v网络号 = 地址.S网络地址4.fc自动(a网络号)
14 | v下一跳 = 南向路由.f生成下一跳4(a下一跳, 实现接口.f创建接口)
15 | v命令 = 命令.C命令("ip route")
16 | if a虚拟路由转发:
17 | v命令 += "vrf", a虚拟路由转发
18 | v命令 += v网络号.fg地址s(), v网络号.fg掩码s()
19 | v命令 += v下一跳
20 | return v命令
21 | class C静态路由4(模式.C同级模式, 南向静态路由.I静态路由配置):
22 | def __init__(self, a, a虚拟路由转发 = None):
23 | 南向静态路由.I静态路由配置.__init__(self, a)
24 | self.m虚拟路由转发 = a虚拟路由转发
25 | def f显示_路由表(self):
26 | v命令 = 路由表信息.f生成显示路由表命令(协议.E协议.e网络协议4, 北向路由.E路由类型.e静态)
27 | v输出 = self.m设备.f执行显示命令(v命令)
28 | return 路由表信息.C路由表4(v输出)
29 | def fs路由(self, a网络号, a下一跳, a操作 = 操作.E操作.e添加):
30 | v命令 = f生成静态路由命令4(a网络号, a下一跳, self.m虚拟路由转发)
31 | if a操作 == 操作.E操作.e删除:
32 | v命令.f前面添加(c不)
33 | self.f执行当前模式命令(v命令)
34 | def fs默认路由(self, a下一跳, a操作 = 操作.E操作.e添加):
35 | self.fs路由("0.0.0.0/0", a下一跳, a操作)
36 |
--------------------------------------------------------------------------------
/网络设备脚本/思科简单网管/全局显示.py:
--------------------------------------------------------------------------------
1 | import cflw代码库py.cflw字符串 as 字符串
2 | from ..简单网管接口 import 全局显示
3 | class C全局显示(全局显示.I全局显示):
4 | def f显示_设备名(self):
5 | return self.f获取_系统名()
6 | def f显示_设备版本(self):
7 | pass
8 |
--------------------------------------------------------------------------------
/网络设备脚本/思科简单网管/全局配置.py:
--------------------------------------------------------------------------------
1 | from ..简单网管接口 import 全局配置
2 | class C全局配置(全局配置.I全局配置):
3 | #模式
4 | def f模式_接口(self, a接口):
5 | raise NotImplementedError()
--------------------------------------------------------------------------------
/网络设备脚本/思科简单网管/接口.py:
--------------------------------------------------------------------------------
1 | from ..简单网管接口 import 接口 as 南向接口
2 | from ..思科命令行 import 接口 as 命令行接口
3 | class C接口(南向接口.I接口配置):
4 | pass
--------------------------------------------------------------------------------
/网络设备脚本/思科简单网管/设备.py:
--------------------------------------------------------------------------------
1 | from ..简单网管接口 import 设备
2 | class C设备(设备.I设备):
3 | def __init__(self, a连接, a型号, a版本):
4 | 设备.I设备.__init__(self, a连接)
5 | self.m型号 = a型号
6 | self.m版本 = a版本
7 | def f模式_配置(self):
8 | from . import 全局配置
9 | return 全局配置.C全局配置(self)
10 | def f模式_显示(self):
11 | from . import 全局显示
12 | return 全局显示.C全局显示(self)
--------------------------------------------------------------------------------
/网络设备脚本/思科网页/命令行全局配置.py:
--------------------------------------------------------------------------------
1 | from ..思科命令行 import 全局配置
2 | class C全局配置(全局配置.C全局配置):
3 | """适用于: 思科c7200"""
4 | def __init__(self, a):
5 | 全局配置.C全局配置.__init__(self, a)
6 | def fg进入命令(self):
7 | return "configure http"
--------------------------------------------------------------------------------
/网络设备脚本/思科网页/命令行用户模式.py:
--------------------------------------------------------------------------------
1 | import time
2 | from ..思科命令行 import 用户模式
3 | from ..基础接口 import 异常
4 | class C用户模式(用户模式.C用户模式):
5 | """适用于: 思科c7200"""
6 | def __init__(self, a):
7 | 用户模式.C用户模式.__init__(self, a)
8 | #模式
9 | def f模式_全局配置(self):
10 | from . import 命令行全局配置
11 | return 命令行全局配置.C全局配置(self)
12 | #连接
13 | def f连接_网络终端(self, a地址, **a参数):
14 | raise 异常.X操作("网页端没有连接命令")
15 | def f连接_安全外壳(self, a地址, **a参数):
16 | raise 异常.X操作("网页端没有连接命令")
17 | def f连接_集群(self, a名称):
18 | raise 异常.X操作("网页端没有连接命令")
19 | #动作
20 | def f登录(self):
21 | time.sleep(0.5)
22 | self.m设备.f输入_结束符()
23 |
--------------------------------------------------------------------------------
/网络设备脚本/思科连结命令行/启动.py:
--------------------------------------------------------------------------------
1 | import time
2 | from ..基础接口 import 启动模式
3 | from ..命令行接口 import 模式
4 | c启动字符 = '\x03' #ctrl+c
5 | class C启动(启动模式.I启动模式, 模式.I模式):
6 | """nexus系列的启动模式
7 | 适用于: 什么都不适用"""
8 | def __init__(self, a):
9 | 模式.I模式.__init__(self, a)
10 | self.m配置 = None
11 | def f登录(self, a密码 = "", a超时 = 60, a镜像 = "nxos.7.0.3.I5.2.bin"):
12 | v秒表 = 时间.C秒表()
13 | while True:
14 | self.m设备.f输入(c启动字符)
15 | time.sleep(1)
16 | v输出 = self.m设备.f输出(a等待 = False)
17 | #继续判断
18 | if "loader >" in v输出:
19 | time.sleep(1)
20 | break
21 | #超时判断
22 | if v秒表.f滴答() >= a超时:
23 | raise TimeoutError()
24 | self.m设备.f执行命令("cmdline recoverymode=1")
25 | self.m设备.f执行命令(f"boot {a镜像}")
26 | time.sleep(1)
27 | def f模式_配置(self):
28 | if not self.m配置:
29 | self.m配置 = C配置(self)
30 | return self.m配置
31 | def f更新系统(self, a文件):
32 | raise NotImplementedError()
33 | def f重置密码(self, a密码):
34 | v配置模式 = self.f模式_配置()
35 | v配置模式.f重置密码(a密码)
36 | def f清除配置(self):
37 | self.f执行当前模式命令("write erase")
38 | def f重新启动(self):
39 | self.f执行当前模式命令("load-nxos")
40 | class C配置(模式.I模式):
41 | def __init__(self, a):
42 | 模式.I模式.__init__(self, a)
43 | def fg进入命令(self):
44 | return "configure terminal"
45 | def fg退出命令(self):
46 | return "exit"
47 | def f重置密码(self, a密码):
48 | self.f执行当前模式命令(f"admin-password {a密码}")
--------------------------------------------------------------------------------
/网络设备脚本/思科连结命令行/接口.py:
--------------------------------------------------------------------------------
1 | import cflw代码库py.cflw网络地址 as 地址
2 | from ..基础接口 import 操作
3 | from ..基础接口 import 接口 as 北向接口
4 | from ..命令行接口 import 命令
5 | from ..命令行接口 import 模式
6 | from ..命令行接口 import 接口 as 南向接口
7 | ca接口名称_nv7 = {
8 | 北向接口.E类型.e虚拟局域网: "Vlan",
9 | 北向接口.E类型.e聚合: "port-channel",
10 | 北向接口.E类型.e以太网: "Ethernet",
11 | 北向接口.E类型.e管理: "mgmt",
12 | }
13 | ca接口缩写_nv7 = {
14 | 北向接口.E类型.e以太网: "Eth",
15 | 北向接口.E类型.e快速以太网: "Fa",
16 | 北向接口.E类型.e吉以太网: "Gi",
17 | 北向接口.E类型.e聚合: "Po",
18 | 北向接口.E类型.e管理: "mgmt",
19 | 北向接口.E类型.e虚拟局域网: "Vlan",
20 | 北向接口.E类型.e堆叠: "sup-eth", #全名应该是supervisor ethernet,不确定接口干嘛用的,只在mac地址表出现
21 | }
22 | f生成接口_nv7, f创建接口_nv7 = 北向接口.F接口工厂(ca接口名称_nv7)
23 | f生成接口缩写_nv7, f创建接口缩写_nv7 = 北向接口.F接口工厂(ca接口缩写_nv7)
24 | class I接口配置(南向接口.I接口配置):
25 | def __init__(self, a, a接口):
26 | 南向接口.I接口配置.__init__(self, a, a接口)
27 | class C接口_nv7(I接口配置):
28 | def fs网络地址4(self, a地址, a操作 = 操作.E操作.e设置):
29 | raise NotImplementedError()
30 | def fs默认网关4(self, a地址, a操作 = 操作.E操作.e设置):
31 | raise NotImplementedError()
--------------------------------------------------------------------------------
/网络设备脚本/思科连结命令行/日志.py:
--------------------------------------------------------------------------------
1 | import cflw代码库py.cflw网络地址 as 地址
2 | from ..基础接口 import 操作
3 | from ..命令行接口 import 命令
4 | from ..命令行接口 import 模式
5 | from ..命令行接口 import 日志 as 南向日志
6 | class C日志nv7(模式.C同级模式, 南向日志.I日志配置):
7 | def __init__(self, a):
8 | 南向日志.I日志配置.__init__(self, a)
9 | self.m地址 = None
10 | def f生成服务器地址(self, a地址 = None):
11 | if a地址:
12 | self.m地址 = 地址.fc网络地址(a地址)
13 | return 命令.C命令(f"logging server {self.m地址.fg地址s()}")
14 | def fs服务器开关(self, a操作 = None):
15 | pass
16 | def fs服务器地址(self, a地址 = None, a操作 = 操作.E操作.e设置):
17 | v命令 = self.f生成服务器地址(a地址)
18 | self.f执行当前模式命令(v命令)
19 | def fs服务器严重级别(self, a级别, a操作 = 操作.E操作.e设置):
20 | v命令 = self.f生成服务器地址()
21 | v命令 += int(a级别)
22 | self.f执行当前模式命令(v命令)
23 |
--------------------------------------------------------------------------------
/网络设备脚本/思科连结命令行/时间.py:
--------------------------------------------------------------------------------
1 | import time
2 | import cflw代码库py.cflw字符串 as 字符串
3 | from ..基础接口 import 时间
4 | from ..命令行接口 import 命令
5 | from ..命令行接口 import 模式
6 | def f解析时间_nv7(a文本):
7 | #15:12:04.631 UTC Sat Jul 06 2002
8 | #Time source is NTP
9 | v文本 = a文本.split("\n")[0]
10 | v文本 = 字符串.f去词(v文本, 1)
11 | return time.strptime(v文本, "%H:%M:%S.%f %a %b %d %Y")
12 | class C时间显示_nv7(时间.I时间显示, 模式.I显示模式):
13 | def __init__(self, a):
14 | 模式.I显示模式.__init__(self, a)
15 | def f显示_时间(self):
16 | v输出 = self.m设备.f执行显示命令("show clock")
17 | return f解析时间_nv7(v输出)
18 | class C时间_nv7(模式.C同级模式, 时间.I时间配置):
19 | """适用于: 思科nexus9000(v7.0),
20 | 浪潮cn8000系列(v7.3), 浪潮cn61108pcv(v7.0)"""
21 | def __init__(self, a):
22 | 模式.C同级模式.__init__(self, a)
23 | def fs日期时间(self, a日期时间):
24 | v时间 = 时间.f解析日期时间(a日期时间)
25 | v时间文本 = time.strftime("%H %M %S %d %B %Y", v时间)
26 | v命令 = "clock set " + v时间文本
27 | self.f执行当前模式命令(v命令)
28 | def fs时区(self, a时区):
29 | v时区 = 时间.f解析时区(a时区)
30 | v时区名, v符号, v时, v分 = 时间.f拆分时区(v时区)
31 | if len(v时区名) > 8:
32 | raise ValueError("时区名太长")
33 | v命令 = 命令.C命令("clock timezone")
34 | v命令 += v时区名
35 | v命令 += "+" if v符号 else "-"
36 | v命令 -= v时
37 | v命令 += v分
38 | self.f执行当前模式命令(v命令)
--------------------------------------------------------------------------------
/网络设备脚本/思科连结命令行/用户.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 用户 as 北向用户
2 | from ..基础接口 import 操作
3 | from ..命令行接口 import 命令
4 | from ..命令行接口 import 模式
5 | from ..命令行接口 import 用户 as 南向用户
6 | from ..思科命令行.常量 import *
7 | #===============================================================================
8 | # nexus系列(v7.x)
9 | #===============================================================================
10 | ca权限 = {
11 | 北向用户.E用户权限.e最低: "network-operator",
12 | 北向用户.E用户权限.e最高: "network-admin",
13 | }
14 | class C用户nv7(模式.C同级模式, 南向用户.I用户配置):
15 | """适用于: 思科nexus系列(v7.x), 浪潮cn系列(v7.x)"""
16 | def __init__(self, a, a用户名):
17 | 南向用户.I用户配置.__init__(self, a, a用户名)
18 | def fg命令前缀(self):
19 | return 命令.C命令(f"username {self.m用户名}")
20 | def fg删除命令(self):
21 | """命令: no username 用户名"""
22 | return self.fg命令前缀().f前面添加(c不)
23 | def fs密码(self, a密码, a操作 = 操作.E操作.e设置):
24 | """命令: username 用户名 password 密码"""
25 | v命令 = self.fg命令前缀()
26 | v命令 += "password", a密码
27 | self.f执行当前模式命令(v命令)
28 | def fs权限(self, a权限, a操作 = 操作.E操作.e设置):
29 | """命令: username 用户名 role 角色
30 | 最高network-admin"""
31 | v命令 = self.fg命令前缀()
32 | if a权限 in 北向用户.E用户权限:
33 | v权限 = ca权限[a权限]
34 | else:
35 | v权限 = int(a权限)
36 | v命令 += "role", v权限
37 | self.f执行当前模式命令(v命令)
38 | def fs服务类型(self, a服务类型, a操作 = 操作.E操作.e设置):
39 | pass
40 |
--------------------------------------------------------------------------------
/网络设备脚本/思科连结命令行/系统信息.py:
--------------------------------------------------------------------------------
1 | import cflw代码库py.cflw字符串 as 字符串
2 | def f解析中央处理器利用率(a文本):
3 | """show system resources"""
4 | #CPU states : 3.24% user, 0.12% kernel, 96.62% idle
5 | v文本 = 字符串.f提取字符串之间(a文本, "CPU states :", "\n")
6 | v空闲s = 字符串.f提取字符串之间(v文本, "kernel,", "%")
7 | return 1 - float(v空闲s) * 0.01
8 | def f解析内存利用率(a文本):
9 | """show system resources"""
10 | #Memory usage: 8236356K total, 3631152K used, 4605204K free
11 | v文本 = 字符串.f提取字符串之间(a文本, "Memory usage:", "\n")
12 | v总共s = 字符串.f提取字符串之间(v文本, None, "K")
13 | v使用s = 字符串.f提取字符串之间(v文本, "total,", "K")
14 | return int(v使用s) / int(v总共s)
--------------------------------------------------------------------------------
/网络设备脚本/思科连结命令行/虚拟局域网.py:
--------------------------------------------------------------------------------
1 | import pandas
2 | import cflw代码库py.cflw字符串 as 字符串
3 | from ..基础接口 import 数据表
4 | from . import 接口 as 实现接口
5 | class C表_nv7: #需重写
6 | """show vlan
7 | 适用于: 浪潮cn8000系列(v7.3)"""
8 | c号 = 0
9 | c名称 = 5
10 | c状态 = 38
11 | c端口 = 48
12 | ca列开始 = (c号, c名称, c状态, c端口)
13 | c标题行0 = "VLAN Name Status Ports"
14 | c标题行1 = "---- -------------------------------- --------- -------------------------------"
15 | def __init__(self, a文本):
16 | v位置 = 字符串.f连续找最后(a文本, C表_nv7.c标题行0, C表_nv7.c标题行1, "\n")
17 | self.m文本 = a文本[v位置 + 1 :]
18 | def __iter__(self):
19 | return self.fe行()
20 | def fe行(self):
21 | v虚拟局域网 = None
22 | va接口 = []
23 | v接口缓冲 = {}
24 | for v行 in self.m文本.split("\n"):
25 | v虚拟局域网s, v名称s, v状态s, v端口s = 字符串.fe按位置分割(v行, *C表_nv7.ca列开始)
26 | if v虚拟局域网s.isdigit(): #开始
27 | if v虚拟局域网:
28 | yield {
29 | 数据表.E字段.e本端虚拟局域网: v虚拟局域网,
30 | 数据表.E字段.e本端接口: va接口,
31 | }
32 | v虚拟局域网 = int(v虚拟局域网s)
33 | va接口 = []
34 | elif not v虚拟局域网s: #空的
35 | pass
36 | else: #其它字符
37 | break
38 | for v接口s in v端口s.split(","):
39 | v接口s = v接口s.strip()
40 | if v接口s in v接口缓冲:
41 | va接口.append(v接口缓冲[v接口s])
42 | else:
43 | v接口 = 实现接口.f创建接口缩写_nv7(v接口s)
44 | v接口缓冲[v接口s] = v接口
45 | va接口.append(v接口)
46 | if v虚拟局域网:
47 | yield {
48 | 数据表.E字段.e本端虚拟局域网: v虚拟局域网,
49 | 数据表.E字段.e本端接口: va接口,
50 | }
51 | def f虚拟局域网nv7(a文本: str): #需重写
52 | v表 = C表_nv7(a文本)
53 | return pandas.DataFrame(v表.fe行())
--------------------------------------------------------------------------------
/网络设备脚本/思科连结命令行/虚拟路由转发.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 操作
2 | from ..基础接口 import 虚拟路由转发 as 北向转发
3 | from ..命令行接口 import 虚拟路由转发 as 南向转发
4 | class C资源配置nv7(南向转发.I资源配置):
5 | """适用于: 浪潮cn8000系列(v7.3)"""
6 | def __init__(self, a, a名称):
7 | 南向转发.I资源配置.__init__(self, a, a名称)
8 | def fg进入命令(self):
9 | """命令: vrf context 名称"""
10 | return f"vrf context {self.fg名称()}"
11 | class C接口配置nv7(南向转发.I接口配置):
12 | """适用于: 浪潮cn8000系列(v7.3)"""
13 | def __init__(self, a, a接口):
14 | 南向转发.I接口配置.__init__(self, a, a接口)
15 | def fs虚拟路由转发(self, a名称, a保留地址 = True, a操作 = 操作.E操作.e设置):
16 | """命令: vrf member 名称"""
17 | v命令 = f"vrf member {a名称}"
18 | self.f执行当前模式命令(v命令)
--------------------------------------------------------------------------------
/网络设备脚本/思科连结命令行/设备.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 操作
2 | from ..命令行接口 import 设备 as 南向设备
3 | from ..命令行接口 import 命令
4 | #===============================================================================
5 | # nexus(v7.*)
6 | #===============================================================================
7 | class C设备_nv7(南向设备.I设备):
8 | """适用于: 思科n7k系列, 思科n9k系列(v7.0), 浪潮cn61108pcv(v7.0)"""
9 | def __init__(self, a连接, a型号, a版本):
10 | 南向设备.I设备.__init__(self, a连接)
11 | self.m连接.fs编码("utf-8")
12 | self.fs自动换页("--More--")
13 | self.m型号 = a型号
14 | self.m版本 = a版本
15 | #输入输出
16 | def f输入_结束符(self):
17 | self.f输入('\x1a') #ctrl+z
18 | #模式
19 | def f模式_用户(self):
20 | from . import 用户模式
21 | return 用户模式.C用户模式_nv7_0(self)
22 | #命令
23 | def f处理显示结果(self, a命令):
24 | v输出 = a命令.replace("\r\n", "\n")
25 | v输出 = 南向设备.f去头尾行(v输出)
26 | # if v输出.count("\n") < 10:
27 | # self.f检测命令异常(self, v输出)
28 | return v输出
29 | def f退出(self, a关闭 = False):
30 | self.f执行命令("exit")
31 | class C设备_nv7_3(C设备_nv7):
32 | """适用于: 浪潮cn8672up(v7.3), 浪潮cn8696q(v7.3)"""
33 | def f模式_用户(self):
34 | from . import 用户模式
35 | return 用户模式.C用户模式_nv7_3(self)
36 | class C设备_nv9(C设备_nv7):
37 | """适用于: 思科n9k系列(v9.x), 浪潮cn61108pcv(v9.2.3)"""
38 | def f模式_用户(self):
39 | from . import 用户模式
40 | return 用户模式.C用户模式_nv9_2(self)
--------------------------------------------------------------------------------
/网络设备脚本/思科连结命令行/静态路由.py:
--------------------------------------------------------------------------------
1 | import cflw代码库py.cflw网络地址 as 地址
2 | from ..基础接口 import 操作
3 | from ..命令行接口 import 命令
4 | from ..命令行接口 import 模式
5 | from ..命令行接口 import 静态路由 as 南向静态路由
6 | from ..思科命令行.常量 import *
7 | def f生成静态路由命令4(a网络号, a下一跳):
8 | """命令: ip route 网络号/前缀长度 下一跳"""
9 | v网络号 = 地址.S网络地址4.fc自动(a网络号)
10 | v下一跳 = 地址.S网络地址4.fc自动(a下一跳)
11 | v命令 = 命令.C命令("ip route")
12 | v命令 += v网络号.ft字符串()
13 | v命令 += v下一跳.fg地址s()
14 | return v命令
15 | class C静态路由nv7(模式.C同级模式, 南向静态路由.I静态路由配置):
16 | """适用于: 浪潮cn8000系列(v7.3)"""
17 | def __init__(self, a):
18 | 南向静态路由.I静态路由配置.__init__(self, a)
19 | def fs路由(self, a网络号, a下一跳, a操作 = 操作.E操作.e添加):
20 | """命令: ip route 网络号/前缀长度 下一跳 [优先级]"""
21 | v命令 = f生成静态路由命令4(a网络号, a下一跳)
22 | if a操作 == 操作.E操作.e删除:
23 | v命令.f前面添加(c不)
24 | self.f执行当前模式命令(v命令)
25 | def fs默认路由(self, a下一跳, a操作 = 操作.E操作.e添加):
26 | self.fs路由("0.0.0.0/0", a下一跳, a操作)
27 | class C虚拟路由静态路由nv7(南向静态路由.I静态路由配置):
28 | """适用于: 浪潮cn8000系列(v7.3)"""
29 | def __init__(self, a, a名称):
30 | 南向静态路由.I静态路由配置.__init__(self, a)
31 | self.m名称 = a名称
32 | def fg进入命令(self):
33 | """命令: vrf context 名称"""
34 | return f"vrf context {self.m名称}"
35 | def fs路由(self, a网络号, a下一跳, a操作 = 操作.E操作.e添加):
36 | """命令: ip route 网络号/前缀长度 下一跳"""
37 | v命令 = f生成静态路由命令4(a网络号, a下一跳)
38 | if a操作 == 操作.E操作.e删除:
39 | v命令.f前面添加(c不)
40 | self.f执行当前模式命令(v命令)
41 | def fs默认路由(self, a下一跳, a操作 = 操作.E操作.e添加):
42 | self.fs路由("0.0.0.0/0", a下一跳, a操作)
--------------------------------------------------------------------------------
/网络设备脚本/普联.py:
--------------------------------------------------------------------------------
1 | import enum
2 | from .基础接口 import 连接层
3 | class E型号(enum.IntEnum):
4 | wdr5620 = 5620
5 | rac1950g = 1950
6 | def f创建设备(a连接, a型号, a版本 = 0):
7 | if 连接层.fi网页(a连接):
8 | from .普联网页 import 设备
9 | return 设备.C设备(a连接, a型号, a版本)
10 | raise ValueError("不支持的连接,型号")
--------------------------------------------------------------------------------
/网络设备脚本/普联网页/全局配置.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 操作
2 | from ..基础接口 import 全局配置
3 | from ..基础接口 import 接口 as 北向接口
4 | from . import 接口 as 实现接口
5 | class C全局配置(全局配置.I全局配置):
6 | """适用于: wdr5620"""
7 | def __init__(self, a设备):
8 | self.m设备 = a设备
9 | def f模式_接口(self, a接口, a操作 = 操作.E操作.e设置):
10 | v接口 = 实现接口.f创建接口(a接口)
11 | if v接口.m类型 == 北向接口.E类型.e无线电:
12 | from . import 无线局域网 as 实现无线局域网
13 | return 实现无线局域网.C无线电接口配置(self.m设备)
14 | def f模式_无线局域网(self): #暂时
15 | from . import 无线局域网 as 实现无线局域网
16 | return 实现无线局域网.C无线电接口配置(self.m设备)
17 |
--------------------------------------------------------------------------------
/网络设备脚本/普联网页/接口.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 接口 as 北向接口
2 | ca接口名称 = 北向接口.ca接口名称
3 | f创建接口 = 北向接口.F创建接口(ca接口名称)
4 |
--------------------------------------------------------------------------------
/网络设备脚本/普联网页/无线局域网.py:
--------------------------------------------------------------------------------
1 | import time
2 | import pandas #pandas
3 | import cflw代码库py.cflw网络地址 as 地址
4 | from ..基础接口 import 数据表
5 | from ..基础接口 import 无线局域网
6 | from . import 模式
7 | class C无线电接口配置(无线局域网.I接口配置):
8 | """适用于: 普联wdr5620"""
9 | def __init__(self, a设备):
10 | self.m设备 = a设备
11 | def f显示_主机表(self):
12 | return f主机表(self.m设备)
13 | def f主机表(a设备):
14 | """适用于: 普联wdr5620"""
15 | def fe主机():
16 | a设备.f切换模式(模式.C模式wdr5620.c设备管理)
17 | i = 0
18 | while True:
19 | va元素 = list(a设备.fe查找("//*[@id='eptMngList']/div[@class='eptConC']"))
20 | if i >= len(va元素):
21 | break
22 | v元素 = va元素[i]
23 | w管理 = v元素.f查找("div/div/input[1]")
24 | w管理.f点击() #进入主机管理
25 | w详细 = a设备.f查找("//*[@id='eptMngDetail']")
26 | w名称 = w详细.f查找("div[1]/p/span/pre")
27 | v名称 = w名称.fg文本()
28 | w标题 = w详细.f查找("div[1]/span")
29 | v网络地址s, v物理地址s, v连接方式s = w标题.fg文本().split("|") #IP：192.168.0.5 | MAC：80-CB-BC-0F-97-8F | 2.4G无线连接
30 | v网络地址 = 地址.S网络地址4.fc主机地址字符串(v网络地址s.strip()[3:])
31 | v物理地址 = 地址.S物理地址.fc字符串(v物理地址s.strip()[4:])
32 | v上传速度s = w详细.f查找("div[2]/ul/li[1]/p").fg文本() #298KB/s
33 | v下载速度s = w详细.f查找("div[2]/ul/li[2]/p").fg文本() #2MB/s
34 | yield {
35 | 数据表.E字段.e对端名称: v名称,
36 | 数据表.E字段.e对端网络地址4: v网络地址,
37 | 数据表.E字段.e对端物理地址: v物理地址,
38 | }
39 | #结束,返回列表
40 | w主人网络 = a设备.f查找("//*[@id='linkedEpt_rsMenu']")
41 | w主人网络.f点击()
42 | i += 1
43 | return pandas.DataFrame(fe主机())
--------------------------------------------------------------------------------
/网络设备脚本/普联网页/模式.py:
--------------------------------------------------------------------------------
1 | import enum
2 | class C模式wdr5620:
3 | """适用于: 普联wdr5620"""
4 | c网络状态 = ("netStateMbtn",)
5 | c设备管理 = ("routeMgtMbtn",)
6 | c设备管理_主人网络 = ("routeMgtMbtn", "linkedEpt_rsMenu")
7 | c设备管理_已禁设备 = ("routeMgtMbtn", "limitedEpt_rsMenu")
8 | c应用管理 = ("appsMgtMbtn",)
9 | c路由设置 = ("routerSetMbtn",)
10 | c路由设置_tplinkid = ("routerSetMbtn", "cloudAnt_rsMenu")
11 | c路由设置_上网设置 = ("routerSetMbtn", "network_rsMenu")
12 | c路由设置_无线设置 = ("routerSetMbtn", "wireless2G_rsMenu")
13 | c路由设置_lan口设置 = ("routerSetMbtn", "lanSet_rsMenu")
14 | c路由设置_dhcp服务器设置 = ("routerSetMbtn", "dhcpServer_rsMenu")
15 | c路由设置_修改管理员密码 = ("routerSetMbtn", "changeWebPwd_rsMenu")
16 | c路由设置_备份和载入配置 = ("routerSetMbtn", "bakRrestore_rsMenu")
17 | c路由设置_重启和恢复出厂 = ("routerSetMbtn", "reBootSet_rsMenu")
18 | c路由设置_系统日志 = ("routerSetMbtn", "sysLog_rsMenu")
--------------------------------------------------------------------------------
/网络设备脚本/普联网页/用户模式.py:
--------------------------------------------------------------------------------
1 | import time
2 | from ..基础接口 import 用户模式
3 | class C用户模式(用户模式.I用户模式):
4 | def __init__(self, a设备):
5 | self.m设备 = a设备
6 | def f登录(self, a密码 = "", a用户名 = None):
7 | time.sleep(0.5)
8 | w密码框 = self.m设备.f查找("//input[@id='lgPwd']")
9 | w密码框.f输入(a密码)
10 | w确定 = self.m设备.f查找("//input[@id='loginSub']")
11 | w确定.f点击()
12 | time.sleep(0.2)
13 | def f模式_全局配置(self):
14 | from . import 全局配置
15 | return 全局配置.C全局配置(self.m设备)
--------------------------------------------------------------------------------
/网络设备脚本/普联网页/设备.py:
--------------------------------------------------------------------------------
1 | import time
2 | from ..网页接口 import 设备
3 | class C设备(设备.I设备):
4 | """适用于: 普联wdr5620"""
5 | def __init__(self, a连接, a型号, a版本):
6 | 设备.I设备.__init__(self, a连接)
7 | self.m型号 = a型号
8 | self.m版本 = a版本
9 | self.ma模式 = []
10 | def f模式_用户(self):
11 | from . import 用户模式
12 | return 用户模式.C用户模式(self)
13 | #模式
14 | def f切换模式(self, aa模式: tuple):
15 | if self.ma模式 == aa模式:
16 | return
17 | time.sleep(0.2)
18 | for v模式 in aa模式:
19 | v元素 = self.f查找(f"//*[@id='{v模式}']")
20 | v元素.f点击()
21 | time.sleep(0.2)
22 | self.ma模式 == aa模式
--------------------------------------------------------------------------------
/网络设备脚本/水星.py:
--------------------------------------------------------------------------------
1 | import enum
2 | class E型号(enum.IntEnum):
3 | mw155r = 155
4 | def f创建设备(a连接, a型号, a版本 = 0):
5 | v类名 = str(a连接.__class__)
6 | if "selenium" in v类名:
7 | from .水星网页 import 设备
8 | return 设备.C设备(a连接, a型号, a版本)
9 | raise ValueError("不支持的连接")
--------------------------------------------------------------------------------
/网络设备脚本/水星网页/全局配置.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 全局配置
2 | class C全局配置(全局配置.I全局配置):
3 | def __init__(self, a设备):
4 | self.m设备 = a设备
5 | def f模式_静态路由(self):
6 | from . import 静态路由
7 | return 静态路由.C静态路由配置(self.m设备)
--------------------------------------------------------------------------------
/网络设备脚本/水星网页/用户模式.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 用户模式
2 | class C用户模式(用户模式.I用户模式):
3 | """适用于: mw155r"""
4 | def __init__(self, a设备):
5 | self.m设备 = a设备
6 | def f登录(self, a密码 = ""):
7 | w密码框 = self.m设备.f查找("//input[@id='pcPassword']")
8 | w密码框.f输入(a密码)
9 | w确认 = self.m设备.f查找("//label[@id='loginBtn']")
10 | w确认.f点击()
11 | self.m设备.mi登录 = True
12 | def f模式_全局配置(self):
13 | from . import 全局配置
14 | return 全局配置.C全局配置(self.m设备)
--------------------------------------------------------------------------------
/网络设备脚本/水星网页/设备.py:
--------------------------------------------------------------------------------
1 | import enum
2 | from selenium.webdriver.common.by import By #selenium
3 | from ..网页接口 import 设备
4 | class C设备(设备.I设备):
5 | """适用于: mw155r"""
6 | c菜单框架 = "/html/frameset/frameset[2]/frame[1]"
7 | c主体框架 = "/html/frameset/frameset[2]/frame[2]"
8 | def __init__(self, a连接, a型号, a版本):
9 | 设备.I设备.__init__(self, a连接)
10 | self.m型号 = a型号
11 | self.m版本 = a版本
12 | self.ma模式 = ()
13 | self.m当前框架 = -1
14 | self.mi登录 = False
15 | def f切换模式(self, aa模式):
16 | if self.ma模式 == aa模式:
17 | return
18 | self.f切换框架(C设备.c菜单框架)
19 | #切换模式
20 | for v模式 in aa模式:
21 | v元素 = self.m连接.find_element(By.XPATH, f"/html/body/menu/ol[@id='ol{v模式}']/a[1]")
22 | v元素.click()
23 | self.ma模式 == aa模式
24 | def f切换框架(self, a框架):
25 | if self.m当前框架 == a框架:
26 | return
27 | self.m连接.switch_to.default_content()
28 | if a框架:
29 | e = self.m连接.find_element(By.XPATH, a框架)
30 | self.m连接.switch_to.frame(e)
31 | self.m当前框架 = a框架
32 | def f查找(self, a找):
33 | if self.mi登录:
34 | self.f切换框架(C设备.c主体框架)
35 | return 设备.I设备.f查找(self, a找)
36 | def f模式_用户(self):
37 | from . import 用户模式
38 | return 用户模式.C用户模式(self)
--------------------------------------------------------------------------------
/网络设备脚本/深信服.py:
--------------------------------------------------------------------------------
1 | import enum
2 | import cflw代码库py.cflw工具 as 工具
3 | from .基础接口 import 连接层
4 | class E型号(enum.IntEnum):
5 | c防火墙 = 0x10000000 #AF
6 | c应用交付 = 0x20000000 #AD
7 | c安全感知 = 0x40000000 #SIP
8 | c探针 = 0x80000000 #STA
9 | af2000j444 = c防火墙 + 2000444
10 | af2000i484 = c防火墙 + 2000484
11 | fw2000x210 = c防火墙 + 2000210
12 | ad1000o482h = c应用交付 + 1000482
13 | ad1000e642rw = c应用交付 + 1000642
14 | def f创建设备(a连接, a型号, a版本 = 0):
15 | v版本 = 工具.S版本号.fc自动(a版本)
16 | if 连接层.fi命令行(a连接): #命令行
17 | if a型号 & E型号.c防火墙:
18 | if v版本 < "8.0.35":
19 | raise ValueError("8.0.35之前的版本不支持命令行")
20 | else: #>=8.0.35
21 | #深信服防火墙需要 在账号勾选命令行、在接口勾选SSH 才能使用命令行登录。SSH端口号22345
22 | from .深信服防火墙命令行 import 设备
23 | return 设备.C设备v8(a连接, a型号, a版本)
24 | elif 连接层.fi网页(a连接): #网页
25 | if a型号 & E型号.c防火墙:
26 | if v版本 < "8.0.35": #界面1,v8.0.0?
27 | from .深信服防火墙网页 import 设备
28 | vt型号 = 设备.C设备
29 | elif v版本 < "8.0.59": #界面2,v8.0.35,2021-03-19发布,新界面
30 | from .深信服防火墙网页2 import 设备
31 | vt型号 = 设备.C设备af8035
32 | else: #v版本 >= 8.0.59 #界面3,v8.0.59,2022-04-22发布,新架构版本
33 | from .深信服防火墙网页2022 import 设备
34 | vt型号 = 设备.C设备_af8059
35 | return vt型号(a连接, a型号, v版本)
36 | elif a型号 & E型号.c应用交付:
37 | if v版本 < "7.0.5": #界面1
38 | from .深信服应用交付网页 import 设备
39 | vt型号 = 设备.C设备_ad70
40 | else: # v版本 >= "7.0.5" #界面2
41 | from .深信服应用交付网页2 import 设备
42 | vt型号 = 设备.C设备_ad705
43 | return vt型号(a连接, a型号, v版本)
44 | raise ValueError("不支持的连接,型号")
--------------------------------------------------------------------------------
/网络设备脚本/深信服应用交付网页/全局显示.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 全局显示
2 | class C全局显示_ad70(全局显示.I全局显示):
3 | """适用于: ad 7.0.3"""
4 | def __init__(self, a设备):
5 | self.m设备 = a设备
6 | def f模式_设备(self):
7 | from . import 设备模式
8 | return 设备模式.C设备显示_ad70(self.m设备)
9 |
--------------------------------------------------------------------------------
/网络设备脚本/深信服应用交付网页/用户模式.py:
--------------------------------------------------------------------------------
1 | import time
2 | from ..基础接口 import 用户模式
3 | from ..基础接口 import 异常
4 | class C用户模式_ad70(用户模式.I用户模式):
5 | """适用于: ad 7.0.3"""
6 | def __init__(self, a设备):
7 | self.m设备 = a设备
8 | def f模式_全局显示(self):
9 | from . import 全局显示
10 | return 全局显示.C全局显示_ad70(self.m设备)
11 | def f登录(self, a用户名, a密码):
12 | #输入
13 | w用户名 = self.m设备.f查找("//*[@id=\"user\"]")
14 | w用户名.f输入(a用户名)
15 | w密码 = self.m设备.f查找("//*[@id=\"password\"]")
16 | w密码.f输入(a密码)
17 | #登录
18 | w登录 = self.m设备.f查找("//*[@id=\"button\"]")
19 | w消息 = self.m设备.f查找("//*[@id=\"error_msg\"]")
20 | w登录.f点击()
21 | time.sleep(1)
22 | if not self.m设备.f查找_直到("//*[@id=\"id_top\"]", a超时 = 1):
23 | # 提示：请输入密码！
24 | # 提示：用户名或密码错误 (还有4次机会)
25 | v消息 = w消息.fg文本()
26 | if "用户名或密码错误" in v消息:
27 | raise 异常.X登录("用户名密码错误")
28 | time.sleep(1)
29 |
--------------------------------------------------------------------------------
/网络设备脚本/深信服应用交付网页/设备.py:
--------------------------------------------------------------------------------
1 | import time
2 | import cflw代码库py.cflw字符串 as 字符串
3 | from ..网页接口 import 设备
4 | from . import 模式
5 | class C设备_ad70(设备.I设备):
6 | """适用于: ad 7.0.3"""
7 | def __init__(self, a连接, a型号, a版本):
8 | 设备.I设备.__init__(self, a连接)
9 | self.m型号 = a型号
10 | self.m版本 = a版本
11 | self.m当前模式 = 模式.C模式_ad70.c主页
12 | v链接 = self.fg地址()
13 | self.m主机 = 字符串.f提取字符串之间(v链接, "//", "/")
14 | def f切换模式(self, aa模式: tuple):
15 | if self.m当前模式 == aa模式:
16 | return
17 | for v序号, v名称, v路径 in aa模式:
18 | v地址 = self.fg模式地址(v路径)
19 | self.fs地址(v地址)
20 | self.m当前模式 = aa模式
21 | def fg模式地址(self, a模式: str):
22 | return f"https://{self.m主机}{a模式}"
23 | def f模式_用户(self):
24 | from . import 用户模式
25 | return 用户模式.C用户模式_ad70(self)
26 |
--------------------------------------------------------------------------------
/网络设备脚本/深信服应用交付网页/设备模式.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 设备模式
2 | from . import 模式
3 | t模式 = 模式.C模式_ad70
4 | class C序列号页:
5 | """适用于: ad 7.0.3"""
6 | def __init__(self, a设备):
7 | self.m设备 = a设备
8 | def fg网关序号(self):
9 | self.m设备.f切换模式(t模式.c系统配置_序列号)
10 | w网关序号 = self.m设备.f查找("//*[@id=\"sn_id\"]")
11 | return w网关序号.fg文本()
12 | def fg基本授权序列号(self):
13 | self.m设备.f切换模式(t模式.c系统配置_序列号)
14 | w序列号 = self.m设备.f查找("//*[@id=\"base_sn\"]")
15 | return w序列号.fg文本()
16 | def fgSSL卸载授权序列号(self):
17 | self.m设备.f切换模式(t模式.c系统配置_序列号)
18 | w序列号 = self.m设备.f查找("//*[@id=\"ssl_sn\"]")
19 | return w序列号.fg文本()
20 | def fgTCP单边加速授权序列号(self):
21 | self.m设备.f切换模式(t模式.c系统配置_序列号)
22 | w序列号 = self.m设备.f查找("//*[@id=\"tcp_sn\"]")
23 | return w序列号.fg文本()
24 | def fgHTTP缓存授权序列号(self):
25 | self.m设备.f切换模式(t模式.c系统配置_序列号)
26 | w序列号 = self.m设备.f查找("//*[@id=\"http_sn\"]")
27 | return w序列号.fg文本()
28 | def fg智能DNS全局授权序列号(self):
29 | self.m设备.f切换模式(t模式.c系统配置_序列号)
30 | w序列号 = self.m设备.f查找("//*[@id=\"gfad_sn\"]")
31 | return w序列号.fg文本()
32 | def fg软件升级授权序列号(self):
33 | self.m设备.f切换模式(t模式.c系统配置_序列号)
34 | w序列号 = self.m设备.f查找("//*[@id=\"update_sn\"]")
35 | return w序列号.fg文本()
36 | class C设备显示_ad70(设备模式.I设备显示, C序列号页):
37 | """适用于: """
38 | def __init__(self, a设备):
39 | self.m设备 = a设备
40 | def f显示_序列号(self): #返回网关ID
41 | return self.fg网关序号()
42 |
--------------------------------------------------------------------------------
/网络设备脚本/深信服应用交付网页2/全局显示.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 全局显示
2 | from . import 模式
3 | class C全局显示_ad705(全局显示.I全局显示):
4 | """适用于: ad 7.0.8"""
5 | def __init__(self, a设备):
6 | self.m设备 = a设备
7 | def f模式_设备(self):
8 | from . import 设备模式
9 | return 设备模式.C设备显示_ad705(self.m设备)
10 | def f显示_路由表4(self):
11 | from . import 静态路由
12 | v静态路由 = 静态路由.C静态路由_ad705(self.m设备)
13 | return v静态路由.f显示_路由表()
--------------------------------------------------------------------------------
/网络设备脚本/深信服应用交付网页2/用户模式.py:
--------------------------------------------------------------------------------
1 | import time
2 | from ..基础接口 import 用户模式
3 | from ..基础接口 import 异常
4 | class C用户模式_ad705(用户模式.I用户模式):
5 | """适用于: ad 7.0.8"""
6 | def __init__(self, a设备):
7 | self.m设备 = a设备
8 | def f模式_全局显示(self):
9 | from . import 全局显示
10 | return 全局显示.C全局显示_ad705(self.m设备)
11 | def f登录(self, a用户名, a密码):
12 | #输入
13 | w用户名 = self.m设备.f查找("//input[@name=\"username\"]")
14 | w用户名.f输入(a用户名)
15 | w密码 = self.m设备.f查找("//input[@name=\"password\"]")
16 | w密码.f输入(a密码)
17 | w协议 = self.m设备.f查找("//input[@name=\"checkbox\"]")
18 | w协议.f选中()
19 | #登录
20 | w登录 = self.m设备.f查找("//button[@class=\"uedc-ppkg-login_product-submit\"]")
21 | w消息 = self.m设备.f查找("//div[@class=\"uedc-ppkg-login_product-tip\"]")
22 | w登录.f点击()
23 | if not self.m设备.f查找_直到("//div[@id=\"top_nav\"]", a超时 = 5):
24 | # 请输入合法的用户名
25 | # 请输入合法的密码
26 | # 身份验证-用户名或密码错误(剩余重试[4]次)
27 | v消息 = w消息.fg文本()
28 | if "用户名或密码错误" in v消息:
29 | raise 异常.X登录("用户名密码错误")
30 | time.sleep(1)
31 | self.m设备.f解析登录后地址()
--------------------------------------------------------------------------------
/网络设备脚本/深信服应用交付网页2/设备.py:
--------------------------------------------------------------------------------
1 | import time
2 | import cflw代码库py.cflw字符串 as 字符串
3 | from ..网页接口 import 设备
4 | from . import 模式
5 | class C设备_ad705(设备.I设备):
6 | """适用于: ad 7.0.8"""
7 | def __init__(self, a连接, a型号, a版本):
8 | 设备.I设备.__init__(self, a连接)
9 | self.m型号 = a型号
10 | self.m版本 = a版本
11 | self.m主机 = None
12 | self.m会话标识 = None #url中的x_id参数
13 | self.m当前模式 = None
14 | def f模式_用户(self):
15 | from . import 用户模式
16 | return 用户模式.C用户模式_ad705(self)
17 | def f解析登录后地址(self):
18 | """登录后调用
19 | 解析"https://x.x.x.x/index?x_id=9dd00700-fcdd-11ea-bb09-c400ada9c07e" """
20 | v链接 = self.fg地址()
21 | self.m主机 = 字符串.f提取字符串之间(v链接, "//", "/")
22 | self.m会话标识 = 字符串.f提取字符串之间(v链接, "x_id=", "&", a结束严谨 = False)
23 | def f切换模式(self, aa模式: tuple):
24 | if self.m当前模式 == aa模式:
25 | return #相同,不切换
26 | match len(aa模式):
27 | case 1:
28 | self.f切换模式_主模式(aa模式[0].m路径)
29 | case 2:
30 | self.f切换模式_主模式(aa模式[0].m路径)
31 | self.f切换模式_选项卡(aa模式[1].m路径)
32 | case _:
33 | raise ValueError()
34 | self.m当前模式 = aa模式
35 | def f切换模式_主模式(self, a路径: str):
36 | v地址 = f"https://{self.m主机}/index?x_id={self.m会话标识}#mod={a路径}"
37 | self.fs地址(v地址)
38 | time.sleep(0.5)
39 | def f切换模式_选项卡(self, a标识: str):
40 | w选项顶层 = self.f查找(f"//li[@utid=\"{a标识}\"]")
41 | w选项按钮 = w选项顶层.f查找("a[2]/em/span/span")
42 | w选项按钮.f点击()
43 | time.sleep(0.5)
--------------------------------------------------------------------------------
/网络设备脚本/深信服应用交付网页2/设备模式.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 设备模式
2 | from . import 模式
3 | t模式 = 模式.C模式_ad705
4 | class C授权管理页:
5 | """适用于: ad 7.0.8R5"""
6 | def __init__(self, a设备):
7 | self.m设备 = a设备
8 | def f切换并查找序列号(self, a序号: str):
9 | self.m设备.f切换模式(t模式.c系统管理_通用配置_授权管理)
10 | if not hasattr(self, "ma序列号"):
11 | self.ma序列号 = []
12 | #先找框,然后找序列号.序列号顺序固定
13 | w序列号总框 = self.m设备.f查找("//div[@class=\"mod_system__authorize__box\"]")
14 | for w单个序列号框 in w序列号总框.fe查找("div"):
15 | if w序列号 := w单个序列号框.f查找("//span[@class=\"mod_system__authorize__sn_text\"]"):
16 | v序列号s = w序列号.fg文本()[4:] #前4个字符是"序列号："要去掉
17 | self.ma序列号.append(v序列号s)
18 | else:
19 | self.ma序列号.append(None)
20 | return self.ma序列号[a序号]
21 | def fg网关序号(self):
22 | self.m设备.f切换模式(t模式.c系统管理_通用配置_授权管理)
23 | w序列号 = self.m设备.f查找("//div[@utid=\"gwid\"]")
24 | return w序列号.fg文本()
25 | def fg基本授权序列号(self):
26 | return self.f切换并查找序列号(0)
27 | def fgSSL卸载授权序列号(self):
28 | return self.f切换并查找序列号(1)
29 | def fgTCP单边加速授权序列号(self):
30 | return self.f切换并查找序列号(2)
31 | def fgHTTP缓存授权序列号(self):
32 | return self.f切换并查找序列号(3)
33 | def fg智能DNS全局授权序列号(self):
34 | return self.f切换并查找序列号(4)
35 | def fg软件升级授权序列号(self):
36 | return self.f切换并查找序列号(5)
37 | class C设备显示_ad705(设备模式.I设备显示, C授权管理页):
38 | """适用于: """
39 | def __init__(self, a设备):
40 | self.m设备 = a设备
41 | def f显示_序列号(self): #返回网关ID
42 | return self.fg网关序号()
43 |
--------------------------------------------------------------------------------
/网络设备脚本/深信服应用交付网页2/静态路由.py:
--------------------------------------------------------------------------------
1 | import time
2 | import pandas #pandas
3 | import cflw代码库py.cflw网络地址 as 地址
4 | from ..基础接口 import 静态路由
5 | from ..基础接口 import 路由
6 | from ..基础接口 import 数据表
7 | from . import 模式
8 | def f解析路由条目(a元素): #div
9 | """适用于: ad 7.0.8"""
10 | #选择 名称 网络号 掩码/前缀 网关地址 网关状态 权重 支持重分发 网关健康检查 启/禁用 操作
11 | v选择s, v名称s, v网络号s, v掩码前缀s, v网关地址s, v网关状态s, v权重s, v支持重分发s, v网关健康检查s, v启禁用s, v操作s = map(lambda x: x.fg文本(), a元素.fe查找("td"))
12 | return {
13 | 数据表.E字段.e目的路由类型: 路由.E路由类型.e静态,
14 | 数据表.E字段.e目的网络号: 地址.S网络地址4.fc地址前缀长度(v网络号s, int(v掩码前缀s)),
15 | 数据表.E字段.e目的下一跳: 地址.S网络地址4.fc地址前缀长度(v网关地址s, 32),
16 | 数据表.E字段.e目的度量值: int(v权重s),
17 | }
18 | class C静态路由_ad705(静态路由.I静态路由配置):
19 | """适用于: ad 7.0.8"""
20 | c工具栏路径 = "/html/body/div[2]/div/div[2]/div[2]/div/div/div[2]/div/div[2]/div/div/div[2]/div/div/div/div[1]/div/table/tbody/tr/td[1]/table/tbody/tr"
21 | c表格路径 = "/html/body/div[2]/div/div[2]/div[2]/div/div/div[2]/div/div[2]/div/div/div[2]/div/div/div/div[2]/div/div[1]/div[2]/div"
22 | def __init__(self, a设备):
23 | self.m设备 = a设备
24 | def f切换到当前模式(self):
25 | self.m设备.f切换模式(模式.C模式_ad705.c网络部署_静态路由)
26 | def f显示_路由表(self):
27 | self.f切换到当前模式()
28 | time.sleep(1) #表格会一直变化,元素会失效
29 | w表格 = self.m设备.f查找(C静态路由_ad705.c表格路径)
30 | def fe行():
31 | for w行 in map(lambda x: x.f查找("table/tbody/tr"), w表格.fe查找("div")):
32 | yield f解析路由条目(w行)
33 | return pandas.DataFrame(fe行())
--------------------------------------------------------------------------------
/网络设备脚本/深信服防火墙命令行/全局显示.py:
--------------------------------------------------------------------------------
1 | from ..命令行接口 import 全局显示
2 | from ..命令行接口 import 模式
3 | #from . import 基本表信息
4 | #===============================================================================
5 | # 全局显示
6 | #===============================================================================
7 | class C全局显示v8(全局显示.I全局显示, 模式.I显示模式):
8 | def __init__(self, a):
9 | 模式.I显示模式.__init__(self, a)
--------------------------------------------------------------------------------
/网络设备脚本/深信服防火墙命令行/全局配置.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 操作
2 | from ..基础接口 import 协议
3 | from ..基础接口 import 接口 as 北向接口
4 | from ..命令行接口 import 全局配置
5 | class C全局配置v8(全局配置.I全局配置):
6 | def __init__(self, a):
7 | 全局配置.I全局配置.__init__(self, a)
8 | def fg进入命令(self):
9 | return "config"
10 | #模式
11 | def f模式_接口(self, a接口, a操作 = 操作.E操作.e设置):
12 | from . import 接口 as 实现接口
13 | v接口 = 实现接口.f创建接口(a接口)
14 | v模式 = 实现接口.C接口配置v8(self, v接口)
15 | return v模式
16 | def f模式_区域(self, a名称, a操作 = 操作.E操作.e设置):
17 | from . import 区域 as 实现区域
18 | v模式 = 实现区域.C区域配置v8(self, a名称)
19 | if 操作.fi减操作(a操作):
20 | v命令 = v模式.fg删除命令()
21 | self.f执行当前模式命令(v命令)
22 | return v模式
--------------------------------------------------------------------------------
/网络设备脚本/深信服防火墙命令行/区域.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 区域
2 | from ..基础接口 import 操作
3 | from ..命令行接口 import 模式
4 | from ..命令行接口 import 命令
5 | from ..深信服防火墙命令行.常量 import *
6 | from . import 接口 as 实现接口
7 | ca类型 = {
8 | 区域.E类型.e二层: "switch",
9 | 区域.E类型.e三层: "route",
10 | 区域.E类型.e虚拟: "virtual",
11 | }
12 | class C区域配置v8(区域.I区域配置, 模式.I模式):
13 | def __init__(self, a, a名称: str):
14 | 模式.I模式.__init__(self, a)
15 | self.m名称 = a名称
16 | def fg进入命令(self):
17 | """命令: zone 名称"""
18 | return f"zone {self.m名称}"
19 | def fg删除命令(self):
20 | """命令: no zone 名称"""
21 | return f"no zone {self.m名称}"
22 | def fs类型(self, a类型, a操作 = 操作.E操作.e设置):
23 | """命令: forward-type 类型"""
24 | if 操作.fi关操作(a操作):
25 | return #区域类型不能删除,跳过
26 | v命令 = 命令.C命令("forward-type")
27 | v命令 += ca类型[a类型]
28 | self.f执行当前模式命令(v命令)
29 | def fs接口(self, a接口, a操作 = 操作.E操作.e添加):
30 | """命令: [no] interface 接口"""
31 | v命令 = 命令.C命令("interface")
32 | v接口 = 实现接口.f创建接口(a接口)
33 | v命令 += v接口
34 | v命令.f前置肯定(操作.fi减操作(a操作), c不)
35 | self.f执行当前模式命令(v命令)
--------------------------------------------------------------------------------
/网络设备脚本/深信服防火墙命令行/常量.py:
--------------------------------------------------------------------------------
1 | c不 = "no "
2 | c做 = "do "
3 | c默认 = "default "
4 | c结束符 = '\x03' #ctrl+c
5 | c注释1 = "!"
6 | c注释2 = "#"
7 | c命令_关闭 = "shutdown"
8 | c命令_描述 = "description"
--------------------------------------------------------------------------------
/网络设备脚本/深信服防火墙命令行/用户模式.py:
--------------------------------------------------------------------------------
1 | import time
2 | from ..基础接口 import 异常
3 | from ..命令行接口 import 用户模式
4 | class C执行模式v8(用户模式.I用户模式): #深信服文档有写，进入到命令行的模式叫执行模式
5 | def f模式_全局配置(self):
6 | from . import 全局配置
7 | return 全局配置.C全局配置v8(self)
8 | def f模式_全局显示(self):
9 | from . import 全局显示
10 | return 全局显示.C全局显示v8(self)
11 | #动作
12 | def f登录(self, a用户名 = "", a密码 = ""): #深信服命令行只有ssh
13 | self.m设备.f切换到当前连接()
14 | self.f记住登录(a用户名, a密码)
15 | self.m设备.f输入_回车()
16 | self.f切换到当前模式()
17 |
--------------------------------------------------------------------------------
/网络设备脚本/深信服防火墙命令行/设备.py:
--------------------------------------------------------------------------------
1 | from ..命令行接口 import 设备 as 南向设备
2 | from ..命令行接口 import 命令
3 | from ..命令行接口 import 用户模式
4 | from .常量 import *
5 | ca错误文本与异常类 = []
6 | class C设备v8(南向设备.I设备): #适用于8.0.35以上版本
7 | def __init__(self, a连接, a型号, a版本):
8 | 南向设备.I设备.__init__(self, a连接)
9 | self.m连接.fs编码("utf-8")
10 | self.fs自动换页("--More--")
11 | self.m型号 = a型号
12 | self.m版本 = a版本
13 | def f退出(self):
14 | self.f执行命令("exit")
15 | def f输入_结束符(self): #ctrl+c
16 | self.f输入(c结束符)
17 | def f模式_用户(self):
18 | from . import 用户模式 as 实现用户模式
19 | v模式 = 实现用户模式.C执行模式v8(self)
20 | # self.fs顶级模式(v模式)
21 | return v模式
22 | def f执行命令(self, a命令):
23 | v输出 = 南向设备.I设备.f执行命令(self, a命令)
24 | return v输出
25 | def f执行用户命令(self, a命令):
26 | v命令 = 命令.C命令(a命令)
27 | if not isinstance(self.fg当前模式(), 用户模式.I用户模式): #在配置模式，命令前要加个do
28 | v命令.f前面添加(c做)
29 | v输出 = self.f执行命令(v命令)
30 | v输出 = v输出.replace("\r\n", "\n")
31 | return v输出
32 | def f处理显示命令(self, a命令):
33 | v命令 = 命令.C命令(a命令)
34 | if not isinstance(self.fg当前模式(), 用户模式.I用户模式): #在配置模式，命令前要加个do
35 | v命令.f前面添加(c做)
36 | return str(v命令)
37 | def f处理显示结果(self, a输出):
38 | v输出 = a输出.replace("\r\n", "\n")
39 | v输出 = 南向设备.f去头尾行(v输出)
40 | return v输出
41 |
--------------------------------------------------------------------------------
/网络设备脚本/深信服防火墙网页/全局显示.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 全局显示
2 | from . import 模式
3 | class C全局显示(全局显示.I全局显示):
4 | """适用于:v8.0.7~8.0.13"""
5 | def __init__(self, a设备):
6 | self.m设备 = a设备
7 | def f显示_中央处理器利用率(self):
8 | self.m设备.f切换模式(模式.C模式af8.c运行状态_总览)
9 | w资源利用率 = self.m设备.f查找('//*[@id="ext-comp-1049"]')
10 | w处理器利用率 = w资源利用率.f查找("ul/li[1]")
11 | from . import 系统信息
12 | return 系统信息.f解析利用率(w处理器利用率.fg文本())
13 | def f显示_内存利用率(self):
14 | self.m设备.f切换模式(模式.C模式af8.c运行状态_总览)
15 | w资源利用率 = self.m设备.f查找('//*[@id="ext-comp-1049"]')
16 | w内存利用率 = w资源利用率.f查找("ul/li[2]")
17 | from . import 系统信息
18 | return 系统信息.f解析利用率(w内存利用率.fg文本())
19 | def f显示_路由表4(self):
20 | from . import 路由表信息
21 | v查看路由 = 路由表信息.C查看路由(self.m设备)
22 | return v查看路由.f显示_路由表()
--------------------------------------------------------------------------------
/网络设备脚本/深信服防火墙网页/全局配置.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 全局配置
2 | class C全局配置(全局配置.I全局配置):
3 | """适用于:v8.0.7~8.0.13"""
4 | def __init__(self, a设备):
5 | self.m设备 = a设备
--------------------------------------------------------------------------------
/网络设备脚本/深信服防火墙网页/用户模式.py:
--------------------------------------------------------------------------------
1 | import time
2 | from ..基础接口 import 用户模式
3 | from ..基础接口 import 异常
4 | from ..网页接口 import 图片
5 | class C用户模式(用户模式.I用户模式):
6 | """适用于:v8.0.7~8.0.13"""
7 | def __init__(self, a设备):
8 | self.m设备 = a设备
9 | def f模式_全局配置(self):
10 | from . import 全局配置
11 | return 全局配置.C全局配置(self.m设备)
12 | def f模式_全局显示(self):
13 | from . import 全局显示
14 | return 全局显示.C全局显示(self.m设备)
15 | def f登录(self, a用户名: str, a密码: str):
16 | w用户名 = self.m设备.f查找("//*[@id=\"user\"]")
17 | w用户名.f输入(a用户名)
18 | w密码 = self.m设备.f查找("//*[@id=\"password\"]")
19 | w密码.f输入(a密码)
20 | # w验证码图 = self.m设备.f查找("//*[@id=\"captcha_img\"]")
21 | # v验证码图 = 图片.f取元素图片(self.m设备, w验证码图)
22 | # w验证码.f输入(图片.f处理验证码(v验证码图))
23 | w验证码 = self.m设备.f查找("//*[@id=\"verify\"]")
24 | w消息 = self.m设备.f查找("//*[@id=\"err_info\"]")
25 | w登录 = self.m设备.f查找("//*[@id=\"button\"]")
26 | for i in range(5):
27 | # 输入验证码并点击登录按钮
28 | v验证码 = 图片.f手动输入验证码(w验证码, 4)
29 | if v验证码:
30 | w登录.f点击()
31 | time.sleep(1)
32 | else:
33 | raise RuntimeError("请输入验证码")
34 | # 检查消息
35 | if w标头 := self.m设备.f查找_直到("//*[@id=\"header\"]", a超时 = 1): # 提示：正在登录，请稍后
36 | break
37 | v消息 = w消息.fg文本()
38 | if "验证码输入不正确" in v消息: # 提示：验证码输入不正确，请重新输入
39 | continue
40 | elif "用户名或密码不正确" in v消息: # 提示：用户名或密码不正确!您还剩下9次尝试机会!
41 | raise 异常.X登录("用户名密码错误")
42 | break # ?
43 | else:
44 | raise 异常.X登录("登录失败次数过多")
45 | # 结束
46 | self.m设备.f查找_直到('//*[@id="ext-gen100"]')
47 | time.sleep(1)
48 |
--------------------------------------------------------------------------------
/网络设备脚本/深信服防火墙网页/系统信息.py:
--------------------------------------------------------------------------------
1 | import cflw代码库py.cflw字符串 as 字符串
2 | def f解析利用率(a文本):
3 | #CPU 3%
4 | #内存 59%
5 | #硬盘 1%
6 | v利用率s = 字符串.f提取字符串之间(a文本, " ", "%")
7 | return float(v利用率s) * 0.01
--------------------------------------------------------------------------------
/网络设备脚本/深信服防火墙网页/路由表信息.py:
--------------------------------------------------------------------------------
1 | import pandas #pandas
2 | import cflw代码库py.cflw网络地址 as 地址
3 | from ..基础接口 import 协议
4 | from ..基础接口 import 路由
5 | from ..基础接口 import 数据表
6 | from . import 模式
7 | ca路由类型 = {
8 | "静态路由": 路由.E路由类型.e静态,
9 | "直接路由": 路由.E路由类型.e直连,
10 | "OSPF": 路由.E路由类型.e开放最短路径优先,
11 | "RIP": 路由.E路由类型.e路由信息协议,
12 | "BGP": 路由.E路由类型.e边界网关协议,
13 | "VPN路由": 路由.E路由类型.e本地,
14 | "SSL VPN路由": 路由.E路由类型.e本地,
15 | }
16 | def f解析路由条目4(a元素): #
17 | """适用于:v8.0.7~8.0.13"""
18 | v类型s, v目的s, v掩码s, v下一跳s, v度量值s, v接口s = map(lambda x: x.fg文本(), a元素.fe查找("td"))
19 | return {
20 | 数据表.E字段.e目的路由类型: ca路由类型[v类型s],
21 | 数据表.E字段.e目的网络号: 地址.S网络地址4.fc地址掩码(v目的s, v掩码s),
22 | 数据表.E字段.e目的下一跳: 地址.S网络地址4.fc地址前缀长度(v下一跳s, 32),
23 | 数据表.E字段.e目的度量值: int(v度量值s),
24 | }
25 | class C查看路由:
26 | """适用于:v8.0.7~8.0.13"""
27 | c表格路径 = "/html/body/div[2]/div[2]/div[2]/div/div/div/div/div/div/div/div/div[2]/div/div[2]/div/div[2]/div/div[2]/div[3]/div"
28 | def __init__(self, a设备):
29 | self.m设备 = a设备
30 | def f显示_路由表(self, a网络协议 = 协议.E协议.e网络协议4, a路由类型 = 0):
31 | #未完成,现在只能取一页,不支持自动换页
32 | self.m设备.f切换模式(模式.C模式af8.c网络_路由_查看路由, C查看路由.c表格路径)
33 | w表格 = self.m设备.f查找(C查看路由.c表格路径)
34 | def fe行():
35 | for w行 in map(lambda x: x.f查找("table/tbody/tr"), w表格.fe查找("div")):
36 | yield f解析路由条目4(w行)
37 | return pandas.DataFrame(fe行())
38 |
--------------------------------------------------------------------------------
/网络设备脚本/深信服防火墙网页2/全局显示.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 全局显示
2 | from . import 模式
3 | class C全局显示af8035(全局显示.I全局显示):
4 | """适用于:v8.0.35~"""
5 | def __init__(self, a设备):
6 | self.m设备 = a设备
7 | def f显示_中央处理器利用率(self):
8 | self.m设备.f切换模式(模式.C模式_af8035.c首页)
9 | c路径 = "/html/body/div[2]/div/div/div[2]/div/div[2]/div[2]/div[1]/div/div/div/div/div/div/div/div/div[2]/div/div/div/div/div/div/div/div/div/div/div[6]/div[2]/div/div/div/div/div[1]/div/div[2]/div/div/div/div[1]/div/div[2]/div/span[1]/span"
10 | w利用率 = self.m设备.f查找(c路径)
11 | from . import 系统信息
12 | return 系统信息.f解析利用率af8035(w利用率.fg文本())
13 | def f显示_内存利用率(self):
14 | self.m设备.f切换模式(模式.C模式_af8035.c首页)
15 | c路径 = "/html/body/div[2]/div/div/div[2]/div/div[2]/div[2]/div[1]/div/div/div/div/div/div/div/div/div[2]/div/div/div/div/div/div/div/div/div/div/div[6]/div[2]/div/div/div/div/div[1]/div/div[2]/div/div/div/div[2]/div/div[2]/div/span[1]/span"
16 | w利用率 = self.m设备.f查找(c路径)
17 | from . import 系统信息
18 | return 系统信息.f解析利用率af8035(w利用率.fg文本())
19 | def f显示_路由表4(self):
20 | from . import 路由表信息
21 | v查看路由 = 路由表信息.C查看路由af8035(self.m设备)
22 | return v查看路由.f显示_路由表()
23 |
--------------------------------------------------------------------------------
/网络设备脚本/深信服防火墙网页2/全局配置.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 全局配置
2 | class C全局配置af8035(全局配置.I全局配置):
3 | """适用于:v8.0.35~"""
4 | def __init__(self, a设备):
5 | self.m设备 = a设备
6 |
--------------------------------------------------------------------------------
/网络设备脚本/深信服防火墙网页2/系统信息.py:
--------------------------------------------------------------------------------
1 | def f解析利用率af8035(a文本):
2 | #26%
3 | v利用率s = a文本[:-1]
4 | return float(v利用率s) * 0.01
--------------------------------------------------------------------------------
/网络设备脚本/深信服防火墙网页2/设备.py:
--------------------------------------------------------------------------------
1 | import time
2 | from ..网页接口 import 设备
3 | from . import 模式
4 | class C设备af8035(设备.I设备):
5 | """适用于:v8.0.35~8.0.59
6 | 8.0.35换新界面, 菜单位置和旧版本不一样"""
7 | def __init__(self, a连接, a型号, a版本):
8 | 设备.I设备.__init__(self, a连接)
9 | self.m型号 = a型号
10 | self.m版本 = a版本
11 | self.ma模式 = 模式.C模式_af8035.c首页
12 | def f模式_用户(self):
13 | from . import 用户模式
14 | return 用户模式.C用户模式af8035(self)
15 | def f切换模式(self, aa模式: tuple, a等待元素 = None):
16 | #第1级在页面顶部, 第2级在左侧可展开/折叠, 默认展开, 第3,4级在左侧, 2,3,4在模式栈是同一级, 第5级在上侧
17 | #每一级判断是否相同,从不同的那一级开始切换
18 | if self.ma模式 == aa模式:
19 | return
20 | v原长度 = len(self.ma模式)
21 | v新长度 = len(aa模式)
22 | v长度 = min(v原长度, v新长度)
23 | for i in range(v长度):
24 | if self.ma模式[i] != aa模式[i]:
25 | break
26 | for j in range(i, v新长度):
27 | v序号, v文本, v路径 = aa模式[j]
28 | w按钮 = self.f查找_直到(v路径, af条件 = (lambda e: e.fg文本() == v文本))
29 | w按钮.f点击()
30 | time.sleep(1)
31 | self.ma模式 = aa模式
32 | if a等待元素:
33 | self.f查找_直到(a等待元素)
34 | time.sleep(1)
--------------------------------------------------------------------------------
/网络设备脚本/深信服防火墙网页2022/全局显示.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 全局显示
2 | from . import 模式
3 | class C全局显示_af8059(全局显示.I全局显示):
4 | """适用于: 深信服FW-2000-X210(af8.0.83)"""
5 | def __init__(self, a设备):
6 | self.m设备 = a设备
7 | def f模式_设备(self):
8 | from . import 设备模式
9 | return 设备模式.C设备显示_af8059(self.m设备)
10 |
--------------------------------------------------------------------------------
/网络设备脚本/深信服防火墙网页2022/全局配置.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 全局配置
2 | class C全局配置_af8059(全局配置.I全局配置):
3 | """适用于: 深信服FW-2000-X210(af8.0.83)"""
4 | def __init__(self, a设备):
5 | self.m设备 = a设备
6 |
--------------------------------------------------------------------------------
/网络设备脚本/深信服防火墙网页2022/设备.py:
--------------------------------------------------------------------------------
1 | import time
2 | from ..网页接口 import 设备
3 | from . import 模式
4 | class C设备_af8059(设备.I设备):
5 | """适用于: 深信服FW-2000-X210(af8.0.83)
6 | 8.0.59换新架构"""
7 | def __init__(self, a连接, a型号, a版本):
8 | 设备.I设备.__init__(self, a连接)
9 | self.m型号 = a型号
10 | self.m版本 = a版本
11 | self.ma模式 = 模式.C模式_af8059.c首页
12 | def f模式_用户(self):
13 | from . import 用户模式
14 | return 用户模式.C用户模式_af8059(self)
15 | def f切换模式(self, aa模式: tuple, a等待元素 = None):
16 | #第1级在页面顶部, 第2级在左侧可展开/折叠, 第3,4级在左侧且默认折叠隐藏, 2,3,4在模式栈是同一级, 第5级在上侧
17 | #每一级判断是否相同,从不同的那一级开始切换
18 | if self.ma模式 == aa模式:
19 | return
20 | v原长度 = len(self.ma模式)
21 | v新长度 = len(aa模式)
22 | v长度 = min(v原长度, v新长度)
23 | for i in range(v长度):
24 | if self.ma模式[i] != aa模式[i]:
25 | break
26 | for j in range(i, v新长度):
27 | v序号, v文本, v路径 = aa模式[j]
28 | if j != 0 and v序号 == 0: #除了顶级模式外,子模式默认进入第一个,不用重复进入
29 | continue
30 | w按钮 = self.f查找_直到(v路径, af条件 = (lambda e: e.fg文本() == v文本))
31 | w按钮.f点击()
32 | time.sleep(1)
33 | self.ma模式 = aa模式
34 | if a等待元素:
35 | self.f查找_直到(a等待元素)
36 | time.sleep(1)
--------------------------------------------------------------------------------
/网络设备脚本/深信服防火墙网页2022/设备模式.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 设备模式
2 | from . import 模式
3 | t模式 = 模式.C模式_af8059
4 | class C设备显示_af8059(设备模式.I设备显示):
5 | """适用于: 深信服FW-2000-X210(af8.0.83)"""
6 | def __init__(self, a设备):
7 | self.m设备 = a设备
8 | def f显示_序列号(self): #返回网关ID
9 | self.m设备.f切换模式(t模式.c系统_通用设置_授权管理)
10 | c路径 = "/html/body/div[1]/section/main/div/div/div/div/div/div/div/div[2]/div/div/div[2]/div[1]/div/div/div[1]/div[7]/span[2]"
11 | v元素 = self.m设备.f查找_直到(c路径)
12 | return v元素.fg文本()
--------------------------------------------------------------------------------
/网络设备脚本/瑞斯康达命令行/全局显示.py:
--------------------------------------------------------------------------------
1 | import cflw代码库py.cflw字符串 as 字符串
2 | from ..基础接口 import 全局显示
3 | from ..命令行接口 import 模式
4 | from . import 系统信息
5 | #===============================================================================
6 | # 全局显示
7 | #===============================================================================
8 | class C全局显示_sv3(全局显示.I全局显示, 模式.I显示模式):
9 | """适用于: 浪潮s6550(v3.x)"""
10 | #模式
11 | def f模式_设备(self):
12 | from . import 设备模式
13 | return 设备模式.C设备显示_sv3(self)
14 | def f模式_时间(self):
15 | from . import 时间
16 | return 时间.C时间显示_sv3(self)
17 | #显示
18 | def f显示_当前配置(self):
19 | self.m设备.f执行命令("show running-config")
20 | # Being processed.This may take a few minutes,please wait......
21 | v输出 = self.m设备.f输出显示结果(a最小等待 = 5)
22 | v输出 = self.m设备.f处理显示结果(v输出)
23 | return v输出
24 | def f显示_启动配置(self):
25 | v输出 = self.m设备.f执行显示命令("show startup-config")
26 | return v输出
27 |
--------------------------------------------------------------------------------
/网络设备脚本/瑞斯康达命令行/接口.py:
--------------------------------------------------------------------------------
1 | import cflw代码库py.cflw网络地址 as 地址
2 | from ..基础接口 import 操作
3 | from ..基础接口 import 接口 as 北向接口
4 | from ..命令行接口 import 命令
5 | from ..命令行接口 import 模式
6 | from ..命令行接口 import 接口 as 南向接口
7 | #s交换机v3
8 | ca接口名称_sv3 = 北向接口.ca接口名称 | {
9 | 北向接口.E类型.e空: "null",
10 | 北向接口.E类型.e环回: "loopback",
11 | 北向接口.E类型.e快速以太网: "fastethernet",
12 | 北向接口.E类型.e聚合: "port-channel",
13 | 北向接口.E类型.e吉以太网: "gigaethernet",
14 | 北向接口.E类型.e十吉以太网: "tengigabitethernet",
15 | 北向接口.E类型.e虚拟局域网: "vlan",
16 | 北向接口.E类型.e堆叠: "isf-port",
17 | }
18 | ca接口缩写_sv3 = ca接口名称_sv3 | {
19 | 北向接口.E类型.e环回: "LO",
20 | 北向接口.E类型.e堆叠: "ISF",
21 | 北向接口.E类型.e聚合: "PC",
22 | 北向接口.E类型.e吉以太网: "GE",
23 | 北向接口.E类型.e十吉以太网: "TGE",
24 | 北向接口.E类型.e快速以太网: "FE",
25 | }
26 | f生成接口_sv3, f创建接口_sv3, = 北向接口.F接口工厂(ca接口名称_sv3)
27 | f生成接口缩写_sv3, f创建接口缩写_sv3 = 北向接口.F接口工厂(ca接口缩写_sv3)
28 |
--------------------------------------------------------------------------------
/网络设备脚本/瑞斯康达命令行/日志.py:
--------------------------------------------------------------------------------
1 | import cflw代码库py.cflw网络地址 as 地址
2 | from ..基础接口 import 操作
3 | from ..命令行接口 import 命令
4 | from ..命令行接口 import 模式
5 | from ..命令行接口 import 日志 as 南向日志
6 | #_sv3
7 | class C日志_sv3(模式.C同级模式, 南向日志.I日志配置):
8 | """适用于: 浪潮s6550(v3.x)"""
9 | def __init__(self, a):
10 | 南向日志.I日志配置.__init__(self, a)
11 | self.m地址 = None
12 | def f生成服务器地址(self, a地址 = None):
13 | if a地址:
14 | self.m地址 = 地址.fc网络地址(a地址)
15 | return 命令.C命令(f"logging host {self.m地址.fg地址s()}")
16 | def fs开关(self, a操作 = 操作.E操作.e开启):
17 | v操作 = 操作.f解析操作(a操作)
18 | if 操作.fi开操作(v操作):
19 | self.f执行当前模式命令("logging on")
20 | else:
21 | self.f执行当前模式命令("no logging on")
22 | def fs服务器地址(self, a地址, a操作 = 操作.E操作.e添加):
23 | v命令 = self.f生成服务器地址(a地址)
24 | self.f执行当前模式命令(v命令)
25 | def fs服务器严重级别(self, a级别, a操作 = 操作.E操作.e设置):
26 | if self.m地址:
27 | v命令 = self.f生成服务器地址()
28 | v命令 += int(a级别)
29 | self.f执行当前模式命令(v命令)
--------------------------------------------------------------------------------
/网络设备脚本/瑞斯康达命令行/时间.py:
--------------------------------------------------------------------------------
1 | import time
2 | import cflw代码库py.cflw字符串 as 字符串
3 | from ..基础接口 import 时间
4 | from ..命令行接口 import 命令
5 | from ..命令行接口 import 模式
6 | def f解析时间_sv3(a文本):
7 | #Clock display mode : default
8 | #Current system time : 2000-02-11,03:03:05.678
9 | #Timezone offset : +08:00-CCT
10 | v文本 = 字符串.f提取字符串之间(a文本, "Current system time : ", "\n", a结束严谨 = False)
11 | return time.strptime(v文本, "%Y-%m-%d,%H:%M:%S.%f")
12 | class C时间显示_sv3(时间.I时间显示, 模式.I显示模式):
13 | """适用于: 浪潮s6550(v3.x)"""
14 | def __init__(self, a):
15 | 模式.I显示模式.__init__(self, a)
16 | def f显示_时间(self):
17 | v输出 = self.m设备.f执行显示命令("show clock")
18 | return f解析时间_sv3(v输出)
19 | class C时间_sv3(模式.C同级模式, 时间.I时间配置):
20 | """适用于: 浪潮s6550(v3.x)"""
21 | def __init__(self, a):
22 | 模式.C同级模式.__init__(self, a)
23 | def fs日期时间(self, a日期时间):
24 | v时间 = 时间.f解析日期时间(a日期时间)
25 | v时间文本 = time.strftime("%H %M %S %Y %m %d", v时间)
26 | v命令 = "clock set " + v时间文本
27 | self.f执行当前模式命令(v命令)
28 | def fs时区(self, a时区):
29 | v时区 = 时间.f解析时区(a时区)
30 | v时区名, v符号, v时, v分 = 时间.f拆分时区(v时区)
31 | v命令 = 命令.C命令("clock timezone")
32 | v命令 += "+" if v符号 else "-"
33 | v命令 -= v时
34 | v命令 += v分
35 | v命令 += v时区名
36 | self.f执行当前模式命令(v命令)
37 |
--------------------------------------------------------------------------------
/网络设备脚本/瑞斯康达命令行/用户.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 操作
2 | from ..基础接口 import 用户 as 北向用户
3 | from ..命令行接口 import 模式
4 | from ..命令行接口 import 命令
5 | from ..命令行接口 import 用户 as 南向用户
6 | from ..思科命令行.常量 import *
7 | ca权限 = {
8 | 北向用户.E用户权限.e最低: 1,
9 | 北向用户.E用户权限.e最高: 15,
10 | }
11 | class C用户_sv3(模式.C同级模式, 南向用户.I用户配置):
12 | """用户模式
13 | 适用于: 浪潮s6550(v3.x)"""
14 | def __init__(self, a, a用户名):
15 | 南向用户.I用户配置.__init__(self, a, a用户名)
16 | def fg命令前缀(self):
17 | return 命令.C命令(f"user name {self.m用户名}")
18 | def fg删除命令(self):
19 | """没有命令"""
20 | return ""
21 | def fs密码(self, a密码, a操作 = 操作.E操作.e设置):
22 | """命令: user name 用户名 password 密码"""
23 | v命令 = self.fg命令前缀()
24 | v命令 += "password", a密码
25 | v输出 = self.f执行当前模式命令(v命令)
26 | # User exist,if you want to modify the user information,please input 'yes' to confirm:
27 | if "confirm" in v输出:
28 | self.m设备.f执行命令("yes")
29 | def fs权限(self, a权限, a操作 = 操作.E操作.e设置):
30 | """命令: user name 用户名 privilege 权限"""
31 | v命令 = self.fg命令前缀()
32 | if a权限 in 北向用户.E用户权限:
33 | v权限 = ca权限[a权限]
34 | else:
35 | v权限 = int(a权限)
36 | v命令 += "privilege", v权限
37 | self.f执行当前模式命令(v命令)
38 | def fs服务类型(self, a服务类型, a操作 = None):
39 | """命令: user 用户名 service-type 服务类型"""
40 | pass
--------------------------------------------------------------------------------
/网络设备脚本/瑞斯康达命令行/用户模式.py:
--------------------------------------------------------------------------------
1 | import time
2 | from ..命令行接口 import 用户模式
3 | #===============================================================================
4 | # s系列(v3.x)
5 | #===============================================================================
6 | class C用户模式_sv3(用户模式.I用户模式):
7 | """适用于: 浪潮s6550(v3.x)"""
8 | def __init__(self, a):
9 | 用户模式.I用户模式.__init__(self, a)
10 | #模式
11 | def f模式_全局配置(self):
12 | from . import 全局配置
13 | return 全局配置.C全局配置_sv3(self)
14 | def f模式_全局显示(self):
15 | from . import 全局显示
16 | return 全局显示.C全局显示_sv3(self)
17 | #操作
18 | def f登录(self, a用户名 = "", a密码 = ""):
19 | self.m设备.f切换到当前连接()
20 | time.sleep(0.5)
21 | self.f记住登录(a用户名, a密码)
22 | v输出 = self.m设备.f输出()[-100:]
23 | if "Username:" in v输出:
24 | v输出 = self.m设备.f执行命令(self.m登录用户名)
25 | if "Password:" in v输出:
26 | self.m设备.f执行命令(self.m登录密码)
27 | self.f切换到当前模式()
28 | time.sleep(0.5)
29 | def f保存配置(self):
30 | self.f执行当前模式命令("write")
--------------------------------------------------------------------------------
/网络设备脚本/瑞斯康达命令行/系统信息.py:
--------------------------------------------------------------------------------
1 | import cflw代码库py.cflw字符串 as 字符串
2 | def f解析中央处理器利用率(a文本):
3 | v数字s = 字符串.f提取字符串之间(a文本, "Last 1 minute CPU utilization:", "%")
4 | return float(v数字s) * 0.01
5 | def f解析内存利用率(a文本):
6 | v数字s = 字符串.f提取字符串之间(a文本, "memory utilization :", "%")
7 | return float(v数字s) * 0.01
8 |
--------------------------------------------------------------------------------
/网络设备脚本/瑞斯康达命令行/设备.py:
--------------------------------------------------------------------------------
1 | from .. import 浪潮
2 | from ..命令行接口 import 设备 as 南向设备
3 | from ..命令行接口 import 命令
4 | from ..命令行接口 import 用户模式
5 | #===============================================================================
6 | # s系列(v3.x)
7 | #===============================================================================
8 | class C设备_sv3_50(南向设备.I设备):
9 | """适用于: 浪潮s6550(v3.x)"""
10 | def __init__(self, a连接, a型号, a版本):
11 | 南向设备.I设备.__init__(self, a连接)
12 | self.m型号 = a型号
13 | self.m版本 = a版本
14 | self.fs自动换页("--More--")
15 | #输入输出
16 | def f输入_结束符(self):
17 | self.f输入('\x1a') #ctrl+z
18 | #模式
19 | def f模式_用户(self):
20 | from . import 用户模式
21 | return 用户模式.C用户模式_sv3(self)
22 | #命令
23 | def f执行命令(self, a命令):
24 | v输出 = 南向设备.I设备.f执行命令(self, a命令)
25 | return v输出
26 | def f执行用户命令(self, a命令):
27 | #退到用户模式执行
28 | self.ma模式[0].f切换到当前模式()
29 | return self.f执行命令(a命令)
30 | def f准备显示(self):
31 | self.ma模式[0].f切换到当前模式()
32 | def f处理显示结果(self, a输出):
33 | v输出 = a输出.replace("\r\n", "\n")
34 | v输出 = 南向设备.f去头尾行(v输出)
35 | return v输出
36 | def f退出(self, a关闭 = False):
37 | self.f执行命令("exit")
38 | class C设备_sv3_60(C设备_sv3_50):
39 | """适用于: s6550(v3.60)"""
40 | def __init__(self, a连接, a型号, a版本):
41 | C设备_sv3_50.__init__(self, a连接, a型号, a版本)
42 | def f准备显示(self):
43 | pass
44 |
--------------------------------------------------------------------------------
/网络设备脚本/瑞斯康达命令行/设备模式.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 设备模式
2 | from ..命令行接口 import 模式
3 | from . import 系统信息
4 | from . import 硬件信息
5 | class C设备显示_sv3(设备模式.I设备显示, 模式.I显示模式):
6 | """适用于: 浪潮s6550(v3.x)"""
7 | def __init__(self, a):
8 | 模式.I显示模式.__init__(self, a)
9 | #硬件
10 | def f显示_风扇(self):
11 | v输出 = self.m设备.f执行显示命令("show fan-monitor status unit all")
12 | return 硬件信息.f风扇状态(v输出)
13 | def f显示_电源(self):
14 | v输出 = self.m设备.f执行显示命令("show environment power unit all")
15 | return 硬件信息.f电源全部(v输出)
16 | def f显示_温度(self):
17 | v输出 = self.m设备.f执行显示命令("show environment temperature unit all")
18 | return 硬件信息.f温度全部(v输出)
19 | #系统
20 | def f显示_中央处理器利用率(self):
21 | v输出 = self.m设备.f执行显示命令("show cpu-utilization")
22 | return 系统信息.f解析中央处理器利用率(v输出)
23 | def f显示_内存利用率(self):
24 | v输出 = self.m设备.f执行显示命令("show memory")
25 | return 系统信息.f解析内存利用率(v输出)
26 |
--------------------------------------------------------------------------------
/网络设备脚本/瑞斯康达命令行/路由表信息.py:
--------------------------------------------------------------------------------
1 | import cflw代码库py.cflw字符串 as 字符串
2 | import cflw代码库py.cflw网络地址 as 地址
3 | from ..基础接口 import 数据表
4 | from ..基础接口 import 信息
5 | from ..基础接口 import 路由 as 北向路由
6 | from . import 接口 as 实现接口
7 | ca路由类型 = {
8 | "C": 北向路由.E路由类型.e直连,
9 | "S": 北向路由.E路由类型.e静态,
10 | "R": 北向路由.E路由类型.e路由信息协议,
11 | "O": 北向路由.E路由类型.e开放最短路径优先,
12 | "I": 北向路由.E路由类型.e中间系统到中间系统,
13 | "B": 北向路由.E路由类型.e边界网关协议,
14 | }
15 | class F路由表4_sv3(数据表.I解析表格管线):
16 | """show ip route
17 | 适用于: 浪潮s6550-24xq-ac/d(v3.60.*)"""
18 | c标志 = 0
19 | c网络号 = 4
20 | c管理距离度量值 = 23
21 | c下一跳 = 38
22 | c寿命 = 55
23 | c接口 = 66
24 | ca列 = 数据表.C切割列(c标志, c网络号, c管理距离度量值, c下一跳, c寿命, c接口)
25 | c标题行 = "P&s Destination/Mask Dis/Metric NextHop Age Interface"
26 | def __init__(self):
27 | 数据表.I解析表格管线.__init__(self)
28 | self.f添加字段(数据表.E字段.e目的路由类型, lambda s: s[0], ca路由类型.get)
29 | self.f添加字段(数据表.E字段.e目的网络号, self.ca列[1], 地址.S网络地址4.fc地址前缀长度字符串)
30 | self.f添加字段(数据表.E字段.e目的管理距离, self.F取管理距离度量值(0), int)
31 | self.f添加字段(数据表.E字段.e目的度量值, self.F取管理距离度量值(1), int)
32 | self.f添加字段(数据表.E字段.e目的下一跳, self.ca列[3], 地址.S网络地址4.fc主机地址字符串)
33 | self.f添加字段(数据表.E字段.e本端出接口, self.ca列[5], 实现接口.f创建接口缩写_sv3)
34 | fi有效行 = staticmethod(数据表.F有效长度(c接口))
35 | f初始处理 = staticmethod(数据表.F去标题行(c标题行))
36 | def F取管理距离度量值(self, a序号: int):
37 | f取列 = self.ca列[2]
38 | def f(a行: str):
39 | v列 = f取列(a行)
40 | return v列.split("/")[a序号]
41 | return f
42 | f路由表4_sv3 = F路由表4_sv3()
43 |
--------------------------------------------------------------------------------
/网络设备脚本/盛科命令行/常量.py:
--------------------------------------------------------------------------------
1 | c不 = "no "
2 | c做 = "do "
3 | c默认 = "default "
4 | c结束符 = '\x03' #ctrl+c
5 | c注释1 = "!"
6 | c注释2 = "#"
--------------------------------------------------------------------------------
/网络设备脚本/盛科命令行/日志.py:
--------------------------------------------------------------------------------
1 | import cflw代码库py.cflw网络地址 as 地址
2 | from ..基础接口 import 操作
3 | from ..命令行接口 import 命令
4 | from ..命令行接口 import 模式
5 | from ..命令行接口 import 日志 as 南向日志
6 | #ev6
7 | class C日志ev6(模式.C同级模式, 南向日志.I日志配置):
8 | """适用于: 盛科e580(v6.x), 浪潮cn61108pcvh(v6.x), 浪潮s5350(v6.x)"""
9 | def __init__(self, a):
10 | 南向日志.I日志配置.__init__(self, a)
11 | def fs服务器开关(self, a操作 = 操作.E操作.e开启):
12 | v操作 = 操作.f解析操作(a操作)
13 | if 操作.fi开操作(v操作):
14 | self.f执行当前模式命令("logging server enable")
15 | else:
16 | self.f执行当前模式命令("logging server disable")
17 | def fs服务器地址(self, a地址, a操作 = 操作.E操作.e添加):
18 | self.f执行当前模式命令(f"logging server address {a地址}")
19 | def fs服务器严重级别(self, a级别, a操作 = 操作.E操作.e设置):
20 | self.f执行当前模式命令(f"logging server severity {int(a级别)}")
21 |
--------------------------------------------------------------------------------
/网络设备脚本/盛科命令行/时间.py:
--------------------------------------------------------------------------------
1 | import time
2 | import cflw代码库py.cflw字符串 as 字符串
3 | from ..基础接口 import 时间 as 时间
4 | from ..命令行接口 import 命令
5 | from ..命令行接口 import 模式
6 | def f解析时间_ev6(a文本):
7 | #09:17:30 UTC Tue Jul 09 2019
8 | v文本 = 字符串.f去词(a文本, 1)
9 | return time.strptime(v文本, "%H:%M:%S %a %b %d %Y")
10 | class C时间显示_ev6(时间.I时间显示, 模式.I显示模式):
11 | """适用于: 盛科e580(v6.x), 浪潮cn61108pcvh(v6.x), 浪潮s5350(v6.x)"""
12 | def __init__(self, a):
13 | 模式.I显示模式.__init__(self, a)
14 | def f显示_时间(self):
15 | v输出 = self.m设备.f执行显示命令("show clock")
16 | from . import 时间
17 | return 时间.f解析时间_ev6(v输出)
18 | class C时间_ev6(模式.C同级模式, 时间.I时间配置):
19 | """适用于: 盛科e580(v6.x), 浪潮cn61108pcvh(v6.x), 浪潮s5350(v6.x)"""
20 | def __init__(self, a):
21 | 模式.C同级模式.__init__(self, a)
22 | def fs日期时间(self, a日期时间):
23 | v时间 = 时间.f解析日期时间(a日期时间)
24 | v时间文本 = time.strftime("%H:%M:%S %m %d %Y", v时间)
25 | v命令 = "clock set " + v时间文本
26 | self.f执行当前模式命令(v命令)
27 | def fs时区(self, a时区):
28 | v时区 = 时间.f解析时区(a时区)
29 | v时区名, v符号, v时, v分 = 时间.f拆分时区(v时区)
30 | v命令 = 命令.C命令("clock set timezone")
31 | v命令 += v时区名
32 | v命令 += "add" if v符号 else "minus"
33 | v命令 += v时
34 | if v分:
35 | v命令 += v分
36 | self.f执行当前模式命令(v命令)
37 |
--------------------------------------------------------------------------------
/网络设备脚本/盛科命令行/用户.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 操作
2 | from ..基础接口 import 用户 as 北向用户
3 | from ..命令行接口 import 模式
4 | from ..命令行接口 import 命令
5 | from ..命令行接口 import 用户 as 南向用户
6 | from .常量 import *
7 | ca权限 = {
8 | 北向用户.E用户权限.e最低: 1,
9 | 北向用户.E用户权限.e最高: 4,
10 | }
11 | class C用户ev6(模式.C同级模式, 南向用户.I用户配置):
12 | """适用于: 盛科e580(v6.x), 浪潮cn61108pcvh(v6.x), 浪潮s5350(v6.x)"""
13 | def __init__(self, a, a用户名):
14 | 南向用户.I用户配置.__init__(self, a, a用户名)
15 | def fg命令前缀(self):
16 | return 命令.C命令(f"username {self.m用户名}")
17 | def fg删除命令(self):
18 | """命令: no username 用户名"""
19 | return self.fg命令前缀().f前面添加(c不)
20 | def fs密码(self, a密码, a操作 = 操作.E操作.e设置):
21 | """命令: username 用户名 password 密码"""
22 | v命令 = self.fg命令前缀()
23 | v命令 += "password", a密码
24 | self.f执行当前模式命令(v命令)
25 | def fs权限(self, a权限, a操作 = 操作.E操作.e设置):
26 | """命令: username 用户名 privilege 权限
27 | 最高4"""
28 | v命令 = self.fg命令前缀()
29 | if a权限 in 北向用户.E用户权限:
30 | v权限 = ca权限[a权限]
31 | else:
32 | v权限 = int(a权限)
33 | v命令 += "privilege", v权限
34 | self.f执行当前模式命令(v命令)
35 | def fs服务类型(self, a服务类型, a操作 = 操作.E操作.e设置):
36 | pass
37 |
--------------------------------------------------------------------------------
/网络设备脚本/盛科命令行/用户模式.py:
--------------------------------------------------------------------------------
1 | import time
2 | from ..命令行接口 import 用户模式
3 | #===============================================================================
4 | # cn系列(v6.x)
5 | #===============================================================================
6 | class C用户模式_ev6(用户模式.I用户模式):
7 |
8 | def __init__(self, a):
9 | 用户模式.I用户模式.__init__(self, a)
10 | def f自动登录(self):
11 | self.f登录()
12 | #事件
13 | def f事件_进入模式后(self):
14 | self.f登录自动刷新()
15 | #模式
16 | def f模式_全局配置(self):
17 | from . import 全局配置
18 | self.m设备.m自动关闭 |= True
19 | return 全局配置.C全局配置_ev6(self)
20 | def f模式_全局显示(self):
21 | from . import 全局显示
22 | return 全局显示.C全局显示_ev6(self)
23 | #动作
24 | def f登录(self, a用户名 = "", a密码 = ""):
25 | self.m设备.f切换到当前连接()
26 | time.sleep(0.5)
27 | self.f记住登录(a用户名, a密码)
28 | v输出 = self.m设备.f输出()[-100:]
29 | if "Username:" in v输出:
30 | v输出 = self.m设备.f执行命令(self.m登录用户名)
31 | if "Password:" in v输出:
32 | self.m设备.f执行命令(self.m登录密码)
33 | self.f切换到当前模式()
34 | self.m设备.mf自动登录 = self.f自动登录
35 | time.sleep(0.5)
36 | def f保存配置(self):
37 | self.f执行当前模式命令("write")
38 | class C用户模式_e580v6(C用户模式_ev6):
39 | """适用于: 盛科e580(v6.x), 浪潮cn61108pcvh(v6.2.27)"""
40 | def f模式_全局显示(self):
41 | from . import 全局显示
42 | return 全局显示.C全局显示_e580v6(self)
43 | class C用户模式_e530v6(C用户模式_ev6):
44 | """适用于: 盛科s530(v6.*), 浪潮s5350(v6.2.27)"""
45 | def f模式_全局显示(self):
46 | from . import 全局显示
47 | return 全局显示.C全局显示_e530v6(self)
48 |
--------------------------------------------------------------------------------
/网络设备脚本/盛科命令行/管理口信息.py:
--------------------------------------------------------------------------------
1 | import cflw代码库py.cflw字符串 as 字符串
2 | import cflw代码库py.cflw网络地址 as 地址
3 | from ..基础接口 import 数据表
4 | from ..基础接口 import 信息
5 | from . import 接口 as 实现接口
6 | #===============================================================================
7 | # 接口表
8 | #===============================================================================
9 | def f接口表(a文本: str):
10 | """show management interface
11 | 适用于: 浪潮s5350(v6.2.*)"""
12 | #===============================================================================
13 | # 网络接口表
14 | #===============================================================================
15 | def f网络接口表4(a文本: str):
16 | """show management ip address
17 | 适用于: 浪潮s5350(v6.2.*)"""
18 | def f网络接口表6(a文本: str):
19 | """show management ipv6 address
20 | 适用于: """
21 | raise NotImplementedError()
22 | #===============================================================================
23 | # 地址解析表
24 | #===============================================================================
25 | class F地址解析表(数据表.I解析表格管线):
26 | """show management arp
27 | 适用于: 浪潮s5350(v6.2.*)"""
28 | #===============================================================================
29 | # 路由表
30 | #===============================================================================
31 | def f路由表4(a文本: str):
32 | """show management ip address 构造vrf=mgmt-if的路由
33 | 适用于: 浪潮s5350(v6.2.*)"""
34 |
--------------------------------------------------------------------------------
/网络设备脚本/盛科命令行/系统信息.py:
--------------------------------------------------------------------------------
1 | import cflw代码库py.cflw字符串 as 字符串
2 | def f解析中央处理器利用率(a文本):
3 | """show processes cpu history"""
4 | v利用率s = 字符串.f提取字符串之间(a文本, "one minute:", "%")
5 | return float(v利用率s) * 0.01
6 | def f解析内存利用率(a文本):
7 | """show memory summary total"""
8 | v利用率s = 字符串.f提取字符串之间(a文本, "Memory utilization:", "%")
9 | return float(v利用率s) * 0.01
--------------------------------------------------------------------------------
/网络设备脚本/盛科命令行/网络终端.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 操作
2 | from ..命令行接口 import 命令
3 | from ..命令行接口 import 模式
4 | from ..命令行接口 import 网络终端 as 南向网络终端
5 | from .常量 import *
6 | from . import 接口 as 实现接口
7 | class C网络终端配置(南向网络终端.I网络终端配置, 模式.C同级模式):
8 | def __init__(self, a):
9 | 南向网络终端.I网络终端配置.__init__(self, a)
10 | def fs开关(self, a操作 = 操作.E操作.e开启):
11 | """service telnet {enable|disable}"""
12 | v命令 = 命令.C命令("service telnet")
13 | v命令 += "enable" if 操作.fi开操作(a操作) else "disable"
14 |
--------------------------------------------------------------------------------
/网络设备脚本/盛科命令行/设备模式.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 设备模式
2 | from ..命令行接口 import 模式
3 | from . import 系统信息
4 | from . import 硬件信息
5 | class C设备显示_ev6(设备模式.I设备显示, 模式.I显示模式):
6 | def __init__(self, a):
7 | 模式.I显示模式.__init__(self, a)
8 | def f显示_中央处理器利用率(self):
9 | v输出 = self.m设备.f执行显示命令("show processes cpu history")
10 | return 系统信息.f解析中央处理器利用率(v输出)
11 | def f显示_内存利用率(self):
12 | v输出 = self.m设备.f执行显示命令("show memory summary total")
13 | return 系统信息.f解析内存利用率(v输出)
14 | def f显示_电源(self):
15 | v输出 = self.m设备.f执行显示命令("show environment")
16 | return 硬件信息.f电源信息(v输出)
17 | def f显示_温度(self):
18 | v输出 = self.m设备.f执行显示命令("show environment")
19 | return 硬件信息.f温度信息(v输出)
20 | class C设备显示_e580v6(C设备显示_ev6):
21 | """适用于: 浪潮cn61108pcvh(v6.x)"""
22 | def f显示_风扇(self):
23 | v输出 = self.m设备.f执行显示命令("show environment")
24 | return 硬件信息.f风扇信息e580(v输出)
25 | class C设备显示_e530v6(C设备显示_ev6):
26 | """适用于: 浪潮s5350(v6.x)"""
27 | def __init__(self, a):
28 | C设备显示_ev6.__init__(self, a)
29 | def f显示_风扇(self):
30 | v输出 = self.m设备.f执行显示命令("show environment")
31 | return 硬件信息.f风扇信息e530(v输出)
32 |
--------------------------------------------------------------------------------
/网络设备脚本/盛科命令行/路由表信息.py:
--------------------------------------------------------------------------------
1 | import cflw代码库py.cflw字符串 as 字符串
2 | import cflw代码库py.cflw网络地址 as 地址
3 | from ..基础接口 import 数据表
4 | from ..基础接口 import 信息
5 | from ..基础接口 import 路由 as 北向路由
6 | from . import 接口 as 实现接口
7 | ca路由类型 = {
8 | "loopback": 北向路由.E路由类型.e本地,
9 | "connected": 北向路由.E路由类型.e直连,
10 | "static": 北向路由.E路由类型.e静态,
11 | }
12 | class F路由表4_ev6(数据表.I解析列表管线): #只有直连路由,缺少静态路由和动态路由,以后再改
13 | """show ip route
14 | 适用于: 浪潮cn61108pcvh(v6.2.27.13), 浪潮s5350(v6.2.27)"""
15 | c代码 = 0
16 | c网络号 = 9
17 | def __init__(self):
18 | 数据表.I解析列表管线.__init__(self)
19 | def fe记录(self, a文本: str):
20 | for v记录s in self.fe记录文本(a文本):
21 | v记录 = {}
22 | v代码s = v记录s[0: self.c网络号].strip()
23 | v是位置 = v记录s.find("is")
24 | v网络号s = v记录s[self.c网络号 : v是位置].strip()
25 | v记录[数据表.E字段.e目的网络号] = 地址.S网络地址4.fc地址前缀长度字符串(v网络号s)
26 | v逗号位置 = v记录s.find(",")
27 | v空格位置 = v记录s.rfind(" ", 0, v逗号位置)
28 | v路由类型s = v记录s[v空格位置+1 : v逗号位置].strip()
29 | v记录[数据表.E字段.e目的路由类型] = ca路由类型.get(v路由类型s)
30 | v接口s = v记录s[v逗号位置+1 :].strip()
31 | v记录[数据表.E字段.e本端出接口] = 实现接口.f创建接口_ev6(v接口s)
32 | yield v记录
33 | def f下一记录(self, a文本: str, a位置: int):
34 | v位置 = a文本.find("\n", a位置+1)
35 | return v位置
36 | def f初始处理(self, a文本: str)->str:
37 | v位置 = 字符串.f找下一行位置(a文本, 0, a循环 = 8)
38 | return a文本[v位置:]
39 | f路由表4_ev6 = F路由表4_ev6()
--------------------------------------------------------------------------------
/网络设备脚本/盛科命令行/链路层发现协议.py:
--------------------------------------------------------------------------------
1 | import functools
2 | import cflw代码库py.cflw工具_运算 as 运算
3 | import cflw代码库py.cflw字符串 as 字符串
4 | from ..基础接口 import 数据表
5 | from . import 接口 as 实现接口
6 | class F邻居简介ev6(数据表.I解析列表管线):
7 | """show lldp neighbor brief
8 | 适用于: 浪潮s5350(v6.2.27.R5.*)"""
9 | c本端端口 = "Local Port"
10 | c对端端口 = "Remote Port"
11 | c保持时间 = "Hold Time"
12 | c过期时间 = "Expire Time"
13 | c系统名称 = "System Name"
14 | c分割线 = "------------------------------------------------------------"
15 | c值开始 = 14
16 | def __init__(self):
17 | 数据表.I解析列表管线.__init__(self)
18 | self.f添加字段(数据表.E字段.e本端接口, 数据表.F列表字段(self.c本端端口), 实现接口.f创建接口_ev6)
19 | self.f添加字段(数据表.E字段.e对端接口, 数据表.F列表字段(self.c对端端口), str)
20 | self.f添加字段(数据表.E字段.e本端保持时间, 数据表.F列表字段(self.c保持时间), int)
21 | self.f添加字段(数据表.E字段.e本端寿命, 数据表.F列表字段(self.c过期时间), int)
22 | self.f添加字段(数据表.E字段.e对端名称, 数据表.F列表字段(self.c系统名称), str)
23 | f下一记录 = staticmethod(数据表.F下一记录(c分割线))
24 | fi有效记录 = staticmethod(数据表.F有效行数(5))
25 | f邻居简介ev6 = F邻居简介ev6()
--------------------------------------------------------------------------------
/网络设备脚本/盛科网页/全局显示.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 全局显示
2 | from . import 模式
3 | from . import 基本表信息
4 | class C全局显示_ev6(全局显示.I全局显示):
5 | """适用于: 浪潮s5350(v6.x)"""
6 | def __init__(self, a设备):
7 | self.m设备 = a设备
8 | def f显示_时间(self):
9 | self.m设备.f切换模式(模式.C模式_ev6.c系统管理_系统配置)
10 | w时间日期 = self.m设备.f查找("/html/body/div/table/tbody/tr/td/table/tbody/tr/td/table/tbody/tr[1]/td/table/tbody/tr[5]/td[2]/form/table/tbody/tr/td/table/tbody/tr[10]/td[3]/input")
11 | from . import 时间
12 | return 时间.f解析时间_ev6(w时间日期.fg文本())
13 | #表
14 | def f显示_接口表(self):
15 | return 基本表信息.C接口表ev6(self.m设备)
--------------------------------------------------------------------------------
/网络设备脚本/盛科网页/全局配置.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 全局配置
2 | from . import 模式
3 | class C全局配置_ev6(全局配置.I全局配置):
4 | """适用于: 浪潮s5350(v6.x)"""
5 | def __init__(self, a设备):
6 | self.m设备 = a设备
7 | def f模式_时间(self):
8 | from . import 时间
9 | return 时间.C时间_ev6(self.m设备)
10 | def fs设备名(self, a名称):
11 | self.m设备.f切换模式(模式.C模式_ev6.c系统管理_系统配置)
12 | w设备名 = self.m设备.f查找("/html/body/div/table/tbody/tr/td/table/tbody/tr/td/table/tbody/tr[1]/td/table/tbody/tr[5]/td[2]/form/table/tbody/tr/td/table/tbody/tr[6]/td[3]/input")
13 | w设备名.f输入(a名称)
14 | w应用 = self.m设备.f查找("/html/body/div/table/tbody/tr/td/table/tbody/tr/td/table/tbody/tr[1]/td/table/tbody/tr[5]/td[2]/form/table/tbody/tr/td/table/tbody/tr[8]/td[6]/input")
15 | w应用.f点击()
--------------------------------------------------------------------------------
/网络设备脚本/盛科网页/基本表信息.py:
--------------------------------------------------------------------------------
1 | import pandas
2 | from ..基础接口 import 数据表
3 | from ..基础接口 import 信息
4 | from . import 模式
5 | from ..盛科命令行 import 接口 as 实现接口
6 | from ..盛科命令行 import 基本表信息 as 命令行信息
7 | class C接口表ev6: #需重写
8 | """端口->端口状态
9 | 适用于: 浪潮s5350(v6.x)"""
10 | c表格路径 = "/html/body/div/form/table/tbody/tr/td/div/table/tbody/tr/td/table/tbody"
11 | def __init__(self, a设备):
12 | self.m设备 = a设备
13 | def __iter__(self):
14 | return self.fe行()
15 | def fe行(self):
16 | self.m设备.f切换模式(模式.C模式_ev6.c端口_端口状态)
17 | w表格 = self.m设备.f查找(C接口表ev6.c表格路径)
18 | for w行 in w表格.fe查找("tr"):
19 | if w行.fg属性("class") == "tableheader": #标题行
20 | continue
21 | w选择, w端口, w状态, w双工, w速率, w模式, w类型, w描述 = w行.fe查找("td")
22 | yield {
23 | 数据表.E字段.e本端接口: 实现接口.f创建接口_ev6(w端口.fg文本()),
24 | 数据表.E字段.e本端链路状态: 信息.f解析起宕状态(w状态.fg文本()),
25 | 数据表.E字段.e本端双工模式: 信息.f解析双工模式(w双工.fg文本()),
26 | 数据表.E字段.e本端速率: 命令行信息.f解析速率(w速率.fg文本()),
27 | 数据表.E字段.e本端描述: w描述.fg文本()
28 | }
29 | def f接口表ev6(a设备): #需重写
30 | v表 = C接口表ev6(a设备)
31 | return pandas.DataFrame(v表.fe行())
--------------------------------------------------------------------------------
/网络设备脚本/盛科网页/用户模式.py:
--------------------------------------------------------------------------------
1 | import time
2 | from ..基础接口 import 用户模式
3 | class C用户模式_ev6(用户模式.I用户模式):
4 | """适用于: 浪潮s5350(v6.x)"""
5 | def __init__(self, a设备):
6 | self.m设备 = a设备
7 | def f登录(self, a用户名 = "", a密码 = ""):
8 | time.sleep(0.5)
9 | w用户名 = self.m设备.f查找("//*[@id='name']")
10 | w用户名.f输入(a用户名)
11 | w密码 = self.m设备.f查找("/html/body/div/form/table/tbody/tr[2]/td[2]/input")
12 | w密码.f输入(a密码)
13 | w确定 = self.m设备.f查找("/html/body/div/form/table/tbody/tr[5]/th/input")
14 | w确定.f点击()
15 | time.sleep(0.5)
16 | #取会话
17 | self.m设备.f解析登录后地址()
18 | def f模式_全局配置(self):
19 | from . import 全局配置
20 | return 全局配置.C全局配置_ev6(self.m设备)
21 | def f模式_全局显示(self):
22 | from . import 全局显示
23 | return 全局显示.C全局显示_ev6(self.m设备)
--------------------------------------------------------------------------------
/网络设备脚本/盛科网页/设备.py:
--------------------------------------------------------------------------------
1 | import time
2 | import cflw代码库py.cflw字符串 as 字符串
3 | from ..网页接口 import 设备 as 网页设备
4 | class C设备_ev6(网页设备.I设备):
5 | """适用于: 盛科e580(v6.x), 浪潮cn61108pcvh(v6.x), 浪潮s5350(v6.x)"""
6 | def __init__(self, a连接, a型号, a版本):
7 | 网页设备.I设备.__init__(self, a连接)
8 | self.m型号 = a型号
9 | self.m版本 = a版本
10 | self.m主机 = None #登录后赋值
11 | self.m会话 = None #登录后赋值
12 | self.m当前模式 = None
13 | def f模式_用户(self):
14 | from . import 用户模式
15 | return 用户模式.C用户模式_ev6(self)
16 | def f解析登录后地址(self):
17 | """登录后调用
18 | 解析"http://x.x.x.x/web_index.cgi?sessionId=1573646679&lang=cn" """
19 | v链接 = self.fg地址()
20 | self.m主机 = 字符串.f提取字符串之间(v链接, "//", "/")
21 | self.m会话 = 字符串.f提取字符串之间(v链接, "sessionId=", "&")
22 | #模式
23 | def f切换模式(self, a模式):
24 | if self.m当前模式 == a模式:
25 | return
26 | v地址 = self.fg模式地址(a模式)
27 | self.fs地址(v地址)
28 | self.m当前模式 = a模式
29 | def fg模式地址(self, a模式):
30 | return f"http://{self.m主机}/{a模式}?sessionId={self.m会话}&lang=cn"
--------------------------------------------------------------------------------
/网络设备脚本/简单网管接口/信息.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 信息
2 | def f解析起宕状态(a值):
3 | return int(a值) == 1
--------------------------------------------------------------------------------
/网络设备脚本/简单网管接口/全局显示.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 全局显示
2 | from . import 模式
3 | from . import 标识
4 | from . import 基本表信息
5 | class I全局显示(全局显示.I全局显示, 模式.I模式):
6 | #系统
7 | def f获取_系统描述(self):
8 | return self.m设备.f获取(标识.c系统描述0)
9 | def f获取_系统名(self):
10 | return self.m设备.f获取(标识.c系统名称0)
11 | def f显示_设备名(self):
12 | return self.f获取_系统名()
13 | #网络
14 | def f显示_接口表(self):
15 | return 基本表信息.f接口表(self.m设备)
16 | def f显示_网络接口表4(self):
17 | return 基本表信息.f网络接口表4(self.m设备)
--------------------------------------------------------------------------------
/网络设备脚本/简单网管接口/全局配置.py:
--------------------------------------------------------------------------------
1 | from ..基础接口 import 全局配置
2 | from . import 模式
3 | class I全局配置(全局配置.I全局配置, 模式.I模式):
4 | #设置
5 | def f设置_系统名(self, a名称):
6 | self.m设备.f设置(".1.3.6.1.2.1.1.5.0", a名称)
7 | def fs设备名(self, a名称):
8 | self.f设置_系统名(a名称)
--------------------------------------------------------------------------------
/网络设备脚本/简单网管接口/基本表信息.py:
--------------------------------------------------------------------------------
1 | import cflw代码库py.cflw网络地址 as 地址
2 | from ..简单网管接口 import 标识
3 | from ..简单网管接口 import 信息
4 | from ..简单网管接口 import 数据表
5 | f接口表 = 数据表.F解析竖表管线(
6 | 数据表.C字段(数据表.E字段.e本端索引, 标识.c接口索引, int),
7 | 数据表.C字段(数据表.E字段.e本端描述, 标识.c接口描述, str),
8 | 数据表.C字段(数据表.E字段.e本端速率, 标识.c接口速率, int),
9 | 数据表.C物理地址字段(数据表.E字段.e本端物理地址, 标识.c接口物理地址),
10 | 数据表.C字段(数据表.E字段.e本端管理状态, 标识.c接口管理状态, 信息.f解析起宕状态),
11 | 数据表.C字段(数据表.E字段.e本端链路状态, 标识.c接口操作状态, 信息.f解析起宕状态),
12 | )
13 | f网络接口表4 = 数据表.F解析竖表管线(
14 | 数据表.C字段(数据表.E字段.e本端索引, 标识.c地址接口索引, int),
15 | 数据表.C网络地址字段(数据表.E字段.e本端网络地址4, 标识.c地址地址, 标识.c地址掩码)
16 | )
--------------------------------------------------------------------------------
/网络设备脚本/简单网管接口/标识.py:
--------------------------------------------------------------------------------
1 | #系统
2 | c系统描述0 = ".1.3.6.1.2.1.1.1.0"
3 | c系统启动时间0 = ".1.3.6.1.2.1.1.3.0"
4 | c系统联系0 = ".1.3.6.1.2.1.1.4.0"
5 | c系统名称0 = ".1.3.6.1.2.1.1.5.0"
6 | c系统位置0 = ".1.3.6.1.2.1.1.6.0"
7 | c系统服务0 = ".1.3.6.1.2.1.1.7.0"
8 | #接口
9 | c接口数量0 = ".1.3.6.1.2.1.2.1.0" #ifNumber
10 | c接口索引 = ".1.3.6.1.2.1.2.2.1.1" #ifIndex
11 | c接口描述 = ".1.3.6.1.2.1.2.2.1.2" #ifDescr
12 | c接口类型 = ".1.3.6.1.2.1.2.2.1.3" #ifType
13 | c接口最大传输单元 = ".1.3.6.1.2.1.2.2.1.4" #ifMTU
14 | c接口速率 = ".1.3.6.1.2.1.2.2.1.5" #ifSpeed
15 | c接口物理地址 = ".1.3.6.1.2.1.2.2.1.6" #IfPhysAddress
16 | c接口管理状态 = ".1.3.6.1.2.1.2.2.1.7" #ifAdminStatus
17 | c接口操作状态 = ".1.3.6.1.2.1.2.2.1.8" #ifOperStatus
18 | c接口最近变化 = ".1.3.6.1.2.1.2.2.1.9" #ifLastChange
19 | #网络地址4
20 | c地址地址 = ".1.3.6.1.2.1.4.20.1.1" #ipAdEntAddr
21 | c地址接口索引 = "1.3.6.1.2.1.4.20.1.2" #ipAdEntIfIndex
22 | c地址掩码 = ".1.3.6.1.2.1.4.20.1.3" #ipAdEntNetMask
23 | c地址广播地址 = ".1.3.6.1.2.1.4.20.1.4" #ipAdEntBcastAddr
24 | c路由网络号 = ".1.3.6.1.2.1.4.21.1.1" #ipRouteDest
25 | c路由接口索引 = ".1.3.6.1.2.1.4.21.1.2" #ipRouteIfIndex
26 | c路由度量值1 = ".1.3.6.1.2.1.4.21.1.3" #ipRouteMetric1
27 | c路由度量值2 = ".1.3.6.1.2.1.4.21.1.4" #ipRouteMetric2
28 | c路由度量值3 = ".1.3.6.1.2.1.4.21.1.5" #ipRouteMetric3
29 | c路由度量值4 = ".1.3.6.1.2.1.4.21.1.6" #ipRouteMetric4
30 | c路由下一跳 = ".1.3.6.1.2.1.4.21.1.7" #ipRouteNextHop
31 | c路由掩码 = ".1.3.6.1.2.1.4.21.1.11" #ipRouteMask
--------------------------------------------------------------------------------
/网络设备脚本/简单网管接口/模式.py:
--------------------------------------------------------------------------------
1 | from . import 设备
2 | class I模式:
3 | def __init__(self, a):
4 | if isinstance(a, 设备.I设备): #设备
5 | self.m设备 = a
6 | elif isinstance(a, I模式):
7 | self.m设备 = a.m设备
--------------------------------------------------------------------------------
/网络设备脚本/简单网管接口/设备.py:
--------------------------------------------------------------------------------
1 | import cflw代码库py.cflw简单网管_派 as 连接
2 | from ..基础接口 import 设备
3 | class I设备(设备.I设备):
4 | def __init__(self, a连接):
5 | self.m连接 = a连接
6 | self.m接口索引表 = None
7 | #SNMP
8 | def f获取(self, a标识, at类型 = None):
9 | return self.m连接.f获取(a标识, at类型)
10 | def f设置(self, a标识, a值, at类型 = None):
11 | return self.m连接.f设置(a标识, a值, at类型)
12 | def f遍历(self, a开始, a结束 = None, at类型 = None):
13 | return self.m连接.f遍历(a开始, a结束, at类型)
14 | def f陷阱(self, a标识, a值, at类型 = None):
15 | return self.m连接.f陷阱(a标识, a值, at类型)
16 | #缓存
17 | def fg接口索引表(self):
18 | from . import 接口
19 | if not self.m接口索引表:
20 | self.m接口索引表 = 接口.C接口索引表()
21 | self.m接口索引表.f更新(self)
22 | return self.m接口索引表
--------------------------------------------------------------------------------
/网络设备脚本/网页接口/图片.py:
--------------------------------------------------------------------------------
1 | import io
2 | import cflw代码库py.cflw时间 as 时间
3 | from . import 元素
4 | def f取元素图片(a设备, a元素):
5 | import PIL.Image #pillow
6 | v数据 = a设备.get_screenshot_as_png()
7 | v输入 = io.BytesIO(v数据)
8 | v图片 = PIL.Image.open(v输入)
9 | v图片.crop(a元素.fg矩形())
10 | return v图片
11 | def f手动输入验证码(a元素, a长度):
12 | """使验证码输入框获得焦点,让用户输入验证码"""
13 | v元素 = 元素.f包装(a元素)
14 | v元素.f聚焦()
15 | v循环阻塞 = 时间.C循环阻塞(60, a间隔 = 1)
16 | while v循环阻塞.f滴答():
17 | if len(v元素.fg文本()) >= a长度: #有输入
18 | return True
19 | else: #没有输入
20 | return False
21 | def f处理验证码(a图片):
22 | """显示验证码并提示输入,返回输入的内容"""
23 | raise NotImplementedError()
--------------------------------------------------------------------------------
/网络设备脚本/网页接口/设备.py:
--------------------------------------------------------------------------------
1 | import time
2 | from selenium.common import exceptions #selenium
3 | from selenium.webdriver.common.by import By #selenium
4 | from ..基础接口 import 设备
5 | from . import 元素
6 | import cflw代码库py.cflw时间 as 时间
7 | import cflw代码库py.cflw工具_运算 as 运算
8 | class I设备(设备.I设备):
9 | "封装selenium库的网页设备类"
10 | def __init__(self, a连接):
11 | self.m连接 = a连接
12 | self.m连接.implicitly_wait(8) #互联网8秒定律
13 | def fs地址(self, a地址):
14 | self.m连接.get(a地址)
15 | time.sleep(0.1)
16 | def fg地址(self):
17 | "返回统一资源定位符"
18 | return self.m连接.current_url
19 | def f查找(self, a找: str, a包装 = True):
20 | time.sleep(0.1)
21 | try:
22 | v元素 = self.m连接.find_element(By.XPATH, a找)
23 | return 元素.f包装(v元素, a包装)
24 | except exceptions.NoSuchElementException as e:
25 | return None
26 | def f查找_直到(self, a找: str, af条件 = 运算.f总是真, a超时: float = 10, a包装: bool = True):
27 | v计时 = 时间.C循环阻塞(a超时)
28 | while v计时.f滴答():
29 | if v元素 := self.f查找(a找, a包装):
30 | if af条件(v元素):
31 | return v元素
32 | return None
33 | def fe查找(self, a找: str, a包装 = True):
34 | f包装0 = 元素.F包装(a包装)
35 | for v元素 in self.m连接.find_elements(By.XPATH, a找):
36 | yield f包装0(v元素)
37 | def f等待存在(self, a找: str, a超时 = 10):
38 | v计时 = 时间.C循环阻塞(a超时)
39 | while v计时.f滴答():
40 | if self.f查找(a找):
41 | return
42 | def f等待不存在(self, a找: str, a超时 = 10):
43 | v计时 = 时间.C循环阻塞(a超时)
44 | while v计时.f滴答():
45 | if not self.f查找(a找):
46 | return
--------------------------------------------------------------------------------
/网络设备脚本/迈普.py:
--------------------------------------------------------------------------------
1 | import enum
2 | #===============================================================================
3 | # 工厂
4 | #===============================================================================
5 | class E型号(enum.IntEnum):
6 | mps4100 = 4100
7 | mps4120 = 4120
8 | def f创建设备(a连接, a型号, a版本 = 0):
9 | from .迈普命令行 import 设备
10 | return 设备.C设备(a连接, a型号, a版本)
11 |
--------------------------------------------------------------------------------
/网络设备脚本/迈普命令行/全局显示.py:
--------------------------------------------------------------------------------
1 | from ..命令行接口 import 全局显示
2 | from . import 基本表信息
3 | class C全局显示(全局显示.I全局显示):
4 | #显示
5 | def f显示_启动配置(self):
6 | v输出 = self.m设备.f执行显示命令("show startup-config")
7 | return v输出
8 | def f显示_当前配置(self):
9 | v输出 = self.m设备.f执行显示命令("show running-config")
10 | return v输出
11 | def f显示_时间(self):
12 | v命令 = "show clock"
13 | v输出 = self.m设备.f执行显示命令(v命令) #beijing(UTC+08:00) THU APR 04 11:11:12 2019
14 | #解析
15 | v空格位置 = 字符串.f全部找(v输出, " ")
16 | v行结束 = v输出.find("\n", v空格位置[0])
17 | if v行结束 > 0: #如果有换行符,截取到行结束
18 | v输出 = v输出[v空格位置[0]+1 : v行结束]
19 | else: #如果没有换行符,截取到字符串结束
20 | v输出 = v输出[v空格位置[0]+1:] #THU APR 04 11:11:12 2019
21 | v时间 = time.strptime(v输出, "%a %b %d %H:%M:%S %Y")
22 | return v时间
23 | def f显示_设备名(self):
24 | v命令 = "show running-config | include hostname"
25 | v输出 = self.m设备.f执行显示命令(v命令)
26 | v位置 = v输出.find("hostname")
27 | v行结束 = v输出.find("\n", v位置)
28 | return v输出[v位置 + 9 : v行结束]
29 | #显示具体
30 | def f显示_接口表(self):
31 | v命令 = "show interface switchport"
32 | v输出 = self.m设备.f执行显示命令(v命令)
33 | return 基本表信息.f交换接口表(v输出)
34 | def f显示_网络接口表4(self):
35 | v命令 = "show ip interface brief"
36 | v输出 = self.m设备.f执行显示命令(v命令)
37 | return 基本表信息.f网络接口表4(v输出)
38 |
--------------------------------------------------------------------------------
/网络设备脚本/迈普命令行/全局配置.py:
--------------------------------------------------------------------------------
1 | from ..命令行接口 import 全局配置
2 | from ..基础接口 import 操作
3 | from ..思科命令行 import 接口
4 | class C全局配置(全局配置.I全局配置):
5 | """适用于: mps4120(v6.6.4.1.3)"""
6 | def __init__(self, a):
7 | 全局配置.I全局配置.__init__(self, a)
8 | #命令
9 | def fg进入命令(self):
10 | return "configure terminal"
11 | #模式
12 | def f模式_接口(self, a接口, a操作 = 操作.E操作.e设置):
13 | v接口 = 接口.f创建接口(a接口)
14 | return 接口.C接口(self, v接口)
--------------------------------------------------------------------------------
/网络设备脚本/迈普命令行/用户模式.py:
--------------------------------------------------------------------------------
1 | import time
2 | import cflw代码库py.cflw字符串 as 字符串
3 | from ..命令行接口 import 用户模式
4 | from ..命令行接口 import 命令
5 | class C用户模式(用户模式.I用户模式):
6 | """适用于: mps4120(v6.6.4.1.3)"""
7 | def __init__(self, a):
8 | 用户模式.I用户模式.__init__(self, a)
9 | #模式
10 | def f事件_进入模式后(self):
11 | self.m设备.f刷新()
12 | self.m设备.f输入_结束符()
13 | self.m设备.f输入_回车(-1, 5)
14 | def f模式_全局配置(self):
15 | from . import 全局配置
16 | return 全局配置.C全局配置(self)
17 | def f模式_全局显示(self):
18 | from . import 全局显示
19 | return 全局显示.C全局显示(self)
20 | #动作
21 | def f登录(self, a用户名 = "", a密码 = ""):
22 | time.sleep(1)
23 | v输出 = self.m设备.f输出()
24 | if "Username:" in v输出:
25 | v输出 = self.m设备.f执行命令(a用户名)
26 | if "Password:" in v输出:
27 | self.m设备.f执行命令(a密码)
28 | def f提升权限(self, a密码 = "", a级别 = None):
29 | v命令 = 命令.C命令("enable")
30 | if a级别:
31 | v命令 += a级别
32 | self.f执行当前模式命令(v命令)
33 | self.m设备.f执行命令(a密码)
34 |
--------------------------------------------------------------------------------
/网络设备脚本/迈普命令行/设备.py:
--------------------------------------------------------------------------------
1 | import cflw代码库py.cflw网络连接 as 连接
2 | from ..命令行接口 import 设备 as 南向设备
3 | from ..思科命令行.常量 import *
4 | class C设备(南向设备.I设备):
5 | """适用于: mps4120(v6.6.4.1.3)"""
6 | def __init__(self, a连接, a型号, a版本):
7 | 南向设备.I设备.__init__(self)
8 | if a连接.c连接特性 & 连接.E连接特性.e命令行:
9 | self.m连接 = a连接
10 | self.m连接.fs编码("gb2312")
11 | else:
12 | raise TypeError("a连接 必须是 I连接 类型")
13 | self.m型号 = a型号
14 | self.m版本 = a版本
15 | self.fs自动换页("---MORE---")
16 | def f输入_结束符(self): #ctrl+c
17 | self.f输入(c结束符)
18 | def f处理显示结果(self, a输出):
19 | v输出 = a输出.replace("\r\n", "\n")
20 | v输出 = 南向设备.f去头尾行(v输出)
21 | return v输出
22 | #动作
23 | def f退出(self):
24 | self.f执行命令("exit")
25 | #模式
26 | def f模式_用户(self):
27 | from . import 用户模式
28 | v模式 = 用户模式.C用户模式(self)
29 | return v模式
30 |
--------------------------------------------------------------------------------
/网络设备脚本/锐捷.py:
--------------------------------------------------------------------------------
1 | import enum
2 | import cflw代码库py.cflw网络连接 as 连接
3 | #===============================================================================
4 | # 工厂
5 | #===============================================================================
6 | class E型号(enum.IntEnum):
7 | s5750 = 5750
8 | def f创建设备(a连接, a型号, a版本 = 0):
9 | if a连接.c连接特性 & 连接.E连接特性.e命令行: #命令行
10 | from .锐捷命令行 import 设备 as 设备
11 | return 设备.C设备(a连接, a型号, a版本)
12 | else:
13 | raise ValueError("参数错误")
14 |
--------------------------------------------------------------------------------
/网络设备脚本/锐捷命令行/全局显示.py:
--------------------------------------------------------------------------------
1 | from ..命令行接口 import 全局显示
2 | from . import 基本表信息
3 | class C全局显示(全局显示.I全局显示):
4 | #显示
5 | def f显示_启动配置(self):
6 | v输出 = self.m设备.f执行显示命令("show startup-config")
7 | return v输出
8 | def f显示_当前配置(self):
9 | v输出 = self.m设备.f执行显示命令("show running-config")
10 | return v输出
11 | def f显示_时间(self):
12 | v命令 = "show clock"
13 | v输出 = self.m设备.f执行显示命令(v命令) #09:22:03 beijing Thu, Apr 4, 2019
14 | #解析
15 | v空格位置 = 字符串.f全部找(v输出, " ")
16 | v行结束 = v输出.find("\n")
17 | if v行结束 > 0: #如果有换行符,截取到行结束
18 | v输出 = v输出[0 : v空格位置[0]] + v输出[v空格位置[1] : v行结束]
19 | else: #如果没有换行符,截取到字符串结束
20 | v输出 = v输出[0 : v空格位置[0]] + v输出[v空格位置[1]:] #09:22:03 Thu, Apr 4, 2019
21 | v时间 = time.strptime(v输出, "%H:%M:%S %a, %b %d, %Y")
22 | return v时间
23 | def f显示_设备名(self):
24 | v命令 = "show running-config | include hostname"
25 | v输出 = self.m设备.f执行显示命令(v命令)
26 | return v输出[9:]
27 | #显示具体
28 | def f显示_接口表(self):
29 | v命令 = "show interface status"
30 | v输出 = self.m设备.f执行显示命令(v命令)
31 | return 基本表信息.f接口表(v输出)
32 | def f显示_网络接口表4(self):
33 | v命令 = "show ip interface brief"
34 | v输出 = self.m设备.f执行显示命令(v命令)
35 | return 基本表信息.f网络接口表4(v输出)
36 |
--------------------------------------------------------------------------------
/网络设备脚本/锐捷命令行/用户模式.py:
--------------------------------------------------------------------------------
1 | import time
2 | import cflw代码库py.cflw字符串 as 字符串
3 | from ..命令行接口 import 用户模式
4 | from ..命令行接口 import 命令
5 | class C用户模式(用户模式.I用户模式):
6 | """适用于: s5750(v11.4)"""
7 | def __init__(self, a):
8 | 用户模式.I用户模式.__init__(self, a)
9 | #模式
10 | def f事件_进入模式后(self):
11 | self.m设备.f刷新()
12 | self.m设备.f输入_结束符()
13 | self.m设备.f输入_回车(-1, 5)
14 | def f模式_全局配置(self):
15 | from . import 全局配置
16 | return 全局配置.C全局配置(self)
17 | def f模式_全局显示(self):
18 | from . import 全局显示
19 | return 全局显示.C全局显示(self)
20 | #动作
21 | def f登录(self, a用户名 = "", a密码 = ""):
22 | time.sleep(1)
23 | v输出 = self.m设备.f输出()
24 | if "Username:" in v输出:
25 | v输出 = self.m设备.f执行命令(a用户名)
26 | if "Password:" in v输出:
27 | self.m设备.f执行命令(a密码)
28 | def f提升权限(self, a密码 = "", a级别 = None):
29 | v命令 = 命令.C命令("enable")
30 | if a级别:
31 | v命令 += a级别
32 | self.f执行当前模式命令(v命令)
33 | self.m设备.f执行命令(a密码)
34 | def f保存配置(self):
35 | self.f执行当前模式命令("write")
36 | def f清除配置(self):
37 | self.f执行当前模式命令("delete config.txt")
38 | self.m设备.f执行命令("y")
39 | def f重新启动(self):
40 | self.f执行当前模式命令("reload")
41 | self.m设备.f执行命令("y")
42 |
--------------------------------------------------------------------------------
/网络设备脚本/锐捷命令行/设备.py:
--------------------------------------------------------------------------------
1 | import cflw代码库py.cflw网络连接 as 连接
2 | from ..命令行接口 import 设备 as 南向设备
3 | from ..思科命令行.常量 import *
4 | class C设备(南向设备.I设备):
5 | """适用于: s5750(v11.4)"""
6 | def __init__(self, a连接, a型号, a版本):
7 | 南向设备.I设备.__init__(self)
8 | if a连接.c连接特性 & 连接.E连接特性.e命令行:
9 | self.m连接 = a连接
10 | self.m连接.fs编码("gb2312")
11 | else:
12 | raise TypeError("a连接 必须是 I连接 类型")
13 | self.m型号 = a型号
14 | self.m版本 = a版本
15 | self.fs自动换页("--More--")
16 | def f输入_结束符(self): #ctrl+c
17 | self.f输入(c结束符)
18 | def f处理显示结果(self, a输出):
19 | v输出 = a输出.replace("\r\n", "\n")
20 | v输出 = 南向设备.f去头尾行(v输出)
21 | return v输出
22 | #动作
23 | def f退出(self):
24 | self.f执行命令("exit")
25 | #模式
26 | def f模式_用户(self):
27 | from . import 用户模式
28 | v模式 = 用户模式.C用户模式(self)
29 | return v模式
30 | def f模式_启动(self):
31 | from . import 启动
32 | if self.m版本 < 10.4:
33 | return 启动.C启动v10(self)
34 | elif self.m版本 < 11:
35 | return 启动.C启动v1042(self)
36 | elif self.m版本 < 12:
37 | return 启动.C启动v11(self)
38 | else:
39 | return NotImplementedError("不支持的版本")
40 |
--------------------------------------------------------------------------------