diff --git a/0001-optimization-printing-progress-bar.patch b/0001-optimization-printing-progress-bar.patch new file mode 100644 index 0000000..3c48f24 --- /dev/null +++ b/0001-optimization-printing-progress-bar.patch @@ -0,0 +1,158 @@ +--- a/packageship/application/cli/commands/initialize.py ++++ b/packageship/application/cli/commands/initialize.py +@@ -15,7 +15,6 @@ Description: Entry method for custom commands + Class: InitDatabaseCommand + """ + import os +-import random + import time + import pwd + import threading +@@ -23,27 +22,23 @@ from packageship.application.cli.base import BaseCommand + from packageship.application.common.exc import InitializeError, ResourceCompetitionError + + +-class PrintThread(threading.Thread): ++class InitServiceThread(threading.Thread): + """ +- Description: Print Thread +- Attributes: +- ++ Description: Execute the initialization thread + """ + +- def __init__(self, *args, **kwargs): +- super(PrintThread, self).__init__(*args, **kwargs) +- self.__clear = False ++ def __init__(self, func, param, *args, **kwargs): ++ super(InitServiceThread, self).__init__(*args, **kwargs) ++ self._func = func ++ self._args = param ++ self.error = False + + def run(self): +- while True: +- print("\r", "initializing{}".format( +- "." * random.randint(1, 4)), end='', flush=True) +- time.sleep(0.5) +- if self.__clear: +- break +- +- def stop(self): +- self.__clear = True ++ try: ++ self._func(*self._args) ++ except (InitializeError, ResourceCompetitionError) as error: ++ self.error = True ++ print('\r', error) + + + class InitDatabaseCommand(BaseCommand): +@@ -63,6 +58,7 @@ class InitDatabaseCommand(BaseCommand): + 'init', help='initialization of the database') + self.params = [ + ('-filepath', 'str', 'specify the path of conf.yaml', '', 'store')] ++ self._char = ["/", "-", "\\"] + + def register(self): + """ +@@ -77,6 +73,13 @@ class InitDatabaseCommand(BaseCommand): + super(InitDatabaseCommand, self).register() + self.parse.set_defaults(func=self.do_command) + ++ @property ++ def login_user(self): ++ """ ++ Description: The user logged in to the system ++ """ ++ return pwd.getpwuid(os.getuid())[0] ++ + def do_command(self, params): + """ + Description: Action to execute command +@@ -88,10 +91,7 @@ class InitDatabaseCommand(BaseCommand): + + """ + +- def get_username(): +- return pwd.getpwuid(os.getuid())[0] +- +- if get_username() not in ["root", "pkgshipuser"]: ++ if self.login_user not in ["root", "pkgshipuser"]: + print("The current user does not have initial execution permission") + return + +@@ -100,14 +100,19 @@ class InitDatabaseCommand(BaseCommand): + file_path = params.filepath + if file_path: + file_path = os.path.abspath(file_path) +- try: +- print_t = PrintThread() +- print_t.start() +- init.import_depend(path=file_path) +- print_t.stop() +- except (InitializeError, ResourceCompetitionError) as error: +- print('\r', error) +- else: ++ ++ _init_service_thread = InitServiceThread( ++ func=init.import_depend, param=(file_path,)) ++ _init_service_thread.setDaemon(True) ++ _init_service_thread.start() ++ ++ while _init_service_thread.isAlive(): ++ for number in range(3): ++ print("\r", "initializing{}".format("." * 10), ++ self._char[number], end='', flush=True) ++ time.sleep(0.5) ++ print("\n") ++ if not _init_service_thread.error: + if init.success: + print('\r', 'Database initialize success') + else: + +--- a/packageship/application/initialize/integration.py ++++ b/packageship/application/initialize/integration.py +@@ -653,7 +653,7 @@ class RepoConfig: + + if not os.path.exists(path): + raise FileNotFoundError( +- "system initialization configuration file" ++ "system initialization configuration file " + "does not exist: %s" % path) + # load yaml configuration file + with open(path, 'r', encoding='utf-8') as file_context: +@@ -663,7 +663,7 @@ class RepoConfig: + except yaml.YAMLError as yaml_error: + LOGGER.error(yaml_error) + raise ValueError( +- "The format of the yaml configuration" ++ "The format of the yaml configuration " + "file is wrong please check and try again:{0}".format(yaml_error)) \ + from yaml_error + +@@ -748,9 +748,9 @@ class RepoConfig: + raise ValueError( + "content of the database initialization configuration file cannot be empty .") + if not isinstance(self._repo, list): +- raise ValueError("""format of the initial database configuration file isincorrect. +- When multiple databases need to be initialized, +- it needs to be configured in the form of multiple .""") ++ raise ValueError("format of the initial database configuration file is incorrect." ++ " When multiple databases need to be initialized," ++ " it needs to be configured in the form of multiple .") + self._validate_database() + for repo in self._repo: + try: + +--- a/packageship/pkgship ++++ b/packageship/pkgship +@@ -15,7 +15,7 @@ import signal + from signal import SIG_DFL + try: + def sig_handler(signum, frame): +- print('Exit command mode') ++ print("\n", 'Exit command mode') + sys.exit(0) + + signal.signal(signal.SIGINT, sig_handler) diff --git a/0002-update-doc.patch b/0002-update-doc.patch new file mode 100644 index 0000000..067fdf0 --- /dev/null +++ b/0002-update-doc.patch @@ -0,0 +1,338 @@ +--- a/README.md ++++ b/README.md +@@ -34,10 +34,22 @@ pkgship是一款管理OS软件包依赖关系，提供依赖和被依赖关系 + + ## 运行环境 + +-* 可用内存700M以上 +-* python版本 3.8及以上 +-* Elasticsearch 版本7.10.1 +-* Redis ++- 硬件配置： ++ ++| 配置项 | 推荐规格 | ++| -------- | ----------- | ++| CPU | 8核 | ++| 内存 | 32G，最小4G | ++| 网络带宽 | 300M | ++| I/O | 375MB/sec | ++ ++- 软件配置： ++ ++| 软件名 | 版本和规格 | ++| ------------- | ------------------------------------------ | ++| Elasticsearch | 版本7.10.1；单机部署可用；有能力可部署集群 | ++| Redis | 建议5.0.4及以上；建议大小配置为内存的3/4 | ++| Python | 版本 3.8及以上 | + + ## 安装工具 + **1、pkgship工具安装** +@@ -85,6 +97,10 @@ pkgship是一款管理OS软件包依赖关系，提供依赖和被依赖关系 + /bin/bash auto_install_pkgship_requires.sh redis + ``` + ++**3、安装后添加用户** ++ ++在安装pkgship软件后，会自动创建名为pkgshipuser的用户和名为pkgshipuser的用户组，无需手动创建，后续服务启动和运行时，都会以该用户角色操作。 ++ + ## 配置参数 + + 1.在配置文件中对相应参数进行配置，系统的默认配置文件存放在 /etc/pkgship/packge.ini，请根据实际情况进行配置更改。 +@@ -158,12 +174,12 @@ database_port=9200 + conf.yaml 文件默认存放在 /etc/pkgship/ 路径下，pkgship会通过该配置读取要建立的数据库名称以及需要导入的sqlite文件，也支持配置sqlite文件所在的repo地址。conf.yaml 示例如下所示。 + + ```yaml +-dbname: openEuler-20.03 #数据库名称 ++dbname: oe20.03 #数据库名称 + src_db_file: /etc/pkgship/repo/openEuler-20.09/src #源码包所在的本地路径 + bin_db_file: /etc/pkgship/repo/openEuler-20.09/bin #二进制包所在的本地路径 + priority: 1 #数据库优先级 + +-dbname: openEuler-20.09 ++dbname: oe20.09 + src_db_file: https://repo.openeuler.org/openEuler-20.09/source #源码包所在的repo源 + bin_db_file: https://repo.openeuler.org/openEuler-20.09/everything/aarch64 #二进制包所在的repo源 + priority: 2 +@@ -174,6 +190,8 @@ priority: 2 + > 如需更改存放路径，请更改package.ini下的 init_conf_path 选项。 + > + > 不支持直接配置sqlite文件路径。 ++> ++> dbname请使用小写字母或者数字，不支持大写字母。 + + ## 服务启动和停止 + pkgship启动和停止方式有两种，systemctl方式和pkgshipd方式，其中systemctl方式启动可以有异常停止自启动的机制。两种方式的执行命令为： +@@ -194,50 +212,50 @@ pkgshipd stop 停止服务 + + > 每次起停周期内仅支持一种方式，不允许两种操作同时使用。 + > +-> pkgshipd启动方式只允许在pkgshipduser用户下操作。 ++> pkgshipd启动方式只允许在pkgshipuser用户下操作。 + + ## 工具使用 + + 1. 数据库初始化。 + +- > 使用场景：服务启动后，为了能查询对应的数据库（比如openEuler-20.09， openEuler-21.03）中的包信息及包依赖关系，需要将这些数据库通过createrepo生成的sqlite（分为源码库和二进制库）导入进服务内，生成对应的包信息json体然后插入Elasticsearch对应的数据库中。数据库名为根据config.yaml中配置的dbname生成的dbname-source/binary，[-filepath]为可选参数。 ++ > 使用场景：服务启动后，为了能查询对应的数据库（比如oe20.03，oe20.09）中的包信息及包依赖关系，需要将这些数据库通过createrepo生成的sqlite（分为源码库和二进制库）导入进服务内，生成对应的包信息json体然后插入Elasticsearch对应的数据库中。数据库名为根据config.yaml中配置的dbname生成的dbname-source/binary。 + + ```bash + pkgship init [-filepath path] + ``` + + > 参数说明： +- > -filepath：指定初始化配置文件config.yaml的路径，可以使用相对路径和绝对路径，不带参数则使用默认配置初始化。 ++ > -filepath：指定初始化配置文件config.yaml的路径，可以使用相对路径和绝对路径，不带参数则使用默认配置初始化，可选参数。 + + 2. 单包查询。 + + 用户可查询源码包或者二进制包(packagename)在指定数据库表（database）中的具体信息。 + +- > 使用场景：用户可查询源码包或者二进制包在指定数据库中的具体信息，packagename,database为必选参数,-s为可选参数。 ++ > 使用场景：用户可查询源码包或者二进制包在指定数据库中的具体信息。 + + ```bash + pkgship pkginfo $packageName $database [-s] + ``` + + > 参数说明： +- > packagename：指定要查询的软件包名。 +- > database：指定具体的数据库名称。 ++ > packagename：指定要查询的软件包名，必传参数。 ++ > database：指定具体的数据库名称，必传参数。 + > +- > -s: 指定`-s`将查询的是`src`源码包信息;若未指定 默认查询`bin`二进制包信息 ++ > -s: 指定`-s`将查询的是`src`源码包信息;若未指定 默认查询`bin`二进制包信息，可选参数。 + + 3. 所有包查询。 + + 查询数据库下包含的所有包的信息。 + +- > 使用场景：用户可查询指定数据库下包含的所有软件包信息。其中tablename为必选参数，-s为可选参数。 ++ > 使用场景：用户可查询指定数据库下包含的所有软件包信息。 + + ```bash + pkgship list $database [-s] + ``` + + > 参数说明： +- > database：指定具体的数据库名称。 +- > -s: 指定`-s`将查询的是`src`源码包信息;若未指定 默认查询`bin`二进制包信息 ++ > database：指定具体的数据库名称，必传参数。 ++ > -s: 指定`-s`将查询的是`src`源码包信息;若未指定 默认查询`bin`二进制包信息，可选参数。 + + 4. 安装依赖查询。 + +@@ -285,7 +303,7 @@ pkgshipd stop 停止服务 + + > 参数说明： + > +- > pkgName：需要查询安装的依赖的二进制包名字,支持传多个；必传参数。 ++ > pkgName：需要查询安装的依赖的软件包名字,支持传多个；必传参数。 + > + > -dbs： 指定需要查询的database优先级,不传按照系统默认优先级搜索；可选参数。 + > +@@ -296,9 +314,9 @@ pkgshipd stop 停止服务 + > -w：指定-s表示引入某个二进制包的时候，查询结果会显示出该二进制包对应的源码包以及该源码包生成的所有二进制包；如果不指定-w参数表示引入某个二进制包的时候，查询结果只显示对应的源码包；可选参数。 + + 7. 被依赖查询。 +- 查询源码包(sourceName)在某数据库(dbName)中被哪些包所依赖。 ++ 查询软件包(pkgName)在某数据库(dbName)中被哪些包所依赖。 + +- > 使用场景：针对软件源码包A，在升级或删除的情况下会影响哪些软件包，可通过该命令查询。该命令会显示源码包A生成的所有二进制包被哪些源码包（比如B）编译依赖，被哪些二进制包（比如C1）安装依赖；以及B生成的二进制包及C1被哪些源码包（比如D）编译依赖，被哪些二进制包（比如E1）安装依赖，以此类推，遍历这些二进制包的被依赖。 ++ > 使用场景：针对软件包A，在升级或删除的情况下会影响哪些软件包，可通过该命令查询。该命令会显示源码包A(若为源码包)生成的所有二进制包（若输入为二进制包，那此处即为输入的二进制包）被哪些源码包（比如B）编译依赖，被哪些二进制包（比如C1）安装依赖；以及B生成的二进制包及C1被哪些源码包（比如D）编译依赖，被哪些二进制包（比如E1）安装依赖，以此类推，遍历这些二进制包的被依赖。 + + ```bash + pkgship bedepend dbName [$pkgName1 $pkgName2 $pkgName3] [-w] [-b] [-install/build] +@@ -306,9 +324,11 @@ pkgshipd stop 停止服务 + + > 参数说明: + > +- > dbName：需要查询依赖关系的仓库，不支持多个；必选参数。 ++ > dbName：需要查询依赖关系的仓库，不支持多个；必选参数。 ++ > ++ > pkgName：待查询的软件包名称，支持多个；必选参数。 + > +- > -w ：当不指定-w 时，查询结果默认不包含对应二进制包的子包；当命令后指定配置参数[-w] 时，不仅会查询二进制包C1的被依赖关系，还会进一步去查询C1对应的源码包C生成的其他二进制包（比如：C2,C3）的被依赖关系；可选参数。 ++ > -w ：当不指定-w 时，查询结果默认不包含对应源码包的子包；当命令后指定配置参数[-w] 时，不仅会查询二进制包C1的被依赖关系，还会进一步去查询C1对应的源码包C生成的其他二进制包（比如：C2,C3）的被依赖关系；可选参数。 + > + > -b：指定`-b`表示查询的包是二进制,默认查询源码包；可选参数。 + > +@@ -318,7 +338,7 @@ pkgshipd stop 停止服务 + + > 使用场景，查看Elasticsearch中初始化了哪些数据库，该功能会按照优先级顺序返回已经初始化的数据库列表。 + +- `pkgship db` ++ `pkgship dbs` + + 9. 获取版本号。 + +@@ -326,3 +346,64 @@ pkgshipd stop 停止服务 + + `pkgship -v` + ++## 日志查看和转储 ++ ++ **日志查看** ++ ++ pkgship服务在运行时会产生两种日志，业务日志和操作日志。 ++ ++ 1、业务日志: ++ ++ 路径：/var/log/pkgship/log_info.log（支持在conf.yaml中通过log_path字段自定义路径）。 ++ ++ 功能：主要记录代码内部运行的日志，方便问题定位。 ++ ++ 权限：路径权限755，日志文件权限644，普通用户可以查看。 ++ ++2、操作日志： ++ ++路径：/var/log/pkgship-operation/uwsgi.log （支持在conf.yaml中通过daemonize字段自定义路径）。 ++ ++功能：记录使用者操作信息，包括ip，访问时间，访问url，访问结果等，方便后续查阅以及记录攻击者信息。 ++ ++权限：路径权限700，日志文件权限644，只有root和pkgshipuser可以查看。 ++ ++**日志转储** ++ ++1、业务日志转储： ++ ++- 转储机制 ++ ++ 使用python自带的logging内置函数的转储机制，按照日志大小来备份。 ++ ++> 配置项，package.ini中配置每个日志的容量和备份数量 ++> ++> ```ini ++> ; Maximum capacity of each file, the unit is byte, default is 30M ++> max_bytes=31457280 ++> ++> ; Number of old logs to keep;default is 30 ++> backup_count=30 ++> ``` ++ ++- 转储过程 ++ ++ 当某次日志写入后，日志文件大小超过配置的日志容量时，会自动压缩转储，压缩后文件名为log_info.log.x.gz， x是数字，数字越小为越新的备份。 ++ ++ 当备份日志数量到达配置的备份数量之后，最早的备份日志会被删除掉，然后备份一个最新的压缩日志文件。 ++ ++ ++ ++2、操作日志转储： ++ ++- 转储机制 ++ ++ 使用脚本进行转储，按照时间转储，每日转储一次，共保留30天，不支持自定义配置。 ++ ++ > 脚本位置：/etc/pkgship/uwsgi_logrotate.sh ++ ++- 转储过程 ++ ++ pkgship启动时转储脚本后台运行，从启动时，每隔1天进行转储压缩，共保留30份压缩文件，压缩文件名称为uwsgi.log-20201010x.zip， x为压缩时的小时数。 ++ ++ pkgship停止后转储脚本停止，不再进行转储，再次启动时，转储脚本重新执行。 +\ No newline at end of file +--- a/doc/design/pkgship-dev-2.0.md ++++ b/doc/design/pkgship-dev-2.0.md +@@ -1364,7 +1364,7 @@ query_ip_addr=127.0.0.1 + + ; The address of the remote service, the command line can directly + ; call the remote service to complete the data request +-remote_host=https://api.openeuler.org/pkgmanage ++remote_host=https://pkgmanage.openeuler.org + + ; A temporary directory for files downloaded from the network that are cleaned periodically + ; The recommended free space in this dir is 1G +@@ -1379,6 +1379,12 @@ log_path=/var/log/pkgship/ + ; INFO DEBUG WARNING ERROR CRITICAL + log_level=INFO + ++; Maximum capacity of each file, the unit is byte, default is 30M ++max_bytes=31457280 ++ ++; Number of old logs to keep;default is 30 ++backup_count=30 ++ + [UWSGI] + ; Operation log storage path + daemonize=/var/log/pkgship-operation/uwsgi.log +@@ -1402,9 +1408,6 @@ redis_port=6379 + redis_max_connections=10 + + [DATABASE] +-;The database engines supported in the system is sqlite database by default +-database_engine_type=elastic +- + ;Default ip address of database + database_host=127.0.0.1 + +@@ -3528,6 +3531,68 @@ binary_data = { + | DatabaseConfigException | 自定义 | 数据库配置异常，例如数据库地址为空，数据库类型不支持 | + | ElasticSearchQueryException | 自定义 | ES数据库查询异常，例如数据库连接失败，连接超时，index不存在 | + ++### 3.9、日志查看和转储 ++ ++#### 3.9.1、日志查看 ++ ++ pkgship服务在运行时会产生两种日志，业务日志和操作日志。 ++ ++ 1、业务日志: ++ ++ 路径：/var/log/pkgship/log_info.log（支持在conf.yaml中配置）。 ++ ++ 功能：主要记录代码内部运行的日志，方便问题定位。 ++ ++ 权限：路径权限755，日志文件权限644，普通用户可以查看。 ++ ++2、操作日志： ++ ++路径：/var/log/pkgship-operation/uwsgi.log （支持在conf.yaml中配置）。 ++ ++功能：记录使用者操作信息，包括ip，访问时间，访问url，访问结果等，方便后续查阅以及记录攻击者信息。 ++ ++权限：路径权限700，日志文件权限644，只有root和pkgshipuser可以查看。 ++ ++#### 3.9.2、日志转储 ++ ++1、业务日志转储： ++ ++- 转储机制 ++ ++ 使用python自带的logging内置函数的转储机制，按照日志大小来备份。 ++ ++> 配置项，package.ini中配置每个日志的容量和备份数量 ++> ++> ```ini ++> ; Maximum capacity of each file, the unit is byte, default is 30M ++> max_bytes=31457280 ++> ++> ; Number of old logs to keep;default is 30 ++> backup_count=30 ++> ``` ++ ++- 转储过程 ++ ++ 当某次日志写入后，日志文件大小超过配置的日志容量时，会自动压缩转储，压缩后文件名为log_info.log.x.gz， x是数字，数字越小为越新的备份。 ++ ++ 当备份日志数量到达配置的备份数量之后，最早的备份日志会被删除掉，然后备份一个最新的压缩日志文件。 ++ ++ ++ ++2、操作日志转储： ++ ++- 转储机制 ++ ++ 使用脚本进行转储，按照时间转储，每日转储一次，共保留30天，不支持自定义配置。 ++ ++ > 脚本位置：/etc/pkgship/uwsgi_logrotate.sh ++ ++- 转储过程 ++ ++ pkgship启动时转储脚本后台运行，从启动时，每隔1天进行转储压缩，共保留30份压缩文件，压缩文件名称为uwsgi.log-20201010x.zip， x为压缩时的小时数。 ++ ++ pkgship停止后转储脚本停止，不再进行转储，再次启动时，转储脚本重新执行。 ++ + ## 4、修改日志 + + |版本|发布说明| diff --git a/0003-fix-pkginfo-queries.patch b/0003-fix-pkginfo-queries.patch new file mode 100644 index 0000000..c5cc7ee --- /dev/null +++ b/0003-fix-pkginfo-queries.patch @@ -0,0 +1,24 @@ +--- a/packageship/application/apps/package/view.py ++++ b/packageship/application/apps/package/view.py +@@ -235,7 +235,9 @@ class SourcePackageInfo(Resource): + """ + # Get verification parameters + rspmsg = RspMsg() +- data = request.args ++ data = dict() ++ data["database_name"] = request.args.get("database_name") ++ data["pkg_name"] = pkg_name + result, error = validate(SingleSchema, data, load=True) + if error: + response = rspmsg.body('param_error') +@@ -289,7 +291,9 @@ class BinaryPackageInfo(Resource): + """ + # Get verification parameters + rspmsg = RspMsg() +- data = request.args ++ data = dict() ++ data["database_name"] = request.args.get("database_name") ++ data["pkg_name"] = pkg_name + result, error = validate(SingleSchema, data, load=True) + if error: + response = rspmsg.body('param_error') diff --git a/0004-wrong-judgment-of-startup-success.patch b/0004-wrong-judgment-of-startup-success.patch new file mode 100644 index 0000000..bf4caa3 --- /dev/null +++ b/0004-wrong-judgment-of-startup-success.patch @@ -0,0 +1,66 @@ +--- a/packageship/pkgshipd ++++ b/packageship/pkgshipd +@@ -3,7 +3,7 @@ SYS_PATH=/etc/pkgship + OUT_PATH=/opt/pkgship/uwsgi + OPERATION=$1 + PKGSHIP_CONSTANT="pkgship" +-MEM_THRESHOLD='700' ++MEM_THRESHOLD='2048' + MEM_FREE=$(free -m | grep "Mem" | awk '{print $7}') + + function check_user() { +@@ -262,22 +262,34 @@ function uwsgi_log_logrotate() { + echo "[INFO] Start the logrotate task success" + } + ++function is_started() { ++ pkgship_version=$(pkgship -v) ++ if [[ -n ${pkgship_version} ]] && [[ ${pkgship_version} =~ "Version" ]]; then ++ return 0 ++ else ++ return 1 ++ fi ++} ++ + function start_service() { +- uwsgi_pid=$(ps -ef | grep -v grep | grep "uwsgi" | grep "${PKGSHIP_CONSTANT}.ini" | awk '{print $2}') +- if [ -n "${uwsgi_pid}" ]; then ++ if is_started; then + echo "[ERROR] ${PKGSHIP_CONSTANT} service is running, please stop it first." + exit 1 + else + uwsgi -d --ini $OUT_PATH/${PKGSHIP_CONSTANT}.ini + echo "[INFO] START uwsgi service: ${PKGSHIP_CONSTANT}.ini" +- uwsgi_pid=$(ps -ef | grep -v grep | grep "uwsgi" | grep "${PKGSHIP_CONSTANT}.ini" | awk '{print $2}') +- if [ -z "${uwsgi_pid}" ]; then +- echo "[ERROR] Service failed to start, please check log $(get_config "daemonize")" +- exit 1 +- fi +- uwsgi_log_logrotate +- echo "[INFO] Start pkgship service success!!!" +- exit 0 ++ ++ for i in {1..5}; do ++ if is_started; then ++ uwsgi_log_logrotate ++ echo "[INFO] Start pkgship service success!!!" ++ exit 0 ++ fi ++ sleep 2s ++ done ++ ++ echo "[ERROR] Service failed to start, please check log $(get_config "daemonize")" ++ exit 1 + fi + } + +@@ -288,8 +300,7 @@ function stop_service() { + exit 1 + fi + +- uwsgi_pid=$(ps -ef | grep -v grep | grep "uwsgi" | grep "${PKGSHIP_CONSTANT}.ini" | awk '{print $2}') +- if [ -n "${uwsgi_pid}" ]; then ++ if is_started; then + uwsgi --stop $OUT_PATH/${PKGSHIP_CONSTANT}.pid + echo "[INFO] STOP uwsgi service: $OUT_PATH/${PKGSHIP_CONSTANT}.ini" + echo "[INFO] The run log is saved into: $(get_config "daemonize")" diff --git a/0005-canonical-naming.patch b/0005-canonical-naming.patch new file mode 100644 index 0000000..49c107c --- /dev/null +++ b/0005-canonical-naming.patch @@ -0,0 +1,4140 @@ +--- a/doc/design/pkgship-dev-2.0.md ++++ b/doc/design/pkgship-dev-2.0.md +@@ -104,7 +104,7 @@ Mulan V2 + |规格名称|规格指标| + |:--|:-------| + |内存占用| 初始化阶段，五万包占用内存1600M，平均每个包占用32k；运行阶段：小于等于700M。 | +-|启动时间| 初始化两个数据库（openEuler-20.09和fedora30，15万个包左右），启动时间为：7min。 | ++|启动时间| 初始化两个数据库（openEuler-20.09和os_version_2，15万个包左右），启动时间为：7min。 | + |响应时间| 3个数据库，90%的查询在5s内给出结果。 | + |文件规格| 初始化和下载功能需要创建临时文件，两个数据库不超过1G，用完即删。 | + |日志规格| 每日日志压缩转储，保留一个月日志，大小视业务操作频率而定。 | +@@ -583,7 +583,7 @@ Mulan V2 + "...": "..." + } + ], +- "fedora30": [ ++ "os_version_2": [ + { + "pkg_name": "Judy", + "...":"..." +@@ -734,7 +734,7 @@ Mulan V2 + "...": "..." + } + ], +- "fedora":[ ++ "os_version_2":[ + { + "...":"..." + }, +@@ -786,7 +786,7 @@ Mulan V2 + "packagename": "Judy", + "depend_type": "installdep", + "parameter": { +- "db_priority": ["Mainline","fedora"], ++ "db_priority": ["Mainline","os_version_2"], + "level": 2 + } + } +@@ -797,7 +797,7 @@ Mulan V2 + "packagename": "Judy", + "depend_type": "builddep", + "parameter": { +- "db_priority": ["Mainline","fedora"], ++ "db_priority": ["Mainline","os_version_2"], + "level": 2, + "self_build": true + } +@@ -809,7 +809,7 @@ Mulan V2 + "packagename": "Judy", + "depend_type": "selfdep", + "parameter": { +- "db_priority": ["Mainline","fedora"], ++ "db_priority": ["Mainline","os_version_2"], + "self_build": true, + "packtype": "source", + "with_subpack": true +@@ -921,7 +921,7 @@ Mulan V2 + "source_num": 37 + }, + { +- "database": "fedora", ++ "database": "os_version_2", + "binary_num": 33, + "source_num": 20 + }, +@@ -969,7 +969,7 @@ Mulan V2 + "depend_type": "builddep", + "node_name": "glibc", + "parameter": { +- "db_priority": ["Mainline","fedora"], ++ "db_priority": ["Mainline","os_version_2"], + "level": 2, + "self_build": true + } +@@ -1009,7 +1009,7 @@ Mulan V2 + "node_name": "glibc", + "node_type": "binary", + "parameter": { +- "db_priority": ["Mainline","fedora"], ++ "db_priority": ["Mainline","os_version_2"], + "level": 2, + "self_build": true + } +@@ -1136,9 +1136,9 @@ Mulan V2 + + ```yaml + # repo源初始化模式 —— 本地repo源 +- - dbname: fedora +- src_db_file: file:///root/public/initdb/fedora/src +- bin_db_file: file:///root/public/initdb/fedora/bin ++ - dbname: os_version_2 ++ src_db_file: file:///root/public/initdb/os_version_2/src ++ bin_db_file: file:///root/public/initdb/os_version_2/bin + priority: 1 + # repo源初始化模式 ——远端repo源 + - dbname: openEuler-20.09-OS +@@ -1660,7 +1660,7 @@ resp = {"total":2300, + + ```python + # 获取指定database中的Judy信息 +-src_package_info(["Judy"],database=['openEuler-20.09','fedora30']) ++src_package_info(["Judy"],database=['openEuler-20.09','os_version_2']) + # 获取所有database下的Judy信息 + src_package_info(["Judy","glibc"]) + ``` +@@ -1767,7 +1767,7 @@ dict:source_dict = { + "...": "..." + } + ], +- "fedora30": [ ++ "os_version_2": [ + { + "src_name": "Judy", + "...":"..." +@@ -1809,7 +1809,7 @@ dict:source_dict = { + + ```python + # 获取指定database中的Judy信息 +-bin_package_info(["Judy-devel"],database=['openEuler-20.09','fedora30']) ++bin_package_info(["Judy-devel"],database=['openEuler-20.09','os_version_2']) + # 获取所有database下的Judy信息 + bin_package_info(["Judy-devel","glibc"]) + ``` +@@ -1916,7 +1916,7 @@ binary_dict = { + "...": "..." + } + ], +- "fedora":[ ++ "os_version_2":[ + { + "...":"..." + }, +@@ -2001,9 +2001,9 @@ db_priority = ["openEuler:Mainline","openEuler:20.09",..] + + ```yaml + # repo源初始化模式 —— 本地repo源 +- - dbname: fedora +- src_db_file: file:///root/public/initdb/fedora/src +- bin_db_file: file:///root/public/initdb/fedora/bin ++ - dbname: os_version_2 ++ src_db_file: file:///root/public/initdb/os_version_2/src ++ bin_db_file: file:///root/public/initdb/os_version_2/bin + priority: 1 + # repo源初始化模式 ——远端repo源 + - dbname: openEuler-20.09-OS +@@ -2054,14 +2054,14 @@ db_priority = ["openEuler:Mainline","openEuler:20.09",..] + # 按照指定优先级搜索，搜索两层依赖关系 + install_depend( + ["Judy","CUnit"], +- db_priority=["openEuler:Mainline","fedora"], ++ db_priority=["openEuler:Mainline","os_version_2"], + level = 2 + ) + + # 不指定level 表示安装依赖会搜索到全部的依赖 + install_depend( + ["Judy","CUnit"], +- db_priority=["openEuler:Mainline","fedora"] ++ db_priority=["openEuler:Mainline","os_version_2"] + ) + ``` + - 预期返回参数 +@@ -2100,7 +2100,7 @@ install_depend( + # 按照指定优先级搜索，搜索两层依赖关系 + build_depend( + ["Judy","CUnit"], +- db_priority=["openEuler:Mainline","fedora"], ++ db_priority=["openEuler:Mainline","os_version_2"], + level = 2, + self_build = True + ) +@@ -2108,7 +2108,7 @@ build_depend( + # 不指定level 表示安装依赖会搜索到全部的依赖, 不指定self_build 表示不查询自编译依赖 + build_depend( + ["glibc"], +- db_priority=["openEuler:Mainline","fedora"] ++ db_priority=["openEuler:Mainline","os_version_2"] + ) + ``` + +@@ -2330,7 +2330,7 @@ build_depend( + depend_list( + ["Judy","CUnit"], + depend_type="install", +- db_priority=["Mainline","fedora"], ++ db_priority=["Mainline","os_version_2"], + level = 3 + ) + +@@ -2338,14 +2338,14 @@ depend_list( + depend_list( + ["Judy","CUnit"], + depend_type="install", +- db_priority=["Mainline","fedora"] ++ db_priority=["Mainline","os_version_2"] + ) + + # 编译依赖，不查询自编译依赖不需要指定self_build 指定level查询到第三层就结束 + depend_list( + ["Judy","CUnit"], + depend_type="build", +- db_priority=["Mainline","fedora"], ++ db_priority=["Mainline","os_version_2"], + level=3 + ) + +@@ -2353,7 +2353,7 @@ depend_list( + depend_list( + ["Judy","CUnit"], + depend_type="build", +- db_priority=["Mainline","fedora"], ++ db_priority=["Mainline","os_version_2"], + self_build=True + ) + +@@ -2361,7 +2361,7 @@ depend_list( + depend_list( + ["Judy","CUnit"], + depend_type="self", +- db_priority=["Mainline","fedora"], ++ db_priority=["Mainline","os_version_2"], + packtype='source', + self_build=True + ) +@@ -2369,7 +2369,7 @@ depend_list( + depend_list( + ["Judy","CUnit"], + depend_type="self", +- db_priority=["Mainline","fedora"], ++ db_priority=["Mainline","os_version_2"], + packtype='binary', + self_build=True, + with_subpack=True +@@ -2458,7 +2458,7 @@ binary_data = { + "version":"v1.20.0.1", + "source_name" : "Judy", + "level": 1, +- "database":"openeuler-20.03", ++ "database":"os_version_1", + "install" :[ + "Judy-devel"， + "attr", +@@ -2477,7 +2477,7 @@ binary_data = { + "version":"v1.20.0.1", + "source_name" : "Judy", + "level": 2, +- "database":"openeuler-20.03", ++ "database":"os_version_1", + "install" :[ + "attr", + "Judy" +@@ -2488,7 +2488,7 @@ binary_data = { + "version":"v1.20.0.1", + "source_name" : "attr", + "level": 2, +- "database":"openeuler-20.03", ++ "database":"os_version_1", + "install" :[ + "openssl-libs" + ] +@@ -2500,7 +2500,7 @@ source_data = { + "Judy": { + "name": "Judy", + "version": "v1.20.0.1", +- "database": "openeuler-20.03", ++ "database": "os_version_1", + "build": [ + "gcc", + "make" +@@ -2509,7 +2509,7 @@ source_data = { + "attr": { + "name": "attr", + "version": "v1.20.0.1", +- "database": "openeuler-20.03" ++ "database": "os_version_1" + } + } + ``` +@@ -2572,7 +2572,7 @@ binary_data = { + "name": "Judy", + "version":"v1.20.0.1", + "source_name" : "Judy", +- "database":"openeuler-20.03", ++ "database":"os_version_1", + "install" :[ + "libselinux", + "ncurses", +@@ -2587,7 +2587,7 @@ binary_data = { + "name": "Judy-devel", + "version":"v1.20.0.1", + "source_name" : "Judy", +- "database":"openeuler-20.03", ++ "database":"os_version_1", + "install" :[ + "attr", + "Judy" +@@ -2602,7 +2602,7 @@ binary_data = { + "name": "attr", + "version":"v1.20.0.1", + "source_name" : "attr", +- "database":"openeuler-20.03", ++ "database":"os_version_1", + "install" :[ + "openssl-libs" + ] +@@ -2614,12 +2614,12 @@ source_data = { + "Judy": { + "name": "Judy", + "version": "v1.20.0.1", +- "database": "openeuler-20.03" ++ "database": "os_version_1" + }, + "attr": { + "name": "attr", + "version": "v1.20.0.1", +- "database": "openeuler-20.03" ++ "database": "os_version_1" + } + + } +@@ -2672,7 +2672,7 @@ binary_data = { + "name": "Judy", + "version":"v1.20.0.1", + "source_name" : "Judy", +- "database":"openeuler-20.03", ++ "database":"os_version_1", + "level": 1, + "direction": "root", + "requires" :[ +@@ -2688,7 +2688,7 @@ binary_data = { + "name": "attr", + "version":"v1.20.0.1", + "source_name" : "attr", +- "database":"openeuler-20.03", ++ "database":"os_version_1", + "level": 2, + "direction": "downward", + "requires":[ +@@ -2700,7 +2700,7 @@ binary_data = { + "name": "glibc", + "version":"v1.20.0.1", + "source_name" : "glibc", +- "database":"openeuler-20.03", ++ "database":"os_version_1", + "level": 2, + "direction": "downward", + "requires":[ +@@ -2712,7 +2712,7 @@ binary_data = { + "name": "gmp", + "version":"v1.20.0.1", + "source_name" : "gmp", +- "database":"openeuler-20.03", ++ "database":"os_version_1", + "level": 2, + "direction": "upward", + "be_requires":[ +@@ -2724,7 +2724,7 @@ binary_data = { + "name": "openssl-libs", + "version":"v1.20.0.1", + "source_name" : "openssl", +- "database":"openeuler-20.03", ++ "database":"os_version_1", + "level": 2, + "direction": "upward", + "be_requires":[ +@@ -2835,7 +2835,7 @@ binary_data = { + + ```python + get_install_req(["Judy","CUnit"]) 隐式参数 self.database_list +- get_install_req(["Judy","CUnit"], "openeuler-20.09") 隐式参数 self.database_list ++ get_install_req(["Judy","CUnit"], "os_version_1") 隐式参数 self.database_list + ``` + + - 预期返回参数： +@@ -2867,7 +2867,7 @@ binary_data = { + { + "binary_name": "Judy", + "bin_version": "1.1.1", +- "database": "openeuler-20.09", ++ "database": "os_version_1", + "src_name": "Judy", + "src_version": "1.1.1", + "requires":[ +@@ -2877,7 +2877,7 @@ binary_data = { + "com_bin_version": "1.1.1", + "com_src_name": "lib", + "com_src_version": "1.1.1", +- "com_database": "openeuler-20.09" ++ "com_database": "os_version_1" + }, + { + "component": "lib4.so", +@@ -2885,7 +2885,7 @@ binary_data = { + "com_bin_version": "1.1.1", + "com_src_name": "lib", + "com_src_version": "1.1.1", +- "com_database": "openeuler-20.09" ++ "com_database": "os_version_1" + }, + { + "component": "lib2.so", +@@ -2894,7 +2894,7 @@ binary_data = { + "com_src_name": "lib", + "com_src_version": "1.1.1", + "com_src_version": "1.1.1", +- "com_database": "fedora31" ++ "com_database": "os_version_2" + } + { + "component": "lib3.so" +@@ -2904,7 +2904,7 @@ binary_data = { + { + "binary_name": "CUit", + "bin_version": "1.1.1", +- "database": "openeuler-20.09", ++ "database": "os_version_1", + "src_name": "CUit", + "src_version": "1.1.1", + "requires":[ +@@ -2914,7 +2914,7 @@ binary_data = { + "com_bin_version": "1.1.1", + "com_src_name": "Judy", + "com_src_version": "1.1.1", +- "com_database": "openeuler-20.09" ++ "com_database": "os_version_1" + }, + { + "component": "lib4.so", +@@ -2922,7 +2922,7 @@ binary_data = { + "com_bin_version": "1.1.1", + "com_src_name": "Judy", + "com_src_version": "1.1.1", +- "com_database": "fedora31" ++ "com_database": "os_version_2" + } + ] + } +@@ -2959,7 +2959,7 @@ binary_data = { + + ```python + get_build_req(["Judy","CUnit"]) 隐式参数 self.database_list +- get_build_req(["Judy","CUnit"], "openeuler-20.09") 隐式参数 self.database_list ++ get_build_req(["Judy","CUnit"], "os_version_1") 隐式参数 self.database_list + ``` + + - 预期返回参数：(可和上面 get_install_req 使用同一个结构) +@@ -2989,7 +2989,7 @@ binary_data = { + { + "source_name": "Judy", + "src_version": "1.1.1", +- "database": "openeuler-20.09", ++ "database": "os_version_1", + "requires":[ + { + "component": "lib", +@@ -2997,7 +2997,7 @@ binary_data = { + "com_bin_version": "1.1.1", + "com_src_name": "make", + "com_src_version": "1.1.1", +- "com_database": "openeuler-20.09" ++ "com_database": "os_version_1" + }, + { + "component": "lib2", +@@ -3006,14 +3006,14 @@ binary_data = { + "com_src_name": "make", + "version": "1.1.1", + "com_src_version": "1.1.1", +- "com_database": "fedora31" ++ "com_database": "os_version_2" + } + ] + }, + { + "source_name": "CUit", + "src_version": "1.1.1", +- "database": "openeuler-20.09", ++ "database": "os_version_1", + "requires":[ + { + "component": "lib", +@@ -3021,7 +3021,7 @@ binary_data = { + "com_bin_version": "1.1.1", + "com_src_name": "Judy", + "com_src_version": "1.1.1", +- "com_database": "openeuler-20.09" ++ "com_database": "os_version_1" + }, + { + "component": "lib2", +@@ -3029,7 +3029,7 @@ binary_data = { + "com_bin_version": "1.1.1", + "com_src_name": "Judy", + "com_src_version": "1.1.1", +- "com_database": "fedora31" ++ "com_database": "os_version_2" + } + ] + } +@@ -3062,7 +3062,7 @@ binary_data = { + - 请求示例： + + ```python +- get_be_req(["Judy","CUnit"],"openeuler-20.09") ++ get_be_req(["Judy","CUnit"],"os_version_1") + ``` + + - 预期返回参数： +@@ -3210,7 +3210,7 @@ binary_data = { + - 调用实例： + + ```python +- get_src_name(["Judy","CUnit"], specify_db = "openeuler") 隐式参数 self.database_list ++ get_src_name(["Judy","CUnit"], specify_db = "os_version_1") 隐式参数 self.database_list + ``` + + - 预期返回参数 （如果和安装、编译依赖的信息有重复，可以考虑移除该方法） +@@ -3229,14 +3229,14 @@ binary_data = { + { + "binary_name": "Judy", + "bin_version": "1.1.1", +- "database": "openeuler-20.09", ++ "database": "os_version_1", + "src_name": "Judy", + "src_version": "1.1.1", + }, + { + "binary_name": "CUit", + "bin_version": "1.1.1", +- "database": "openeuler-20.09", ++ "database": "os_version_1", + "src_name": "CUit", + "src_version": "1.1.1", + } +@@ -3271,7 +3271,7 @@ binary_data = { + - 请求示例： + + ```python +- get_bin_name(["Judy","CUnit"], specify_db = "openeuler") 隐式参数 self.database_list ++ get_bin_name(["Judy","CUnit"], specify_db = "os_version_1") 隐式参数 self.database_list + ``` + + - 预期返回参数： +@@ -3297,7 +3297,7 @@ binary_data = { + { + "source_name": "Judy", + "src_version": "1.1.1", +- "database": "openeuler-20.09", ++ "database": "os_version_1", + "binary_infos":[ + { + "bin_name": "Judy", +@@ -3312,7 +3312,7 @@ binary_data = { + { + "source_name": "CUit", + "src_version": "1.1.1", +- "database": "openeuler-20.09", ++ "database": "os_version_1", + "binary_infos":[ + { + "bin_name": "CUit", +@@ -3357,7 +3357,7 @@ binary_data = { + - 请求示例： + + ```json +- get_src_info(src_list=["Judy","CUnit"],database="openeuler-20.09",page_num=1,page_size=20,command_line=False) ++ get_src_info(src_list=["Judy","CUnit"],database="os_version_1",page_num=1,page_size=20,command_line=False) + ``` + + - 预期返回参数 +@@ -3455,7 +3455,7 @@ binary_data = { + - 请求示例： + + ```python +- get_bin_info(bin_list=["Judy","CUnit"],database="openeuler-20.09",page_num=1,page_size=20,command_line=False) ++ get_bin_info(bin_list=["Judy","CUnit"],database="os_version_1",page_num=1,page_size=20,command_line=False) + ``` + + - 预期返回参数 + +--- a/packageship/application/database/cache.py ++++ b/packageship/application/database/cache.py +@@ -73,13 +73,13 @@ class BufferCache: + input kwargs: + {'depend_type': 'installdep', + 'packagename': ['Judy','Judy1'], +- 'parameter': {'db_priority': ['fedora30', 'openeuler'], 'level': 0}} ++ 'parameter': {'db_priority': ['os_version_2', 'os_version_1'], 'level': 0}} + + To: + + {'depend_type': 'installdep', + 'packagename': 'Judy,Judy1', # be sorted first then merge to string +- 'db_priority':'fedora30,openeuler' # do not sorted, can merge to string ++ 'db_priority':'os_version_2,os_version_1' # do not sorted, can merge to string + 'level':'0' + } + """ + +--- a/test/common_files/correct_test_result_json/dependinfo_depend_graph.json ++++ b/test/common_files/correct_test_result_json/dependinfo_depend_graph.json +@@ -8,7 +8,7 @@ + "node_type": "source", + "parameter": { + "db_priority": [ +- "openeuler" ++ "os_version_1" + ], + "level": 2, + "self_build": false + +--- a/test/common_files/correct_test_result_json/dependinfo_depend_list.json ++++ b/test/common_files/correct_test_result_json/dependinfo_depend_list.json +@@ -7,7 +7,7 @@ + "depend_type": "installdep", + "parameter": { + "db_priority": [ +- "openeuler" ++ "os_version_1" + ], + "level": 2 + } +@@ -16,71 +16,71 @@ + "binary_list": [ + { + "binary_name": "A1", +- "database": "openeuler", ++ "database": "os_version_1", + "source_name": "A", + "version": "0.0.23b" + }, + { + "binary_name": "A2", +- "database": "openeuler", ++ "database": "os_version_1", + "source_name": "A", + "version": "0.0.23b" + }, + { + "binary_name": "B1", +- "database": "openeuler", ++ "database": "os_version_1", + "source_name": "B", + "version": "0.0.2" + }, + { + "binary_name": "B2", +- "database": "openeuler", ++ "database": "os_version_1", + "source_name": "B", + "version": "0.0.2" + }, + { + "binary_name": "C1", +- "database": "openeuler", ++ "database": "os_version_1", + "source_name": "C", + "version": "0.1" + }, + { + "binary_name": "C2", +- "database": "openeuler", ++ "database": "os_version_1", + "source_name": "C", + "version": "0.1" + }, + { + "binary_name": "D1", +- "database": "openeuler", ++ "database": "os_version_1", + "source_name": "D", + "version": "0.11" + }, + { + "binary_name": "D2", +- "database": "openeuler", ++ "database": "os_version_1", + "source_name": "D", + "version": "0.11" + } + ], + "source_list": [ + { +- "database": "openeuler", ++ "database": "os_version_1", + "source_name": "A", + "version": "0.0.23b" + }, + { +- "database": "openeuler", ++ "database": "os_version_1", + "source_name": "C", + "version": "0.1" + }, + { +- "database": "openeuler", ++ "database": "os_version_1", + "source_name": "B", + "version": "0.0.2" + }, + { +- "database": "openeuler", ++ "database": "os_version_1", + "source_name": "D", + "version": "0.11" + } +@@ -88,7 +88,7 @@ + "statistics": [ + { + "binary_sum": 8, +- "database": "openeuler", ++ "database": "os_version_1", + "source_sum": 4 + } + ] +@@ -102,7 +102,7 @@ + "depend_type": "builddep", + "parameter": { + "db_priority": [ +- "openeuler" ++ "os_version_1" + ], + "level": 2, + "self_build": false +@@ -112,53 +112,53 @@ + "binary_list": [ + { + "binary_name": "B1", +- "database": "openeuler", ++ "database": "os_version_1", + "source_name": "B", + "version": "0.0.2" + }, + { + "binary_name": "C1", +- "database": "openeuler", ++ "database": "os_version_1", + "source_name": "C", + "version": "0.1" + }, + { + "binary_name": "A1", +- "database": "openeuler", ++ "database": "os_version_1", + "source_name": "A", + "version": "0.0.23b" + }, + { + "binary_name": "A2", +- "database": "openeuler", ++ "database": "os_version_1", + "source_name": "A", + "version": "0.0.23b" + }, + { + "binary_name": "D1", +- "database": "openeuler", ++ "database": "os_version_1", + "source_name": "D", + "version": "0.11" + } + ], + "source_list": [ + { +- "database": "openeuler", ++ "database": "os_version_1", + "source_name": "C", + "version": "0.1" + }, + { +- "database": "openeuler", ++ "database": "os_version_1", + "source_name": "D", + "version": "0.11" + }, + { +- "database": "openeuler", ++ "database": "os_version_1", + "source_name": "B", + "version": "0.0.2" + }, + { +- "database": "openeuler", ++ "database": "os_version_1", + "source_name": "A", + "version": "0.0.23b" + } +@@ -166,12 +166,12 @@ + "statistics": [ + { + "binary_sum": 5, +- "database": "openeuler", ++ "database": "os_version_1", + "source_sum": 4 + }, + { + "binary_sum": 0, +- "database": "fedora30", ++ "database": "os_version_2", + "source_sum": 0 + }, + { +@@ -190,7 +190,7 @@ + "depend_type": "selfdep", + "parameter": { + "db_priority": [ +- "openeuler" ++ "os_version_1" + ], + "self_build": false, + "packtype": "source", +@@ -201,42 +201,42 @@ + "binary_list": [ + { + "binary_name": "A1", +- "database": "openeuler", ++ "database": "os_version_1", + "source_name": "A", + "version": "0.0.23b" + }, + { + "binary_name": "A2", +- "database": "openeuler", ++ "database": "os_version_1", + "source_name": "A", + "version": "0.0.23b" + }, + { + "binary_name": "C1", +- "database": "openeuler", ++ "database": "os_version_1", + "source_name": "C", + "version": "0.1" + }, + { + "binary_name": "D1", +- "database": "openeuler", ++ "database": "os_version_1", + "source_name": "D", + "version": "0.11" + } + ], + "source_list": [ + { +- "database": "openeuler", ++ "database": "os_version_1", + "source_name": "D", + "version": "0.11" + }, + { +- "database": "openeuler", ++ "database": "os_version_1", + "source_name": "A", + "version": "0.0.23b" + }, + { +- "database": "openeuler", ++ "database": "os_version_1", + "source_name": "C", + "version": "0.1" + } +@@ -244,12 +244,12 @@ + "statistics": [ + { + "binary_sum": 4, +- "database": "openeuler", ++ "database": "os_version_1", + "source_sum": 3 + }, + { + "binary_sum": 0, +- "database": "fedora30", ++ "database": "os_version_2", + "source_sum": 0 + }, + { +@@ -268,7 +268,7 @@ + "depend_type": "bedep", + "parameter": { + "db_priority": [ +- "openeuler" ++ "os_version_1" + ], + "packtype": "source", + "with_subpack": false, +@@ -279,65 +279,65 @@ + "binary_list": [ + { + "binary_name": "C1", +- "database": "openeuler", ++ "database": "os_version_1", + "source_name": "C", + "version": "0.1" + }, + { + "binary_name": "C2", +- "database": "openeuler", ++ "database": "os_version_1", + "source_name": "C", + "version": "0.1" + }, + { + "binary_name": "A2", +- "database": "openeuler", ++ "database": "os_version_1", + "source_name": "A", + "version": "0.0.23b" + }, + { + "binary_name": "D1", +- "database": "openeuler", ++ "database": "os_version_1", + "source_name": "D", + "version": "0.11" + }, + { + "binary_name": "A1", +- "database": "openeuler", ++ "database": "os_version_1", + "source_name": "A", + "version": "0.0.23b" + }, + { + "binary_name": "B1", +- "database": "openeuler", ++ "database": "os_version_1", + "source_name": "B", + "version": "0.0.2" + }, + { + "binary_name": "B2", +- "database": "openeuler", ++ "database": "os_version_1", + "source_name": "B", + "version": "0.0.2" + } + ], + "source_list": [ + { +- "database": "openeuler", ++ "database": "os_version_1", + "source_name": "C", + "version": "0.1" + }, + { +- "database": "openeuler", ++ "database": "os_version_1", + "source_name": "A", + "version": "0.0.23b" + }, + { +- "database": "openeuler", ++ "database": "os_version_1", + "source_name": "D", + "version": "0.11" + }, + { +- "database": "openeuler", ++ "database": "os_version_1", + "source_name": "B", + "version": "0.0.2" + } +@@ -345,12 +345,12 @@ + "statistics": [ + { + "binary_sum": 7, +- "database": "openeuler", ++ "database": "os_version_1", + "source_sum": 4 + }, + { + "binary_sum": 0, +- "database": "fedora30", ++ "database": "os_version_2", + "source_sum": 0 + }, + { + +--- a/test/common_files/correct_test_result_json/empty_dependinfo_depend_graph.json ++++ b/test/common_files/correct_test_result_json/empty_dependinfo_depend_graph.json +@@ -8,7 +8,7 @@ + "node_type": "source", + "parameter": { + "db_priority": [ +- "openeuler" ++ "os_version_1" + ], + "level": 2, + "self_build": false + +--- a/test/common_files/correct_test_result_json/empty_dependinfo_depend_list.json ++++ b/test/common_files/correct_test_result_json/empty_dependinfo_depend_list.json +@@ -6,7 +6,7 @@ + "depend_type": "installdep", + "parameter": { + "db_priority": [ +- "openeuler" ++ "os_version_1" + ], + "level": 2 + } + +--- a/test/common_files/correct_test_result_json/get_single_bin_package.json ++++ b/test/common_files/correct_test_result_json/get_single_bin_package.json +@@ -1,5 +1,5 @@ + { +- "openeuler": [ ++ "os_version_1": [ + { + "bin_name": "Judy", + "description": "The package provides the most advanced core technology, the main\nadvantages are scalability, high performance and memory efficiency.", + +--- a/test/common_files/correct_test_result_json/get_single_src_package.json ++++ b/test/common_files/correct_test_result_json/get_single_src_package.json +@@ -1,5 +1,5 @@ + { +- "openeuler": [ ++ "os_version_1": [ + { + "buildrequired": [ + "coreutils", + +--- a/test/test_module/test_api/test_bin_packages.py ++++ b/test/test_module/test_api/test_bin_packages.py +@@ -77,7 +77,7 @@ class TestBinPackages(ReadTestBase): + @mock.patch.object(Package, "all_bin_packages") + def test_empty_resp(self, mock_all_bin_packages): + """The table name is not in the database""" +- self.REQUESTS_KWARGS["url"] = self.BASE_URL.format("openeuler", "1", "10") ++ self.REQUESTS_KWARGS["url"] = self.BASE_URL.format("os_version_1", "1", "10") + mock_all_bin_packages.return_value = [] + resp_dict = self.client_request(**self.REQUESTS_KWARGS) + self.assertEqual(resp_dict['code'], ResponseCode.TABLE_NAME_NOT_EXIST) +@@ -87,7 +87,7 @@ class TestBinPackages(ReadTestBase): + """The test table name is in the database""" + mock_data = get_correct_json_by_filename("bin_packages") + self.REQUESTS_KWARGS["url"] = self.BASE_URL.format( +- "openeuler", "1", "1") ++ "os_version_1", "1", "1") + mock_all_bin_packages.return_value = mock_data + resp_dict = self.client_request(**self.REQUESTS_KWARGS) + self.response_json_format(resp_dict) +@@ -100,7 +100,7 @@ class TestBinPackages(ReadTestBase): + Returns: + """ + self.REQUESTS_KWARGS["url"] = self.BASE_URL.format( +- "openeuler", "1", "1") ++ "os_version_1", "1", "1") + mock_es_error.return_value = None + resp_dict = self.client_request(**self.REQUESTS_KWARGS) + self.response_json_format(resp_dict) + +--- a/test/test_module/test_api/test_db_priority.py ++++ b/test/test_module/test_api/test_db_priority.py +@@ -45,7 +45,7 @@ class TestGetDBPriority(ReadTestBase): + self.assertEqual(ResponseCode.SUCCESS, + resp_dict.get("code"), + msg="Error in status code return") +- self.assertEqual(["openeuler", "fedora30"], resp_dict.get( ++ self.assertEqual(["os_version_1", "os_version_2"], resp_dict.get( + 'resp'), msg="The data content is incorrect") + + def test_true_result(self): +@@ -59,7 +59,7 @@ class TestGetDBPriority(ReadTestBase): + response = db_priority.get() + output_data = response.json + self.assertEqual( +- {'code': '200', 'message': 'Successful Operation', 'resp': ["openeuler", "fedora30"]}, ++ {'code': '200', 'message': 'Successful Operation', 'resp': ["os_version_1", "os_version_2"]}, + output_data) + + def test_wrong_result(self): + +--- a/test/test_module/test_api/test_dependinfo_depend_graph.py ++++ b/test/test_module/test_api/test_dependinfo_depend_graph.py +@@ -55,8 +55,8 @@ class TestDependInfoDependGraph(ReadTestBase): + "node_type": "binary", + "parameter": { + "db_priority": [ +- "openeuler", +- "fedora30" ++ "os_version_1", ++ "os_version_2" + ], + "level": 2, + "self_build": True +@@ -69,8 +69,8 @@ class TestDependInfoDependGraph(ReadTestBase): + "node_type": "binary", + "parameter": { + "db_priority": [ +- "openeuler", +- "fedora30" ++ "os_version_1", ++ "os_version_2" + ], + "level": 2, + "self_build": True +@@ -83,8 +83,8 @@ class TestDependInfoDependGraph(ReadTestBase): + "node_type": "", + "parameter": { + "db_priority": [ +- "openeuler", +- "fedora30" ++ "os_version_1", ++ "os_version_2" + ], + "level": 2, + "self_build": True +@@ -97,8 +97,8 @@ class TestDependInfoDependGraph(ReadTestBase): + "node_type": "xxx", + "parameter": { + "db_priority": [ +- "openeuler", +- "fedora30" ++ "os_version_1", ++ "os_version_2" + ], + "level": 2, + "self_build": True + +--- a/test/test_module/test_api/test_dependinfo_depend_list.py ++++ b/test/test_module/test_api/test_dependinfo_depend_list.py +@@ -51,26 +51,26 @@ class TestDependInfoDependList(ReadTestBase): + json.dumps({"packagename": [], + "depend_type": "installdep", + "parameter": { +- "db_priority": ["openeuler"], ++ "db_priority": ["os_version_1"], + "level": 2}}), + json.dumps({"packagename": [], + "depend_type": "bedep", + "parameter": { +- "db_priority": ["openeuler"], ++ "db_priority": ["os_version_1"], + "packtype": "source", + "with_subpack": True, + "search_type": "install"}}), + json.dumps({"packagename": [], + "depend_type": "selfdep", + "parameter": { +- "db_priority": ["openeuler"], ++ "db_priority": ["os_version_1"], + "self_build": False, + "packtype": "source", + "with_subpack": False}}), + json.dumps({"packagename": [], + "depend_type": "builddep", + "parameter": { +- "db_priority": ["openeuler"], ++ "db_priority": ["os_version_1"], + "level": 2, + "self_build": False}}), + json.dumps({"packagename": ["Judy"], +@@ -90,7 +90,7 @@ class TestDependInfoDependList(ReadTestBase): + json.dumps({"packagename": [], + "depend_type": "selfdep", + "parameter": { +- "db_priority": ["openeuler"], ++ "db_priority": ["os_version_1"], + "self_build": False, + "packtype": "xxx", + "with_subpack": False}}), +@@ -152,7 +152,7 @@ class TestDependInfoDependList(ReadTestBase): + "depend_type": "installdep", + "parameter": { + "db_priority": [ +- "openeuler" ++ "os_version_1" + ], + "level": 2 + } + +--- a/test/test_module/test_api/test_download_files.py ++++ b/test/test_module/test_api/test_download_files.py +@@ -45,26 +45,26 @@ class TestDownloadFile(ReadTestBase): + json.dumps({"packagename": [], + "depend_type": "installdep", + "parameter": { +- "db_priority": ["openeuler"], ++ "db_priority": ["os_version_1"], + "level": 2}}), + json.dumps({"packagename": [], + "depend_type": "bedep", + "parameter": { +- "db_priority": ["openeuler"], ++ "db_priority": ["os_version_1"], + "packtype": "source", + "with_subpack": True, + "search_type": "install"}}), + json.dumps({"packagename": [], + "depend_type": "selfdep", + "parameter": { +- "db_priority": ["openeuler"], ++ "db_priority": ["os_version_1"], + "self_build": False, + "packtype": "source", + "with_subpack": False}}), + json.dumps({"packagename": [], + "depend_type": "builddep", + "parameter": { +- "db_priority": ["openeuler"], ++ "db_priority": ["os_version_1"], + "level": 2, + "self_build": False}}), + json.dumps({"packagename": ["Judy"], +@@ -77,7 +77,7 @@ class TestDownloadFile(ReadTestBase): + json.dumps({"packagename": [], + "depend_type": "installdep", + "parameter": { +- "db_priority": ["openeuler"], ++ "db_priority": ["os_version_1"], + "level": 0}}), + json.dumps({"packagename": ["Judy"], + "depend_type": "bedep", +@@ -89,7 +89,7 @@ class TestDownloadFile(ReadTestBase): + json.dumps({"packagename": [], + "depend_type": "selfdep", + "parameter": { +- "db_priority": ["openeuler"], ++ "db_priority": ["os_version_1"], + "self_build": False, + "packtype": "xxx", + "with_subpack": False}}), +@@ -109,7 +109,7 @@ class TestDownloadFile(ReadTestBase): + "packagename": ["Judy"], + "depend_type": "builddep", + "parameter": { +- "db_priority": ["openeuler"], ++ "db_priority": ["os_version_1"], + "self_build": False, + "packtype": "source", + "level": 1, +@@ -125,7 +125,7 @@ class TestDownloadFile(ReadTestBase): + "packagename": ["Judy"], + "depend_type": "selfdep", + "parameter": { +- "db_priority": ["openeuler"], ++ "db_priority": ["os_version_1"], + "self_build": False, + "packtype": "source", + "with_subpack": False}}), content_type="application/json") +@@ -140,7 +140,7 @@ class TestDownloadFile(ReadTestBase): + "packagename": ["Judy"], + "depend_type": "installdep", + "parameter": { +- "db_priority": ["openeuler"], ++ "db_priority": ["os_version_1"], + "level": 2}}), content_type="application/json") + self.assertIsNotNone(resp_dict) + +@@ -153,7 +153,7 @@ class TestDownloadFile(ReadTestBase): + "packagename": ["Judy"], + "depend_type": "bedep", + "parameter": { +- "db_priority": ["openeuler"], ++ "db_priority": ["os_version_1"], + "packtype": "source", + "with_subpack": False, + "search_type": "install"}}), content_type="application/json") +@@ -168,7 +168,7 @@ class TestDownloadFile(ReadTestBase): + "packagename": ["Judy"], + "depend_type": "src", + "parameter": { +- "db_priority": ["openeuler"], ++ "db_priority": ["os_version_1"], + "packtype": "source", + "with_subpack": False, + "search_type": "install"}}), content_type="application/json") +@@ -185,7 +185,7 @@ class TestDownloadFile(ReadTestBase): + "packagename": ["Judy"], + "depend_type": "bedep", + "parameter": { +- "db_priority": ["openeuler"], ++ "db_priority": ["os_version_1"], + "packtype": "source", + "with_subpack": False, + "search_type": "install"}}), content_type="application/json") +@@ -202,7 +202,7 @@ class TestDownloadFile(ReadTestBase): + "packagename": ["Judy"], + "depend_type": "bedep", + "parameter": { +- "db_priority": ["openeuler"], ++ "db_priority": ["os_version_1"], + "packtype": "source", + "with_subpack": False, + "search_type": "install"}}), content_type="application/json") +@@ -220,7 +220,7 @@ class TestDownloadFile(ReadTestBase): + "packagename": ["Judy"], + "depend_type": "selfdep", + "parameter": { +- "db_priority": ["openeuler"], ++ "db_priority": ["os_version_1"], + "self_build": False, + "packtype": "source", + "with_subpack": False}}), content_type="application/json") + +--- a/test/test_module/test_api/test_get_single_bin_package.py ++++ b/test/test_module/test_api/test_get_single_bin_package.py +@@ -51,7 +51,7 @@ class TestGetSinglePack(ReadTestBase): + + def test_wrong_pkg_name(self): + """test wrong package name""" +- self.REQUESTS_KWARGS["url"] = self.BASE_URL.format("openeuler", "test") ++ self.REQUESTS_KWARGS["url"] = self.BASE_URL.format("os_version_1", "test") + resp_dict = self.client_request(**self.REQUESTS_KWARGS) + self.response_json_error_judge( + resp_dict, +@@ -61,7 +61,7 @@ class TestGetSinglePack(ReadTestBase): + @mock.patch.object(BinaryPackage, "bin_package_info") + def test_empty_resp(self, mock_bin_package_info): + """test wrong resp""" +- self.REQUESTS_KWARGS["url"] = self.BASE_URL.format("openeuler", "Judy") ++ self.REQUESTS_KWARGS["url"] = self.BASE_URL.format("os_version_1", "Judy") + mock_bin_package_info.return_value = [] + resp_dict = self.client_request(**self.REQUESTS_KWARGS) + self.assertEqual(resp_dict['code'], ResponseCode.PACK_NAME_NOT_FOUND) +@@ -72,7 +72,7 @@ class TestGetSinglePack(ReadTestBase): + test true parameters + """ + mock_data = get_correct_json_by_filename("get_single_bin_package") +- self.REQUESTS_KWARGS["url"] = self.BASE_URL.format("openeuler", "Judy") ++ self.REQUESTS_KWARGS["url"] = self.BASE_URL.format("os_version_1", "Judy") + mock_bin_package_info.return_value = mock_data + resp_dict = self.client_request(**self.REQUESTS_KWARGS) + self.response_json_format(resp_dict) +@@ -85,7 +85,7 @@ class TestGetSinglePack(ReadTestBase): + Returns: + """ + self.REQUESTS_KWARGS["url"] = self.BASE_URL.format( +- "openeuler", "1", "1") ++ "os_version_1", "1", "1") + mock_es_error.return_value = None + resp_dict = self.client_request(**self.REQUESTS_KWARGS) + self.response_json_format(resp_dict) + +--- a/test/test_module/test_api/test_get_single_src_package.py ++++ b/test/test_module/test_api/test_get_single_src_package.py +@@ -51,7 +51,7 @@ class TestGetSinglePack(ReadTestBase): + + def test_wrong_pkg_name(self): + """test wrong package name""" +- self.REQUESTS_KWARGS["url"] = self.BASE_URL.format("openeuler", "test") ++ self.REQUESTS_KWARGS["url"] = self.BASE_URL.format("os_version_1", "test") + resp_dict = self.client_request(**self.REQUESTS_KWARGS) + self.response_json_error_judge( + resp_dict, +@@ -61,7 +61,7 @@ class TestGetSinglePack(ReadTestBase): + @mock.patch.object(SourcePackage, "src_package_info") + def test_empty_resp(self, mock_src_package_info): + """test wrong resp""" +- self.REQUESTS_KWARGS["url"] = self.BASE_URL.format("openeuler", "Judy") ++ self.REQUESTS_KWARGS["url"] = self.BASE_URL.format("os_version_1", "Judy") + mock_src_package_info.return_value = [] + resp_dict = self.client_request(**self.REQUESTS_KWARGS) + self.assertEqual(resp_dict['code'], ResponseCode.PACK_NAME_NOT_FOUND) +@@ -73,7 +73,7 @@ class TestGetSinglePack(ReadTestBase): + """ + mock_data = get_correct_json_by_filename("get_single_src_package") + +- self.REQUESTS_KWARGS["url"] = self.BASE_URL.format("openeuler", "Judy") ++ self.REQUESTS_KWARGS["url"] = self.BASE_URL.format("os_version_1", "Judy") + mock_src_package_info.return_value = mock_data + resp_dict = self.client_request(**self.REQUESTS_KWARGS) + self.response_json_format(resp_dict) +@@ -86,7 +86,7 @@ class TestGetSinglePack(ReadTestBase): + Returns: + """ + self.REQUESTS_KWARGS["url"] = self.BASE_URL.format( +- "openeuler", "1", "1") ++ "os_version_1", "1", "1") + mock_es_error.return_value = None + resp_dict = self.client_request(**self.REQUESTS_KWARGS) + self.response_json_format(resp_dict) + +--- a/test/test_module/test_api/test_src_packages.py ++++ b/test/test_module/test_api/test_src_packages.py +@@ -76,7 +76,7 @@ class TestBinPackages(ReadTestBase): + @mock.patch.object(Package, "all_src_packages") + def test_empty_resp(self, mock_src_bin_packages): + """The table name is not in the database""" +- self.REQUESTS_KWARGS["url"] = self.BASE_URL.format("openeuler", "1", "10") ++ self.REQUESTS_KWARGS["url"] = self.BASE_URL.format("os_version_1", "1", "10") + mock_src_bin_packages.return_value = [] + resp_dict = self.client_request(**self.REQUESTS_KWARGS) + self.assertEqual(resp_dict['code'], ResponseCode.TABLE_NAME_NOT_EXIST) +@@ -86,7 +86,7 @@ class TestBinPackages(ReadTestBase): + """The test table name is in the database""" + mock_data = get_correct_json_by_filename("src_packages") + self.REQUESTS_KWARGS["url"] = self.BASE_URL.format( +- "openeuler", "1", "1") ++ "os_version_1", "1", "1") + mock_src_bin_packages.return_value = mock_data + resp_dict = self.client_request(**self.REQUESTS_KWARGS) + self.response_json_format(resp_dict) +@@ -99,7 +99,7 @@ class TestBinPackages(ReadTestBase): + Returns: + """ + self.REQUESTS_KWARGS["url"] = self.BASE_URL.format( +- "openeuler", "1", "1") ++ "os_version_1", "1", "1") + mock_es_error.return_value = None + resp_dict = self.client_request(**self.REQUESTS_KWARGS) + self.response_json_format(resp_dict) + +--- a/test/test_module/test_basedepend/data/basedepend_data.json ++++ b/test/test_module/test_basedepend/data/basedepend_data.json +@@ -51,7 +51,7 @@ + "build": [ + "Judy" + ], +- "database": "fedora", ++ "database": "os_version_2", + "name": "A", + "version": "2.0" + }, +@@ -94,7 +94,7 @@ + ], + "source_list": [ + { +- "database": "fedora", ++ "database": "os_version_2", + "source_name": "A", + "version": "2.0" + }, +@@ -112,7 +112,7 @@ + }, + { + "binary_sum": 0, +- "database": "fedora", ++ "database": "os_version_2", + "source_sum": 1 + } + ] + +--- a/test/test_module/test_basedepend/test_dispatch.py ++++ b/test/test_module/test_basedepend/test_dispatch.py +@@ -12,14 +12,14 @@ from packageship.application.core.depend.be_depend import BeDepend + install_params = { + "packagename": ["Judy"], + "depend_type": "installdep", +- "parameter": {"db_priority": ["Mainline", "fedora"], "level": 2}, ++ "parameter": {"db_priority": ["Mainline", "os_version_2"], "level": 2}, + } + + build_params = { + "packagename": ["Judy"], + "depend_type": "builddep", + "parameter": { +- "db_priority": ["Mainline", "fedora"], ++ "db_priority": ["Mainline", "os_version_2"], + "level": 2, + "self_build": True, + }, +@@ -29,7 +29,7 @@ selfdep_params = { + "packagename": ["Judy"], + "depend_type": "selfdep", + "parameter": { +- "db_priority": ["Mainline", "fedora"], ++ "db_priority": ["Mainline", "os_version_2"], + "self_build": False, + "packtype": "source", + "with_subpack": False, +@@ -50,12 +50,12 @@ bedep_params = { + error_depend_type_params = { + "packagename": ["Judy"], + "depend_type": "errordepend", +- "parameter": {"db_priority": ["Mainline", "fedora"], "level": 2}, ++ "parameter": {"db_priority": ["Mainline", "os_version_2"], "level": 2}, + } + + no_depend_type_params = { + "packagename": ["Judy"], +- "parameter": {"db_priority": ["Mainline", "fedora"], "level": 2}, ++ "parameter": {"db_priority": ["Mainline", "os_version_2"], "level": 2}, + } + + + +--- a/test/test_module/test_bedepend/data/bedepend_data.json ++++ b/test/test_module/test_bedepend/data/bedepend_data.json +@@ -183,7 +183,7 @@ + }, + "B1": { + "build": [], +- "database": "fedora", ++ "database": "os_version_2", + "install": [ + "Judy" + ], +@@ -217,7 +217,7 @@ + "version": "1.1" + }, + "B1": { +- "database": "fedora", ++ "database": "os_version_2", + "install": [ + "Judy" + ], + +--- a/test/test_module/test_build/data/except_src.json ++++ b/test/test_module/test_build/data/except_src.json +@@ -1 +1 @@ +-{"Judy": {"name": "Judy", "version": "1.0.5", "database": "openeuler", "build": ["sed"]}} +\ No newline at end of file ++{"Judy": {"name": "Judy", "version": "1.0.5", "database": "os_version_1", "build": ["sed"]}} +\ No newline at end of file + +--- a/test/test_module/test_build/data/level_1_src.json ++++ b/test/test_module/test_build/data/level_1_src.json +@@ -1 +1 @@ +-{"sed": {"name": "sed", "version": "4.8", "database": "openeuler"}, "Judy": {"name": "Judy", "version": "1.0.5", "database": "openeuler", "build": ["sed"]}} +\ No newline at end of file ++{"sed": {"name": "sed", "version": "4.8", "database": "os_version_1"}, "Judy": {"name": "Judy", "version": "1.0.5", "database": "os_version_1", "build": ["sed"]}} +\ No newline at end of file + +--- a/test/test_module/test_build/data/not_found_component.json ++++ b/test/test_module/test_build/data/not_found_component.json +@@ -1 +1 @@ +-[{"source_name": "Judy", "src_version": "1.0.5", "database": "openeuler", "requires": [{"component": "sed", "com_bin_name": null, "com_bin_version": null, "com_src_name": null, "com_src_version": null, "com_database": null}]}] +\ No newline at end of file ++[{"source_name": "Judy", "src_version": "1.0.5", "database": "os_version_1", "requires": [{"component": "sed", "com_bin_name": null, "com_bin_version": null, "com_src_name": null, "com_src_version": null, "com_database": null}]}] +\ No newline at end of file + +--- a/test/test_module/test_build/data/not_searched_pkg_build_info.json ++++ b/test/test_module/test_build/data/not_searched_pkg_build_info.json +@@ -1 +1 @@ +-[{"source_name": "Judy11", "src_version": "1.0.5", "database": "openeuler", "requires": [{"component": "sed", "com_bin_name": "sed", "com_bin_version": "4.8", "com_src_name": "sed", "com_src_version": "4.8", "com_database": "openeuler"}]}] +\ No newline at end of file ++[{"source_name": "Judy11", "src_version": "1.0.5", "database": "os_version_1", "requires": [{"component": "sed", "com_bin_name": "sed", "com_bin_version": "4.8", "com_src_name": "sed", "com_src_version": "4.8", "com_database": "os_version_1"}]}] +\ No newline at end of file + +--- a/test/test_module/test_build/data/true_build_info.json ++++ b/test/test_module/test_build/data/true_build_info.json +@@ -1 +1 @@ +-[{"source_name": "Judy", "src_version": "1.0.5", "database": "openeuler", "requires": [{"component": "sed", "com_bin_name": "sed", "com_bin_version": "4.8", "com_src_name": "sed", "com_src_version": "4.8", "com_database": "openeuler"}]}] +\ No newline at end of file ++[{"source_name": "Judy", "src_version": "1.0.5", "database": "os_version_1", "requires": [{"component": "sed", "com_bin_name": "sed", "com_bin_version": "4.8", "com_src_name": "sed", "com_src_version": "4.8", "com_database": "os_version_1"}]}] +\ No newline at end of file + +--- a/test/test_module/test_build/data/true_install_info.json ++++ b/test/test_module/test_build/data/true_install_info.json +@@ -1 +1 @@ +-[{"binary_name": "sed", "bin_version": "4.8", "database": "openeuler", "src_name": "sed", "src_version": "4.8", "requires": [{"component": "ld-linux-aarch64.so.1()(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "openeuler"}, {"component": "ld-linux-aarch64.so.1(GLIBC_2.17)(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "openeuler"}, {"component": "libacl.so.1()(64bit)", "com_bin_name": "libacl", "com_bin_version": "2.2.53", "com_src_name": "acl", "com_src_version": "2.2.53", "com_database": "openeuler"}, {"component": "libacl.so.1(ACL_1.0)(64bit)", "com_bin_name": "libacl", "com_bin_version": "2.2.53", "com_src_name": "acl", "com_src_version": "2.2.53", "com_database": "openeuler"}, {"component": "libselinux.so.1()(64bit)", "com_bin_name": "libselinux", "com_bin_version": "3.1", "com_src_name": "libselinux", "com_src_version": "3.1", "com_database": "openeuler"}, {"component": "libselinux.so.1(LIBSELINUX_1.0)(64bit)", "com_bin_name": "libselinux", "com_bin_version": "3.1", "com_src_name": "libselinux", "com_src_version": "3.1", "com_database": "openeuler"}, {"component": "rtld(GNU_HASH)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "openeuler"}, {"component": "libc.so.6(GLIBC_2.17)(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "openeuler"}]}, {"binary_name": "make", "bin_version": "4.3", "database": "openeuler", "src_name": "make", "src_version": "4.3", "requires": [{"component": "/bin/sh", "com_bin_name": "bash", "com_bin_version": "5.0", "com_src_name": "bash", "com_src_version": "5.0", "com_database": "openeuler"}, {"component": "/bin/sh", "com_bin_name": "bash", "com_bin_version": "5.0", "com_src_name": "bash", "com_src_version": "5.0", "com_database": "openeuler"}, {"component": "/sbin/install-info", "com_bin_name": "info", "com_bin_version": "6.7", "com_src_name": "texinfo", "com_src_version": "6.7", "com_database": "openeuler"}, {"component": "/sbin/install-info", "com_bin_name": "info", "com_bin_version": "6.7", "com_src_name": "texinfo", "com_src_version": "6.7", "com_database": "openeuler"}, {"component": "ld-linux-aarch64.so.1()(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "openeuler"}, {"component": "ld-linux-aarch64.so.1(GLIBC_2.17)(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "openeuler"}, {"component": "libdl.so.2()(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "openeuler"}, {"component": "libdl.so.2(GLIBC_2.17)(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "openeuler"}, {"component": "libguile-2.0.so.22()(64bit)", "com_bin_name": "guile", "com_bin_version": "2.0.14", "com_src_name": "guile", "com_src_version": "2.0.14", "com_database": "openeuler"}, {"component": "libguile-2.0.so.22(GUILE_2.0)(64bit)", "com_bin_name": "guile", "com_bin_version": "2.0.14", "com_src_name": "guile", "com_src_version": "2.0.14", "com_database": "openeuler"}, {"component": "libpthread.so.0()(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "openeuler"}, {"component": "libpthread.so.0(GLIBC_2.17)(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "openeuler"}, {"component": "rtld(GNU_HASH)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "openeuler"}, {"component": "libc.so.6(GLIBC_2.27)(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "openeuler"}]}, {"binary_name": "coreutils", "bin_version": "8.32", "database": "openeuler", "src_name": "coreutils", "src_version": "8.32", "requires": [{"component": "/sbin/install-info", "com_bin_name": "info", "com_bin_version": "6.7", "com_src_name": "texinfo", "com_src_version": "6.7", "com_database": "openeuler"}, {"component": "/sbin/install-info", "com_bin_name": "info", "com_bin_version": "6.7", "com_src_name": "texinfo", "com_src_version": "6.7", "com_database": "openeuler"}, {"component": "gmp", "com_bin_name": "gmp", "com_bin_version": "6.2.0", "com_src_name": "gmp", "com_src_version": "6.2.0", "com_database": "openeuler"}, {"component": "ld-linux-aarch64.so.1()(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "openeuler"}, {"component": "ld-linux-aarch64.so.1(GLIBC_2.17)(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "openeuler"}, {"component": "libacl.so.1()(64bit)", "com_bin_name": "libacl", "com_bin_version": "2.2.53", "com_src_name": "acl", "com_src_version": "2.2.53", "com_database": "openeuler"}, {"component": "libacl.so.1(ACL_1.0)(64bit)", "com_bin_name": "libacl", "com_bin_version": "2.2.53", "com_src_name": "acl", "com_src_version": "2.2.53", "com_database": "openeuler"}, {"component": "libattr.so.1()(64bit)", "com_bin_name": "attr", "com_bin_version": "2.4.48", "com_src_name": "attr", "com_src_version": "2.4.48", "com_database": "openeuler"}, {"component": "libattr.so.1(ATTR_1.1)(64bit)", "com_bin_name": "attr", "com_bin_version": "2.4.48", "com_src_name": "attr", "com_src_version": "2.4.48", "com_database": "openeuler"}, {"component": "libcap.so.2()(64bit)", "com_bin_name": "libcap", "com_bin_version": "2.32", "com_src_name": "libcap", "com_src_version": "2.32", "com_database": "openeuler"}, {"component": "libcrypto.so.1.1()(64bit)", "com_bin_name": "openssl-libs", "com_bin_version": "1.1.1f", "com_src_name": "openssl", "com_src_version": "1.1.1f", "com_database": "openeuler"}, {"component": "libcrypto.so.1.1(OPENSSL_1_1_0)(64bit)", "com_bin_name": "openssl-libs", "com_bin_version": "1.1.1f", "com_src_name": "openssl", "com_src_version": "1.1.1f", "com_database": "openeuler"}, {"component": "libgmp.so.10()(64bit)", "com_bin_name": "gmp", "com_bin_version": "6.2.0", "com_src_name": "gmp", "com_src_version": "6.2.0", "com_database": "openeuler"}, {"component": "libpthread.so.0()(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "openeuler"}, {"component": "libpthread.so.0(GLIBC_2.17)(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "openeuler"}, {"component": "librt.so.1()(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "openeuler"}, {"component": "librt.so.1(GLIBC_2.17)(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "openeuler"}, {"component": "libselinux.so.1()(64bit)", "com_bin_name": "libselinux", "com_bin_version": "3.1", "com_src_name": "libselinux", "com_src_version": "3.1", "com_database": "openeuler"}, {"component": "libselinux.so.1(LIBSELINUX_1.0)(64bit)", "com_bin_name": "libselinux", "com_bin_version": "3.1", "com_src_name": "libselinux", "com_src_version": "3.1", "com_database": "openeuler"}, {"component": "ncurses", "com_bin_name": "ncurses", "com_bin_version": "6.2", "com_src_name": "ncurses", "com_src_version": "6.2", "com_database": "openeuler"}, {"component": "rtld(GNU_HASH)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "openeuler"}, {"component": "libc.so.6(GLIBC_2.28)(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "openeuler"}]}, {"binary_name": "gcc", "bin_version": "9.3.1", "database": "openeuler", "src_name": "gcc", "src_version": "9.3.1", "requires": [{"component": "/bin/sh", "com_bin_name": "bash", "com_bin_version": "5.0", "com_src_name": "bash", "com_src_version": "5.0", "com_database": "openeuler"}, {"component": "binutils", "com_bin_name": "binutils", "com_bin_version": "2.34", "com_src_name": "binutils", "com_src_version": "2.34", "com_database": "openeuler"}, {"component": "cpp", "com_bin_name": "cpp", "com_bin_version": "9.3.1", "com_src_name": "gcc", "com_src_version": "9.3.1", "com_database": "openeuler"}, {"component": "glibc-devel", "com_bin_name": "glibc-devel", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "openeuler"}, {"component": "ld-linux-aarch64.so.1()(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "openeuler"}, {"component": "ld-linux-aarch64.so.1(GLIBC_2.17)(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "openeuler"}, {"component": "libdl.so.2()(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "openeuler"}, {"component": "libdl.so.2(GLIBC_2.17)(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "openeuler"}, {"component": "libgcc", "com_bin_name": "libgcc", "com_bin_version": "9.3.1", "com_src_name": "gcc", "com_src_version": "9.3.1", "com_database": "openeuler"}, {"component": "libgcc_s.so.1()(64bit)", "com_bin_name": "libgcc", "com_bin_version": "9.3.1", "com_src_name": "gcc", "com_src_version": "9.3.1", "com_database": "openeuler"}, {"component": "libgcc_s.so.1(GCC_3.3)(64bit)", "com_bin_name": "libgcc", "com_bin_version": "9.3.1", "com_src_name": "gcc", "com_src_version": "9.3.1", "com_database": "openeuler"}, {"component": "libgcc_s.so.1(GCC_4.2.0)(64bit)", "com_bin_name": "libgcc", "com_bin_version": "9.3.1", "com_src_name": "gcc", "com_src_version": "9.3.1", "com_database": "openeuler"}, {"component": "libgmp.so.10()(64bit)", "com_bin_name": "gmp", "com_bin_version": "6.2.0", "com_src_name": "gmp", "com_src_version": "6.2.0", "com_database": "openeuler"}, {"component": "libgomp", "com_bin_name": "libgomp", "com_bin_version": "9.3.1", "com_src_name": "gcc", "com_src_version": "9.3.1", "com_database": "openeuler"}, {"component": "libm.so.6()(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "openeuler"}, {"component": "libm.so.6(GLIBC_2.17)(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "openeuler"}, {"component": "libmpc.so.3()(64bit)", "com_bin_name": "libmpc", "com_bin_version": "1.1.0", "com_src_name": "libmpc", "com_src_version": "1.1.0", "com_database": "openeuler"}, {"component": "libmpfr.so.6()(64bit)", "com_bin_name": "mpfr", "com_bin_version": "4.1.0", "com_src_name": "mpfr", "com_src_version": "4.1.0", "com_database": "openeuler"}, {"component": "libstdc++.so.6()(64bit)", "com_bin_name": "libstdc++", "com_bin_version": "9.3.1", "com_src_name": "gcc", "com_src_version": "9.3.1", "com_database": "openeuler"}, {"component": "libstdc++.so.6(CXXABI_1.3)(64bit)", "com_bin_name": "libstdc++", "com_bin_version": "9.3.1", "com_src_name": "gcc", "com_src_version": "9.3.1", "com_database": "openeuler"}, {"component": "libstdc++.so.6(CXXABI_1.3.9)(64bit)", "com_bin_name": "libstdc++", "com_bin_version": "9.3.1", "com_src_name": "gcc", "com_src_version": "9.3.1", "com_database": "openeuler"}, {"component": "libstdc++.so.6(GLIBCXX_3.4)(64bit)", "com_bin_name": "libstdc++", "com_bin_version": "9.3.1", "com_src_name": "gcc", "com_src_version": "9.3.1", "com_database": "openeuler"}, {"component": "libstdc++.so.6(GLIBCXX_3.4.15)(64bit)", "com_bin_name": "libstdc++", "com_bin_version": "9.3.1", "com_src_name": "gcc", "com_src_version": "9.3.1", "com_database": "openeuler"}, {"component": "libstdc++.so.6(GLIBCXX_3.4.20)(64bit)", "com_bin_name": "libstdc++", "com_bin_version": "9.3.1", "com_src_name": "gcc", "com_src_version": "9.3.1", "com_database": "openeuler"}, {"component": "libz.so.1()(64bit)", "com_bin_name": "zlib", "com_bin_version": "1.2.11", "com_src_name": "zlib", "com_src_version": "1.2.11", "com_database": "openeuler"}, {"component": "rtld(GNU_HASH)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "openeuler"}, {"component": "libc.so.6(GLIBC_2.17)(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "openeuler"}]}, {"binary_name": "gawk", "bin_version": "5.1.0", "database": "openeuler", "src_name": "gawk", "src_version": "5.1.0", "requires": [{"component": "filesystem", "com_bin_name": "filesystem", "com_bin_version": "3.14", "com_src_name": "filesystem", "com_src_version": "3.14", "com_database": "openeuler"}, {"component": "ld-linux-aarch64.so.1()(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "openeuler"}, {"component": "ld-linux-aarch64.so.1(GLIBC_2.17)(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "openeuler"}, {"component": "libdl.so.2()(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "openeuler"}, {"component": "libdl.so.2(GLIBC_2.17)(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "openeuler"}, {"component": "libgmp.so.10()(64bit)", "com_bin_name": "gmp", "com_bin_version": "6.2.0", "com_src_name": "gmp", "com_src_version": "6.2.0", "com_database": "openeuler"}, {"component": "libm.so.6()(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "openeuler"}, {"component": "libm.so.6(GLIBC_2.17)(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "openeuler"}, {"component": "libm.so.6(GLIBC_2.29)(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "openeuler"}, {"component": "libmpfr.so.6()(64bit)", "com_bin_name": "mpfr", "com_bin_version": "4.1.0", "com_src_name": "mpfr", "com_src_version": "4.1.0", "com_database": "openeuler"}, {"component": "libreadline.so.8()(64bit)", "com_bin_name": "readline", "com_bin_version": "8.0", "com_src_name": "readline", "com_src_version": "8.0", "com_database": "openeuler"}, {"component": "libsigsegv.so.2()(64bit)", "com_bin_name": "libsigsegv", "com_bin_version": "2.12", "com_src_name": "libsigsegv", "com_src_version": "2.12", "com_database": "openeuler"}, {"component": "rtld(GNU_HASH)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "openeuler"}, {"component": "libc.so.6(GLIBC_2.17)(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "openeuler"}]}] +\ No newline at end of file ++[{"binary_name": "sed", "bin_version": "4.8", "database": "os_version_1", "src_name": "sed", "src_version": "4.8", "requires": [{"component": "ld-linux-aarch64.so.1()(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "os_version_1"}, {"component": "ld-linux-aarch64.so.1(GLIBC_2.17)(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "os_version_1"}, {"component": "libacl.so.1()(64bit)", "com_bin_name": "libacl", "com_bin_version": "2.2.53", "com_src_name": "acl", "com_src_version": "2.2.53", "com_database": "os_version_1"}, {"component": "libacl.so.1(ACL_1.0)(64bit)", "com_bin_name": "libacl", "com_bin_version": "2.2.53", "com_src_name": "acl", "com_src_version": "2.2.53", "com_database": "os_version_1"}, {"component": "libselinux.so.1()(64bit)", "com_bin_name": "libselinux", "com_bin_version": "3.1", "com_src_name": "libselinux", "com_src_version": "3.1", "com_database": "os_version_1"}, {"component": "libselinux.so.1(LIBSELINUX_1.0)(64bit)", "com_bin_name": "libselinux", "com_bin_version": "3.1", "com_src_name": "libselinux", "com_src_version": "3.1", "com_database": "os_version_1"}, {"component": "rtld(GNU_HASH)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "os_version_1"}, {"component": "libc.so.6(GLIBC_2.17)(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "os_version_1"}]}, {"binary_name": "make", "bin_version": "4.3", "database": "os_version_1", "src_name": "make", "src_version": "4.3", "requires": [{"component": "/bin/sh", "com_bin_name": "bash", "com_bin_version": "5.0", "com_src_name": "bash", "com_src_version": "5.0", "com_database": "os_version_1"}, {"component": "/bin/sh", "com_bin_name": "bash", "com_bin_version": "5.0", "com_src_name": "bash", "com_src_version": "5.0", "com_database": "os_version_1"}, {"component": "/sbin/install-info", "com_bin_name": "info", "com_bin_version": "6.7", "com_src_name": "texinfo", "com_src_version": "6.7", "com_database": "os_version_1"}, {"component": "/sbin/install-info", "com_bin_name": "info", "com_bin_version": "6.7", "com_src_name": "texinfo", "com_src_version": "6.7", "com_database": "os_version_1"}, {"component": "ld-linux-aarch64.so.1()(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "os_version_1"}, {"component": "ld-linux-aarch64.so.1(GLIBC_2.17)(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "os_version_1"}, {"component": "libdl.so.2()(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "os_version_1"}, {"component": "libdl.so.2(GLIBC_2.17)(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "os_version_1"}, {"component": "libguile-2.0.so.22()(64bit)", "com_bin_name": "guile", "com_bin_version": "2.0.14", "com_src_name": "guile", "com_src_version": "2.0.14", "com_database": "os_version_1"}, {"component": "libguile-2.0.so.22(GUILE_2.0)(64bit)", "com_bin_name": "guile", "com_bin_version": "2.0.14", "com_src_name": "guile", "com_src_version": "2.0.14", "com_database": "os_version_1"}, {"component": "libpthread.so.0()(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "os_version_1"}, {"component": "libpthread.so.0(GLIBC_2.17)(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "os_version_1"}, {"component": "rtld(GNU_HASH)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "os_version_1"}, {"component": "libc.so.6(GLIBC_2.27)(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "os_version_1"}]}, {"binary_name": "coreutils", "bin_version": "8.32", "database": "os_version_1", "src_name": "coreutils", "src_version": "8.32", "requires": [{"component": "/sbin/install-info", "com_bin_name": "info", "com_bin_version": "6.7", "com_src_name": "texinfo", "com_src_version": "6.7", "com_database": "os_version_1"}, {"component": "/sbin/install-info", "com_bin_name": "info", "com_bin_version": "6.7", "com_src_name": "texinfo", "com_src_version": "6.7", "com_database": "os_version_1"}, {"component": "gmp", "com_bin_name": "gmp", "com_bin_version": "6.2.0", "com_src_name": "gmp", "com_src_version": "6.2.0", "com_database": "os_version_1"}, {"component": "ld-linux-aarch64.so.1()(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "os_version_1"}, {"component": "ld-linux-aarch64.so.1(GLIBC_2.17)(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "os_version_1"}, {"component": "libacl.so.1()(64bit)", "com_bin_name": "libacl", "com_bin_version": "2.2.53", "com_src_name": "acl", "com_src_version": "2.2.53", "com_database": "os_version_1"}, {"component": "libacl.so.1(ACL_1.0)(64bit)", "com_bin_name": "libacl", "com_bin_version": "2.2.53", "com_src_name": "acl", "com_src_version": "2.2.53", "com_database": "os_version_1"}, {"component": "libattr.so.1()(64bit)", "com_bin_name": "attr", "com_bin_version": "2.4.48", "com_src_name": "attr", "com_src_version": "2.4.48", "com_database": "os_version_1"}, {"component": "libattr.so.1(ATTR_1.1)(64bit)", "com_bin_name": "attr", "com_bin_version": "2.4.48", "com_src_name": "attr", "com_src_version": "2.4.48", "com_database": "os_version_1"}, {"component": "libcap.so.2()(64bit)", "com_bin_name": "libcap", "com_bin_version": "2.32", "com_src_name": "libcap", "com_src_version": "2.32", "com_database": "os_version_1"}, {"component": "libcrypto.so.1.1()(64bit)", "com_bin_name": "openssl-libs", "com_bin_version": "1.1.1f", "com_src_name": "openssl", "com_src_version": "1.1.1f", "com_database": "os_version_1"}, {"component": "libcrypto.so.1.1(OPENSSL_1_1_0)(64bit)", "com_bin_name": "openssl-libs", "com_bin_version": "1.1.1f", "com_src_name": "openssl", "com_src_version": "1.1.1f", "com_database": "os_version_1"}, {"component": "libgmp.so.10()(64bit)", "com_bin_name": "gmp", "com_bin_version": "6.2.0", "com_src_name": "gmp", "com_src_version": "6.2.0", "com_database": "os_version_1"}, {"component": "libpthread.so.0()(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "os_version_1"}, {"component": "libpthread.so.0(GLIBC_2.17)(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "os_version_1"}, {"component": "librt.so.1()(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "os_version_1"}, {"component": "librt.so.1(GLIBC_2.17)(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "os_version_1"}, {"component": "libselinux.so.1()(64bit)", "com_bin_name": "libselinux", "com_bin_version": "3.1", "com_src_name": "libselinux", "com_src_version": "3.1", "com_database": "os_version_1"}, {"component": "libselinux.so.1(LIBSELINUX_1.0)(64bit)", "com_bin_name": "libselinux", "com_bin_version": "3.1", "com_src_name": "libselinux", "com_src_version": "3.1", "com_database": "os_version_1"}, {"component": "ncurses", "com_bin_name": "ncurses", "com_bin_version": "6.2", "com_src_name": "ncurses", "com_src_version": "6.2", "com_database": "os_version_1"}, {"component": "rtld(GNU_HASH)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "os_version_1"}, {"component": "libc.so.6(GLIBC_2.28)(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "os_version_1"}]}, {"binary_name": "gcc", "bin_version": "9.3.1", "database": "os_version_1", "src_name": "gcc", "src_version": "9.3.1", "requires": [{"component": "/bin/sh", "com_bin_name": "bash", "com_bin_version": "5.0", "com_src_name": "bash", "com_src_version": "5.0", "com_database": "os_version_1"}, {"component": "binutils", "com_bin_name": "binutils", "com_bin_version": "2.34", "com_src_name": "binutils", "com_src_version": "2.34", "com_database": "os_version_1"}, {"component": "cpp", "com_bin_name": "cpp", "com_bin_version": "9.3.1", "com_src_name": "gcc", "com_src_version": "9.3.1", "com_database": "os_version_1"}, {"component": "glibc-devel", "com_bin_name": "glibc-devel", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "os_version_1"}, {"component": "ld-linux-aarch64.so.1()(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "os_version_1"}, {"component": "ld-linux-aarch64.so.1(GLIBC_2.17)(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "os_version_1"}, {"component": "libdl.so.2()(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "os_version_1"}, {"component": "libdl.so.2(GLIBC_2.17)(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "os_version_1"}, {"component": "libgcc", "com_bin_name": "libgcc", "com_bin_version": "9.3.1", "com_src_name": "gcc", "com_src_version": "9.3.1", "com_database": "os_version_1"}, {"component": "libgcc_s.so.1()(64bit)", "com_bin_name": "libgcc", "com_bin_version": "9.3.1", "com_src_name": "gcc", "com_src_version": "9.3.1", "com_database": "os_version_1"}, {"component": "libgcc_s.so.1(GCC_3.3)(64bit)", "com_bin_name": "libgcc", "com_bin_version": "9.3.1", "com_src_name": "gcc", "com_src_version": "9.3.1", "com_database": "os_version_1"}, {"component": "libgcc_s.so.1(GCC_4.2.0)(64bit)", "com_bin_name": "libgcc", "com_bin_version": "9.3.1", "com_src_name": "gcc", "com_src_version": "9.3.1", "com_database": "os_version_1"}, {"component": "libgmp.so.10()(64bit)", "com_bin_name": "gmp", "com_bin_version": "6.2.0", "com_src_name": "gmp", "com_src_version": "6.2.0", "com_database": "os_version_1"}, {"component": "libgomp", "com_bin_name": "libgomp", "com_bin_version": "9.3.1", "com_src_name": "gcc", "com_src_version": "9.3.1", "com_database": "os_version_1"}, {"component": "libm.so.6()(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "os_version_1"}, {"component": "libm.so.6(GLIBC_2.17)(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "os_version_1"}, {"component": "libmpc.so.3()(64bit)", "com_bin_name": "libmpc", "com_bin_version": "1.1.0", "com_src_name": "libmpc", "com_src_version": "1.1.0", "com_database": "os_version_1"}, {"component": "libmpfr.so.6()(64bit)", "com_bin_name": "mpfr", "com_bin_version": "4.1.0", "com_src_name": "mpfr", "com_src_version": "4.1.0", "com_database": "os_version_1"}, {"component": "libstdc++.so.6()(64bit)", "com_bin_name": "libstdc++", "com_bin_version": "9.3.1", "com_src_name": "gcc", "com_src_version": "9.3.1", "com_database": "os_version_1"}, {"component": "libstdc++.so.6(CXXABI_1.3)(64bit)", "com_bin_name": "libstdc++", "com_bin_version": "9.3.1", "com_src_name": "gcc", "com_src_version": "9.3.1", "com_database": "os_version_1"}, {"component": "libstdc++.so.6(CXXABI_1.3.9)(64bit)", "com_bin_name": "libstdc++", "com_bin_version": "9.3.1", "com_src_name": "gcc", "com_src_version": "9.3.1", "com_database": "os_version_1"}, {"component": "libstdc++.so.6(GLIBCXX_3.4)(64bit)", "com_bin_name": "libstdc++", "com_bin_version": "9.3.1", "com_src_name": "gcc", "com_src_version": "9.3.1", "com_database": "os_version_1"}, {"component": "libstdc++.so.6(GLIBCXX_3.4.15)(64bit)", "com_bin_name": "libstdc++", "com_bin_version": "9.3.1", "com_src_name": "gcc", "com_src_version": "9.3.1", "com_database": "os_version_1"}, {"component": "libstdc++.so.6(GLIBCXX_3.4.20)(64bit)", "com_bin_name": "libstdc++", "com_bin_version": "9.3.1", "com_src_name": "gcc", "com_src_version": "9.3.1", "com_database": "os_version_1"}, {"component": "libz.so.1()(64bit)", "com_bin_name": "zlib", "com_bin_version": "1.2.11", "com_src_name": "zlib", "com_src_version": "1.2.11", "com_database": "os_version_1"}, {"component": "rtld(GNU_HASH)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "os_version_1"}, {"component": "libc.so.6(GLIBC_2.17)(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "os_version_1"}]}, {"binary_name": "gawk", "bin_version": "5.1.0", "database": "os_version_1", "src_name": "gawk", "src_version": "5.1.0", "requires": [{"component": "filesystem", "com_bin_name": "filesystem", "com_bin_version": "3.14", "com_src_name": "filesystem", "com_src_version": "3.14", "com_database": "os_version_1"}, {"component": "ld-linux-aarch64.so.1()(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "os_version_1"}, {"component": "ld-linux-aarch64.so.1(GLIBC_2.17)(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "os_version_1"}, {"component": "libdl.so.2()(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "os_version_1"}, {"component": "libdl.so.2(GLIBC_2.17)(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "os_version_1"}, {"component": "libgmp.so.10()(64bit)", "com_bin_name": "gmp", "com_bin_version": "6.2.0", "com_src_name": "gmp", "com_src_version": "6.2.0", "com_database": "os_version_1"}, {"component": "libm.so.6()(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "os_version_1"}, {"component": "libm.so.6(GLIBC_2.17)(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "os_version_1"}, {"component": "libm.so.6(GLIBC_2.29)(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "os_version_1"}, {"component": "libmpfr.so.6()(64bit)", "com_bin_name": "mpfr", "com_bin_version": "4.1.0", "com_src_name": "mpfr", "com_src_version": "4.1.0", "com_database": "os_version_1"}, {"component": "libreadline.so.8()(64bit)", "com_bin_name": "readline", "com_bin_version": "8.0", "com_src_name": "readline", "com_src_version": "8.0", "com_database": "os_version_1"}, {"component": "libsigsegv.so.2()(64bit)", "com_bin_name": "libsigsegv", "com_bin_version": "2.12", "com_src_name": "libsigsegv", "com_src_version": "2.12", "com_database": "os_version_1"}, {"component": "rtld(GNU_HASH)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "os_version_1"}, {"component": "libc.so.6(GLIBC_2.17)(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "os_version_1"}]}] +\ No newline at end of file + +--- a/test/test_module/test_build/test_get_build_depend.py ++++ b/test/test_module/test_build/test_get_build_depend.py +@@ -37,7 +37,7 @@ param = { + "packagename": ["Judy"], + "depend_type": "builddep", + "parameter": { +- "db_priority": ["openeuler"], ++ "db_priority": ["os_version_1"], + "level": 2, + "self_build": True + } +@@ -55,7 +55,7 @@ class TestBuildDdepend(unittest.TestCase): + + """ + mock1.return_value = [] +- build = BuildDepend(db_list=['openeuler']) ++ build = BuildDepend(db_list=['os_version_1']) + build.build_depend(src_name=["Judy111"]) + binary, source = build.depend_dict + self.assertEqual(binary, {}, "Error in testing package not exists.") +@@ -70,10 +70,10 @@ class TestBuildDdepend(unittest.TestCase): + """ + mock1.return_value = TRUE_INSTALL_INFO + mock2.return_value = TRUE_BUILD_INFO +- build = BuildDepend(db_list=['openeuler']) ++ build = BuildDepend(db_list=['os_version_1']) + build.build_depend(src_name=["Judy"], level=1) + binary, source = build.depend_dict +- EXCEPT_BIN_INFO = {'sed': {'name': 'sed', 'version': '4.8', 'source_name': 'sed', 'database': 'openeuler'}} ++ EXCEPT_BIN_INFO = {'sed': {'name': 'sed', 'version': '4.8', 'source_name': 'sed', 'database': 'os_version_1'}} + self.assertDictEqual(binary, EXCEPT_BIN_INFO, "Error in testing build level 1.") + self.assertDictEqual(source, LEVEL_1_EXCEPT_SRC, "Error in testing build level 1.") + +@@ -88,7 +88,7 @@ class TestBuildDdepend(unittest.TestCase): + """ + mock1.return_value = TRUE_INSTALL_INFO + mock2.return_value = TRUE_BUILD_INFO +- build = BuildDepend(db_list=['openeuler']) ++ build = BuildDepend(db_list=['os_version_1']) + build.build_depend(src_name=["Judy"], level=2, self_build=True) + binary, source = build.depend_dict + self.assertDictEqual(binary, {}, "Error in testing true result.") +@@ -111,7 +111,7 @@ class TestBuildDdepend(unittest.TestCase): + + """ + with self.assertRaises(AttributeError): +- build_depend = BuildDepend(db_list=['openeuler']) ++ build_depend = BuildDepend(db_list=['os_version_1']) + build_depend.build_depend(src_name="Judy") + + +@@ -124,7 +124,7 @@ class TestBuildDdepend(unittest.TestCase): + """ + mock1.return_value = TRUE_INSTALL_INFO + mock2.return_value = [{}] +- build = BuildDepend(db_list=['openeuler']) ++ build = BuildDepend(db_list=['os_version_1']) + build.build_depend(src_name=["Judy"], self_build=True) + binary, source = build.depend_dict + self.assertDictEqual(binary, {}, "Error in testing empty build requires.") +@@ -140,10 +140,10 @@ class TestBuildDdepend(unittest.TestCase): + """ + mock1.return_value = TRUE_INSTALL_INFO + mock2.return_value = NOT_FOUND_COMP +- build = BuildDepend(db_list=['openeuler']) ++ build = BuildDepend(db_list=['os_version_1']) + build.build_depend(src_name=["Judy"], level=2, self_build=True) + binary, source = build.depend_dict +- EXCEPT_SRC_INFO = {'Judy': {'name': 'Judy', 'version': '1.0.5', 'database': 'openeuler', 'build': []}} ++ EXCEPT_SRC_INFO = {'Judy': {'name': 'Judy', 'version': '1.0.5', 'database': 'os_version_1', 'build': []}} + self.assertDictEqual(binary, {}, "Error in testing not found component.") + self.assertDictEqual(source, EXCEPT_SRC_INFO, "Error in testing not found component.") + +@@ -156,10 +156,10 @@ class TestBuildDdepend(unittest.TestCase): + """ + mock1.return_value = TRUE_INSTALL_INFO + mock2.return_value = NOT_SEARCHED_BUILD +- build = BuildDepend(db_list=['openeuler']) ++ build = BuildDepend(db_list=['os_version_1']) + build.build_depend(src_name=["Judy"], level=2, self_build=True) + binary, source = build.depend_dict +- EXCEPT_SRC_INFO = {'Judy11': {'name': 'Judy11', 'version': '1.0.5', 'database': 'openeuler', 'build': ['sed']}} ++ EXCEPT_SRC_INFO = {'Judy11': {'name': 'Judy11', 'version': '1.0.5', 'database': 'os_version_1', 'build': ['sed']}} + self.assertDictEqual(binary, {}, "Error in testing srcname not in searched packages.") + self.assertDictEqual(source, EXCEPT_SRC_INFO, "Error in testing srcname not in searched packages.") + +@@ -179,7 +179,7 @@ class TestBuildDdepend(unittest.TestCase): + ] + InstallRequires.get_install_req = mock.Mock(return_value=TRUE_INSTALL_INFO) + BuildRequires.get_build_req = mock.Mock(return_value=TRUE_BUILD_INFO) +- build = BuildDepend(db_list=['openeuler']) ++ build = BuildDepend(db_list=['os_version_1']) + build(**param) + binary, source = build.depend_dict + self.assertDictEqual(binary, {}, "Error in testing call func with true param.") + +--- a/test/test_module/test_cache/test_redis.py ++++ b/test/test_module/test_cache/test_redis.py +@@ -43,7 +43,7 @@ class TestBufferCache(unittest.TestCase): + mock_hgetall.return_value = dict( + source_dict=str(dict()), binary_dict=str(dict())) + mock_delete.return_value = None +- self.assertEqual(None, self.cache(pkgname="openeuler")) ++ self.assertEqual(None, self.cache(pkgname="os_version_1")) + + @mock.patch.object(Redis, "delete") + @mock.patch.object(Redis, "hmset") +@@ -62,7 +62,7 @@ class TestBufferCache(unittest.TestCase): + mock_expire.return_value = None + mock_hmset.return_value = None + mock_delete.return_value = None +- self.assertEqual(None, self.cache(pkgname="openeuler")) ++ self.assertEqual(None, self.cache(pkgname="os_version_1")) + + @mock.patch.object(Redis, "hgetall") + @mock.patch.object(Redis, "exists") +@@ -80,9 +80,9 @@ class TestBufferCache(unittest.TestCase): + ] + mock_hgetall.return_value = dict( + source_dict=str(dict()), binary_dict=str(dict())) +- self.assertEqual(None, self.cache(pkgname="openeuler")) ++ self.assertEqual(None, self.cache(pkgname="os_version_1")) + + @mock.patch.object(Redis, "exists") + def test_redis_exception(self, mock_exists): + mock_exists.side_effect = RedisError() +- self.assertEqual(None, self.cache(pkgname="openeuler")) ++ self.assertEqual(None, self.cache(pkgname="os_version_1")) + +--- a/test/test_module/test_cmd/mock_data/all_bin_package.json ++++ b/test/test_module/test_cmd/mock_data/all_bin_package.json +@@ -3,7 +3,7 @@ + "message": "Successful Operation", + "resp": [ + { +- "database": "openeuler", ++ "database": "os_version_1", + "license": "GPLv3+", + "pkg_name": "389-ds-base", + "source_name": "389-ds-base", +@@ -11,7 +11,7 @@ + "version": "1.4.0.31" + }, + { +- "database": "openeuler", ++ "database": "os_version_1", + "license": "GPLv3+", + "pkg_name": "389-ds-base-devel", + "source_name": "389-ds-base", +@@ -19,7 +19,7 @@ + "version": "1.4.0.31" + }, + { +- "database": "openeuler", ++ "database": "os_version_1", + "license": "GPLv3+", + "pkg_name": "389-ds-base-help", + "source_name": "389-ds-base", +@@ -27,7 +27,7 @@ + "version": "1.4.0.31" + }, + { +- "database": "openeuler", ++ "database": "os_version_1", + "license": "GPLv3+", + "pkg_name": "389-ds-base-legacy-tools", + "source_name": "389-ds-base", +@@ -35,7 +35,7 @@ + "version": "1.4.0.31" + }, + { +- "database": "openeuler", ++ "database": "os_version_1", + "license": "GPLv3+", + "pkg_name": "389-ds-base-snmp", + "source_name": "389-ds-base", +@@ -43,7 +43,7 @@ + "version": "1.4.0.31" + }, + { +- "database": "openeuler", ++ "database": "os_version_1", + "license": "Public Domain", + "pkg_name": "BareBonesBrowserLaunch", + "source_name": "BareBonesBrowserLaunch", +@@ -51,7 +51,7 @@ + "version": "3.1" + }, + { +- "database": "openeuler", ++ "database": "os_version_1", + "license": "Public Domain", + "pkg_name": "BareBonesBrowserLaunch-javadoc", + "source_name": "BareBonesBrowserLaunch", +@@ -59,7 +59,7 @@ + "version": "3.1" + }, + { +- "database": "openeuler", ++ "database": "os_version_1", + "license": "LGPLv2+", + "pkg_name": "CUnit", + "source_name": "CUnit", + +--- a/test/test_module/test_cmd/mock_data/all_src_package.json ++++ b/test/test_module/test_cmd/mock_data/all_src_package.json +@@ -3,70 +3,70 @@ + "message": "Successful Operation", + "resp": [ + { +- "database": "openeuler", ++ "database": "os_version_1", + "license": "GPLv3+", + "pkg_name": "389-ds-base", + "url": "https://www.port389.org", + "version": "1.4.0.31" + }, + { +- "database": "openeuler", ++ "database": "os_version_1", + "license": "Public Domain", + "pkg_name": "BareBonesBrowserLaunch", + "url": "http://www.centerkey.com/java/browser/", + "version": "3.1" + }, + { +- "database": "openeuler", ++ "database": "os_version_1", + "license": "LGPLv2+", + "pkg_name": "CUnit", + "url": "http://cunit.sourceforge.net/", + "version": "2.1.3" + }, + { +- "database": "openeuler", ++ "database": "os_version_1", + "license": "MIT", + "pkg_name": "ComputeLibrary", + "url": "https://developer.arm.com/technologies/compute-library", + "version": "20.02.1" + }, + { +- "database": "openeuler", ++ "database": "os_version_1", + "license": "Huawei Software License", + "pkg_name": "CreateImage", + "url": null, + "version": "0.0.5" + }, + { +- "database": "openeuler", ++ "database": "os_version_1", + "license": "Apache 2.0", + "pkg_name": "Cython", + "url": "https://cython.org/", + "version": "0.29.14" + }, + { +- "database": "openeuler", ++ "database": "os_version_1", + "license": "LGPLv2+ and GPLv2+", + "pkg_name": "GConf2", + "url": "http://projects.gnome.org/gconf/", + "version": "3.2.6" + }, + { +- "database": "openeuler", ++ "database": "os_version_1", + "license": "LGPLv2+", + "pkg_name": "GeoIP", + "url": "http://www.maxmind.com/app/c", + "version": "1.6.12" + }, + { +- "database": "openeuler", ++ "database": "os_version_1", + "license": "CC-BY-SA", + "pkg_name": "GeoIP-GeoLite-data", + "url": "http://dev.maxmind.com/geoip/legacy/geolite/", + "version": "2018.06" + }, + { +- "database": "openeuler", ++ "database": "os_version_1", + "license": "MIT", + "pkg_name": "GraphicsMagick", + "url": "http://www.graphicsmagick.org/", + +--- a/test/test_module/test_cmd/mock_data/be_depend.json ++++ b/test/test_module/test_cmd/mock_data/be_depend.json +@@ -5,25 +5,25 @@ + "binary_list": [ + { + "binary_name": "Judy-devel", +- "database": "openeuler", ++ "database": "os_version_1", + "source_name": "Judy", + "version": "1.0.5" + }, + { + "binary_name": "Judy-help", +- "database": "openeuler", ++ "database": "os_version_1", + "source_name": "Judy", + "version": "1.0.5" + }, + { + "binary_name": "Judy", +- "database": "openeuler", ++ "database": "os_version_1", + "source_name": "Judy", + "version": "1.0.5" + }, + { + "binary_name": "mariadb-oqgraph-engine", +- "database": "openeuler", ++ "database": "os_version_1", + "source_name": "mariadb", + "version": "10.3.9" + } +@@ -32,7 +32,7 @@ + "statistics": [ + { + "binary_sum": 4, +- "database": "openeuler", ++ "database": "os_version_1", + "source_sum": 0 + } + ] + +--- a/test/test_module/test_cmd/mock_data/build_depend.json ++++ b/test/test_module/test_cmd/mock_data/build_depend.json +@@ -5,63 +5,63 @@ + "binary_list": [ + { + "binary_name": "gcc", +- "database": "openeuler", ++ "database": "os_version_1", + "source_name": "gcc", + "version": "9.3.1" + }, + { + "binary_name": "make", +- "database": "openeuler", ++ "database": "os_version_1", + "source_name": "make", + "version": "4.3" + }, + { + "binary_name": "coreutils", +- "database": "openeuler", ++ "database": "os_version_1", + "source_name": "coreutils", + "version": "8.32" + }, + { + "binary_name": "gawk", +- "database": "openeuler", ++ "database": "os_version_1", + "source_name": "gawk", + "version": "5.1.0" + }, + { + "binary_name": "sed", +- "database": "openeuler", ++ "database": "os_version_1", + "source_name": "sed", + "version": "4.8" + } + ], + "source_list": [ + { +- "database": "openeuler", ++ "database": "os_version_1", + "source_name": "Judy", + "version": "1.0.5" + }, + { +- "database": "openeuler", ++ "database": "os_version_1", + "source_name": "gcc", + "version": "9.3.1" + }, + { +- "database": "openeuler", ++ "database": "os_version_1", + "source_name": "make", + "version": "4.3" + }, + { +- "database": "openeuler", ++ "database": "os_version_1", + "source_name": "coreutils", + "version": "8.32" + }, + { +- "database": "openeuler", ++ "database": "os_version_1", + "source_name": "gawk", + "version": "5.1.0" + }, + { +- "database": "openeuler", ++ "database": "os_version_1", + "source_name": "sed", + "version": "4.8" + } +@@ -69,7 +69,7 @@ + "statistics": [ + { + "binary_sum": 5, +- "database": "openeuler", ++ "database": "os_version_1", + "source_sum": 6 + } + ] + +--- a/test/test_module/test_cmd/mock_data/empty_judy_binary.json ++++ b/test/test_module/test_cmd/mock_data/empty_judy_binary.json +@@ -2,7 +2,7 @@ + "code": "200", + "message": "Successful Operation", + "resp": { +- "openeuler": [ ++ "os_version_1": [ + { + "bin_name": "Judy", + "description": "The package provides the most advanced core technology, the main\nadvantages are scalability, high performance and memory efficiency.", + +--- a/test/test_module/test_cmd/mock_data/install_depend.json ++++ b/test/test_module/test_cmd/mock_data/install_depend.json +@@ -5,36 +5,36 @@ + "binary_list": [ + { + "binary_name": "Judy", +- "database": "openeuler", ++ "database": "os_version_1", + "source_name": "Judy", + "version": "1.0.5" + }, + { + "binary_name": "bash", +- "database": "openeuler", ++ "database": "os_version_1", + "source_name": "bash", + "version": "5.0" + }, + { + "binary_name": "glibc", +- "database": "openeuler", ++ "database": "os_version_1", + "source_name": "glibc", + "version": "2.31" + } + ], + "source_list": [ + { +- "database": "openeuler", ++ "database": "os_version_1", + "source_name": "Judy", + "version": "1.0.5" + }, + { +- "database": "openeuler", ++ "database": "os_version_1", + "source_name": "bash", + "version": "5.0" + }, + { +- "database": "openeuler", ++ "database": "os_version_1", + "source_name": "glibc", + "version": "2.31" + } +@@ -42,7 +42,7 @@ + "statistics": [ + { + "binary_sum": 3, +- "database": "openeuler", ++ "database": "os_version_1", + "source_sum": 3 + } + ] + +--- a/test/test_module/test_cmd/mock_data/judy_binary.json ++++ b/test/test_module/test_cmd/mock_data/judy_binary.json +@@ -2,7 +2,7 @@ + "code": "200", + "message": "Successful Operation", + "resp": { +- "openeuler": [ ++ "os_version_1": [ + { + "bin_name": "Judy", + "description": "The package provides the most advanced core technology, the main\nadvantages are scalability, high performance and memory efficiency.", + +--- a/test/test_module/test_cmd/mock_data/judy_source.json ++++ b/test/test_module/test_cmd/mock_data/judy_source.json +@@ -2,7 +2,7 @@ + "code": "200", + "message": "Successful Operation", + "resp": { +- "openeuler": [ ++ "os_version_1": [ + { + "buildrequired": [ + "coreutils", + +--- a/test/test_module/test_cmd/mock_data/self_depend.json ++++ b/test/test_module/test_cmd/mock_data/self_depend.json +@@ -5,32 +5,32 @@ + "binary_list": [ + { + "binary_name": "Judy", +- "database": "openeuler", ++ "database": "os_version_1", + "source_name": "Judy", + "version": "1.0.5" + }, + { + "binary_name": "Judy-devel", +- "database": "openeuler", ++ "database": "os_version_1", + "source_name": "Judy", + "version": "1.0.5" + }, + { + "binary_name": "Judy-help", +- "database": "openeuler", ++ "database": "os_version_1", + "source_name": "Judy", + "version": "1.0.5" + }, + { + "binary_name": "bash", +- "database": "openeuler", ++ "database": "os_version_1", + "source_name": "bash", + "version": "5.0" + } + ], + "source_list": [ + { +- "database": "openeuler", ++ "database": "os_version_1", + "source_name": "Judy", + "version": "1.0.5" + } +@@ -38,7 +38,7 @@ + "statistics": [ + { + "binary_sum": 4, +- "database": "openeuler", ++ "database": "os_version_1", + "source_sum": 1 + } + ] + +--- a/test/test_module/test_cmd/test_all_package_cmd.py ++++ b/test/test_module/test_cmd/test_all_package_cmd.py +@@ -66,33 +66,33 @@ class TestAllPackages(unittest.TestCase): + parser.add_argument('-packagename') + parser.add_argument('-s') + parser.add_argument('-remote') +- args = parser.parse_args(['openeuler', '-packagename=Judy']) ++ args = parser.parse_args(['os_version_1', '-packagename=Judy']) + all_package.do_command(args) + c = self.r.getvalue().strip() + s = """ + =================================================================================================== + Package Name Database Version License URL Source Name + =================================================================================================== +- 389-ds-base openeuler 1.4.0.31 GPLv3+ https://www.port389. ++ 389-ds-base os_version_1 1.4.0.31 GPLv3+ https://www.port389. + org +- BareBonesBrowser openeuler 3.1 Public Domain http://www.centerkey ++ BareBonesBrowser os_version_1 3.1 Public Domain http://www.centerkey + Launch .com/java/browser/ +- CUnit openeuler 2.1.3 LGPLv2+ http://cunit.sourcef ++ CUnit os_version_1 2.1.3 LGPLv2+ http://cunit.sourcef + orge.net/ +- ComputeLibrary openeuler 20.02.1 MIT https://developer.ar ++ ComputeLibrary os_version_1 20.02.1 MIT https://developer.ar + m.com/technologies/c + ompute-library +- CreateImage openeuler 0.0.5 Huawei Software ++ CreateImage os_version_1 0.0.5 Huawei Software + License +- Cython openeuler 0.29.14 Apache 2.0 https://cython.org/ +- GConf2 openeuler 3.2.6 LGPLv2+ and http://projects.gnom ++ Cython os_version_1 0.29.14 Apache 2.0 https://cython.org/ ++ GConf2 os_version_1 3.2.6 LGPLv2+ and http://projects.gnom + GPLv2+ e.org/gconf/ +- GeoIP openeuler 1.6.12 LGPLv2+ http://www.maxmind.c ++ GeoIP os_version_1 1.6.12 LGPLv2+ http://www.maxmind.c + om/app/c +- GeoIP-GeoLite- openeuler 2018.06 CC-BY-SA http://dev.maxmind.c ++ GeoIP-GeoLite- os_version_1 2018.06 CC-BY-SA http://dev.maxmind.c + data om/geoip/legacy/geol + ite/ +- GraphicsMagick openeuler 1.3.30 MIT http://www.graphicsm ++ GraphicsMagick os_version_1 1.3.30 MIT http://www.graphicsm + agick.org/ + =================================================================================================== + """.strip() +@@ -111,23 +111,23 @@ class TestAllPackages(unittest.TestCase): + parser.add_argument('-packagename') + parser.add_argument('-s') + parser.add_argument('-remote') +- args = parser.parse_args(['openeuler', '-packagename=Judy', '-ss']) ++ args = parser.parse_args(['os_version_1', '-packagename=Judy', '-ss']) + all_package.do_command(args) + c = self.r.getvalue().strip() + s = """ + ==================================================================================================== + Package Name Database Version License URL + ==================================================================================================== +- 389-ds-base openeuler 1.4.0.31 GPLv3+ https://www.port389.org +- 389-ds-base-devel openeuler 1.4.0.31 GPLv3+ https://www.port389.org +- 389-ds-base-help openeuler 1.4.0.31 GPLv3+ https://www.port389.org +- 389-ds-base-legacy-tools openeuler 1.4.0.31 GPLv3+ https://www.port389.org +- 389-ds-base-snmp openeuler 1.4.0.31 GPLv3+ https://www.port389.org +- BareBonesBrowserLaunch openeuler 3.1 Public Domain http://www.centerkey.com/java ++ 389-ds-base os_version_1 1.4.0.31 GPLv3+ https://www.port389.org ++ 389-ds-base-devel os_version_1 1.4.0.31 GPLv3+ https://www.port389.org ++ 389-ds-base-help os_version_1 1.4.0.31 GPLv3+ https://www.port389.org ++ 389-ds-base-legacy-tools os_version_1 1.4.0.31 GPLv3+ https://www.port389.org ++ 389-ds-base-snmp os_version_1 1.4.0.31 GPLv3+ https://www.port389.org ++ BareBonesBrowserLaunch os_version_1 3.1 Public Domain http://www.centerkey.com/java + /browser/ +- BareBonesBrowserLaunch- openeuler 3.1 Public Domain http://www.centerkey.com/java ++ BareBonesBrowserLaunch- os_version_1 3.1 Public Domain http://www.centerkey.com/java + javadoc /browser/ +- CUnit openeuler 2.1.3 LGPLv2+ http://cunit.sourceforge.net/ ++ CUnit os_version_1 2.1.3 LGPLv2+ http://cunit.sourceforge.net/ + ==================================================================================================== + """.strip() + self.assertEqual(c, s) +@@ -145,7 +145,7 @@ class TestAllPackages(unittest.TestCase): + parser.add_argument('-packagename') + parser.add_argument('-s') + parser.add_argument('-remote') +- args = parser.parse_args(['openeuler', '-packagename=Judy']) ++ args = parser.parse_args(['os_version_1', '-packagename=Judy']) + all_package.do_command(args) + c = self.r.getvalue().strip() + s = """ +@@ -167,7 +167,7 @@ Request failed + parser.add_argument('-packagename') + parser.add_argument('-s') + parser.add_argument('-remote') +- args = parser.parse_args(['openeuler', '-packagename=Judy']) ++ args = parser.parse_args(['os_version_1', '-packagename=Judy']) + all_package.do_command(args) + c = self.r.getvalue().strip() + s = """ +@@ -190,7 +190,7 @@ Failed to get packages + parser.add_argument('-packagename') + parser.add_argument('-s') + parser.add_argument('-remote') +- args = parser.parse_args(['openeuler', '-packagename=Judy']) ++ args = parser.parse_args(['os_version_1', '-packagename=Judy']) + all_package.do_command(args) + c = self.r.getvalue().strip() + s = """ +@@ -211,7 +211,7 @@ HINT :The content is not a legal json format,please check the paramete + parser.add_argument('-packagename') + parser.add_argument('-s') + parser.add_argument('-remote') +- args = parser.parse_args(['openeuler', '-packagename=Judy']) ++ args = parser.parse_args(['os_version_1', '-packagename=Judy']) + all_package.do_command(args) + c = self.r.getvalue().strip() + s = """ +@@ -233,7 +233,7 @@ HINT :Please check the connection and try again + parser.add_argument('-packagename') + parser.add_argument('-s') + parser.add_argument('-remote') +- args = parser.parse_args(['openeuler', '-packagename=Judy']) ++ args = parser.parse_args(['os_version_1', '-packagename=Judy']) + all_package.do_command(args) + c = self.r.getvalue().strip() + self.assertEqual(c, "Sorry, no relevant information has been found yet\n".strip()) +@@ -251,7 +251,7 @@ HINT :Please check the connection and try again + parser.add_argument('-packagename') + parser.add_argument('-s') + parser.add_argument('-remote') +- args = parser.parse_args(['openeuler', '-packagename=Judy', '-ss']) ++ args = parser.parse_args(['os_version_1', '-packagename=Judy', '-ss']) + all_package.do_command(args) + c = self.r.getvalue().strip() + self.assertEqual(c, "Sorry, no relevant information has been found yet\n".strip()) + +--- a/test/test_module/test_cmd/test_be_depend_cmd.py ++++ b/test/test_module/test_cmd/test_be_depend_cmd.py +@@ -67,7 +67,7 @@ class TestBeDepend(unittest.TestCase): + parser.add_argument('-w') + parser.add_argument('-installorbuild') + parser.add_argument('-remote') +- args = parser.parse_args(['Judy', '-dbs=openeuler']) ++ args = parser.parse_args(['Judy', '-dbs=os_version_1']) + be_depend.do_command(args) + c = self.r.getvalue().strip() + s = """ +@@ -76,10 +76,10 @@ Binary + ==================================================================================================== + Binary name Source name Version Database name + ==================================================================================================== +- Judy-devel Judy 1.0.5 openeuler +- Judy-help Judy 1.0.5 openeuler +- Judy Judy 1.0.5 openeuler +- mariadb-oqgraph-engine mariadb 10.3.9 openeuler ++ Judy-devel Judy 1.0.5 os_version_1 ++ Judy-help Judy 1.0.5 os_version_1 ++ Judy Judy 1.0.5 os_version_1 ++ mariadb-oqgraph-engine mariadb 10.3.9 os_version_1 + ==================================================================================================== + Source + ==================================================================================================== +@@ -90,7 +90,7 @@ Statistics + ==================================================================================================== + Database name Binary Sum Source Sum + ==================================================================================================== +- openeuler 4 0 ++ os_version_1 4 0 + ==================================================================================================== + """.strip() + self.assertEqual(c, s) +@@ -110,7 +110,7 @@ Statistics + parser.add_argument('-w') + parser.add_argument('-installorbuild') + parser.add_argument('-remote') +- args = parser.parse_args(['Judy', '-dbs=openeuler']) ++ args = parser.parse_args(['Judy', '-dbs=os_version_1']) + be_depend.do_command(args) + c = self.r.getvalue().strip() + s = """ +@@ -138,7 +138,7 @@ HINT :Please check the service and try again + parser.add_argument('-w') + parser.add_argument('-installorbuild') + parser.add_argument('-remote') +- args = parser.parse_args(['Judy', '-dbs=openeuler']) ++ args = parser.parse_args(['Judy', '-dbs=os_version_1']) + be_depend.do_command(args) + c = self.r.getvalue().strip() + s = """ +@@ -165,7 +165,7 @@ HINT :Please check the parameter is valid and query again + parser.add_argument('-w') + parser.add_argument('-installorbuild') + parser.add_argument('-remote') +- args = parser.parse_args(['Judy', '-dbs=openeuler']) ++ args = parser.parse_args(['Judy', '-dbs=os_version_1']) + be_depend.do_command(args) + c = self.r.getvalue().strip() + s = """ +@@ -188,7 +188,7 @@ HINT :The content is not a legal json format,please check the paramete + parser.add_argument('-w') + parser.add_argument('-installorbuild') + parser.add_argument('-remote') +- args = parser.parse_args(['Judy', '-dbs=openeuler']) ++ args = parser.parse_args(['Judy', '-dbs=os_version_1']) + be_depend.do_command(args) + c = self.r.getvalue().strip() + s = """ + +--- a/test/test_module/test_cmd/test_build_depend_cmd.py ++++ b/test/test_module/test_cmd/test_build_depend_cmd.py +@@ -65,7 +65,7 @@ class TestBuildDepend(unittest.TestCase): + parser.add_argument('-dbs') + parser.add_argument('-level') + parser.add_argument('-remote') +- args = parser.parse_args(['Judy', '-dbs=openeuler']) ++ args = parser.parse_args(['Judy', '-dbs=os_version_1']) + build_depend.do_command(args) + c = self.r.getvalue().strip() + s = """ +@@ -74,28 +74,28 @@ Binary + ==================================================================================================== + Binary name Source name Version Database name + ==================================================================================================== +- gcc gcc 9.3.1 openeuler +- make make 4.3 openeuler +- coreutils coreutils 8.32 openeuler +- gawk gawk 5.1.0 openeuler +- sed sed 4.8 openeuler ++ gcc gcc 9.3.1 os_version_1 ++ make make 4.3 os_version_1 ++ coreutils coreutils 8.32 os_version_1 ++ gawk gawk 5.1.0 os_version_1 ++ sed sed 4.8 os_version_1 + ==================================================================================================== + Source + ==================================================================================================== + Source name Version Database name + ==================================================================================================== +- Judy 1.0.5 openeuler +- gcc 9.3.1 openeuler +- make 4.3 openeuler +- coreutils 8.32 openeuler +- gawk 5.1.0 openeuler +- sed 4.8 openeuler ++ Judy 1.0.5 os_version_1 ++ gcc 9.3.1 os_version_1 ++ make 4.3 os_version_1 ++ coreutils 8.32 os_version_1 ++ gawk 5.1.0 os_version_1 ++ sed 4.8 os_version_1 + ==================================================================================================== + Statistics + ==================================================================================================== + Database name Binary Sum Source Sum + ==================================================================================================== +- openeuler 5 6 ++ os_version_1 5 6 + ==================================================================================================== + """.strip() + self.assertEqual(c, s) +@@ -113,7 +113,7 @@ Statistics + parser.add_argument('-dbs') + parser.add_argument('-level') + parser.add_argument('-remote') +- args = parser.parse_args(['Judy', '-dbs=openeuler']) ++ args = parser.parse_args(['Judy', '-dbs=os_version_1']) + build_depend.do_command(args) + c = self.r.getvalue().strip() + s = """ +@@ -139,7 +139,7 @@ HINT :Please check the service and try again + parser.add_argument('-dbs') + parser.add_argument('-level') + parser.add_argument('-remote') +- args = parser.parse_args(['Judy', '-dbs=openeuler']) ++ args = parser.parse_args(['Judy', '-dbs=os_version_1']) + build_depend.do_command(args) + c = self.r.getvalue().strip() + s = """ +@@ -164,7 +164,7 @@ HINT :Please check the parameter is valid and query again + parser.add_argument('-dbs') + parser.add_argument('-level') + parser.add_argument('-remote') +- args = parser.parse_args(['Judy', '-dbs=openeuler']) ++ args = parser.parse_args(['Judy', '-dbs=os_version_1']) + build_depend.do_command(args) + c = self.r.getvalue().strip() + s = """ +@@ -185,7 +185,7 @@ HINT :The content is not a legal json format,please check the paramete + parser.add_argument('-dbs') + parser.add_argument('-level') + parser.add_argument('-remote') +- args = parser.parse_args(['Judy', '-dbs=openeuler']) ++ args = parser.parse_args(['Judy', '-dbs=os_version_1']) + build_depend.do_command(args) + c = self.r.getvalue().strip() + s = """ + +--- a/test/test_module/test_cmd/test_dbs_cmd.py ++++ b/test/test_module/test_cmd/test_dbs_cmd.py +@@ -52,7 +52,7 @@ class TestDB(unittest.TestCase): + """ + parser = argparse.ArgumentParser() + db_priority = DbPriorityCommand() +- data = {'code': '200', 'message': 'Successful Operation', 'resp': ['openeuler', 'fedora30']} ++ data = {'code': '200', 'message': 'Successful Operation', 'resp': ['os_version_1', 'os_version_2']} + + mock_get.return_value = mock_get_response(200, json.dumps(data)) + parser.add_argument('-remote') +@@ -61,7 +61,7 @@ class TestDB(unittest.TestCase): + c = self.r.getvalue().strip() + s = """ + DB priority +-[\'openeuler\', \'fedora30\'] ++[\'os_version_1\', \'os_version_2\'] + """.strip() + self.assertEqual(c, s) + + +--- a/test/test_module/test_cmd/test_install_depend_cmd.py ++++ b/test/test_module/test_cmd/test_install_depend_cmd.py +@@ -65,7 +65,7 @@ class TestInstallDepend(unittest.TestCase): + parser.add_argument('-dbs') + parser.add_argument('-level') + parser.add_argument('-remote') +- args = parser.parse_args(['Judy', '-dbs=openeuler']) ++ args = parser.parse_args(['Judy', '-dbs=os_version_1']) + install_depend.do_command(args) + c = self.r.getvalue().strip() + s = """ +@@ -74,23 +74,23 @@ Binary + ==================================================================================================== + Binary name Source name Version Database name + ==================================================================================================== +- Judy Judy 1.0.5 openeuler +- bash bash 5.0 openeuler +- glibc glibc 2.31 openeuler ++ Judy Judy 1.0.5 os_version_1 ++ bash bash 5.0 os_version_1 ++ glibc glibc 2.31 os_version_1 + ==================================================================================================== + Source + ==================================================================================================== + Source name Version Database name + ==================================================================================================== +- Judy 1.0.5 openeuler +- bash 5.0 openeuler +- glibc 2.31 openeuler ++ Judy 1.0.5 os_version_1 ++ bash 5.0 os_version_1 ++ glibc 2.31 os_version_1 + ==================================================================================================== + Statistics + ==================================================================================================== + Database name Binary Sum Source Sum + ==================================================================================================== +- openeuler 3 3 ++ os_version_1 3 3 + ==================================================================================================== + """.strip() + self.assertEqual(c, s) +@@ -108,7 +108,7 @@ Statistics + parser.add_argument('-dbs') + parser.add_argument('-level') + parser.add_argument('-remote') +- args = parser.parse_args(['Judy', '-dbs=openeuler']) ++ args = parser.parse_args(['Judy', '-dbs=os_version_1']) + install_depend.do_command(args) + c = self.r.getvalue().strip() + s = """ +@@ -134,7 +134,7 @@ HINT :Please check the service and try again + parser.add_argument('-dbs') + parser.add_argument('-level') + parser.add_argument('-remote') +- args = parser.parse_args(['Judy', '-dbs=openeuler']) ++ args = parser.parse_args(['Judy', '-dbs=os_version_1']) + install_depend.do_command(args) + c = self.r.getvalue().strip() + s = """ +@@ -159,7 +159,7 @@ HINT :Please check the parameter is valid and query again + parser.add_argument('-dbs') + parser.add_argument('-level') + parser.add_argument('-remote') +- args = parser.parse_args(['Judy', '-dbs=openeuler']) ++ args = parser.parse_args(['Judy', '-dbs=os_version_1']) + install_depend.do_command(args) + c = self.r.getvalue().strip() + s = """ +@@ -180,7 +180,7 @@ HINT :The content is not a legal json format,please check the paramete + parser.add_argument('-dbs') + parser.add_argument('-level') + parser.add_argument('-remote') +- args = parser.parse_args(['Judy', '-dbs=openeuler']) ++ args = parser.parse_args(['Judy', '-dbs=os_version_1']) + install_depend.do_command(args) + c = self.r.getvalue().strip() + s = """ + +--- a/test/test_module/test_cmd/test_self_depend_cmd.py ++++ b/test/test_module/test_cmd/test_self_depend_cmd.py +@@ -67,7 +67,7 @@ class TestSelfDepend(unittest.TestCase): + parser.add_argument('-w') + parser.add_argument('-s') + parser.add_argument('-remote') +- args = parser.parse_args(['Judy', '-dbs=openeuler']) ++ args = parser.parse_args(['Judy', '-dbs=os_version_1']) + self_depend.do_command(args) + c = self.r.getvalue().strip() + s = """ +@@ -76,22 +76,22 @@ Binary + ==================================================================================================== + Binary name Source name Version Database name + ==================================================================================================== +- Judy Judy 1.0.5 openeuler +- Judy-devel Judy 1.0.5 openeuler +- Judy-help Judy 1.0.5 openeuler +- bash bash 5.0 openeuler ++ Judy Judy 1.0.5 os_version_1 ++ Judy-devel Judy 1.0.5 os_version_1 ++ Judy-help Judy 1.0.5 os_version_1 ++ bash bash 5.0 os_version_1 + ==================================================================================================== + Source + ==================================================================================================== + Source name Version Database name + ==================================================================================================== +- Judy 1.0.5 openeuler ++ Judy 1.0.5 os_version_1 + ==================================================================================================== + Statistics + ==================================================================================================== + Database name Binary Sum Source Sum + ==================================================================================================== +- openeuler 4 1 ++ os_version_1 4 1 + ==================================================================================================== + """.strip() + self.assertEqual(c, s) +@@ -111,7 +111,7 @@ Statistics + parser.add_argument('-w') + parser.add_argument('-s') + parser.add_argument('-remote') +- args = parser.parse_args(['Judy', '-dbs=openeuler']) ++ args = parser.parse_args(['Judy', '-dbs=os_version_1']) + self_depend.do_command(args) + c = self.r.getvalue().strip() + s = """ +@@ -139,7 +139,7 @@ HINT :Please check the service and try again + parser.add_argument('-w') + parser.add_argument('-s') + parser.add_argument('-remote') +- args = parser.parse_args(['Judy', '-dbs=openeuler']) ++ args = parser.parse_args(['Judy', '-dbs=os_version_1']) + self_depend.do_command(args) + c = self.r.getvalue().strip() + s = """ +@@ -166,7 +166,7 @@ HINT :Please check the parameter is valid and query again + parser.add_argument('-w') + parser.add_argument('-s') + parser.add_argument('-remote') +- args = parser.parse_args(['Judy', '-dbs=openeuler']) ++ args = parser.parse_args(['Judy', '-dbs=os_version_1']) + self_depend.do_command(args) + c = self.r.getvalue().strip() + s = """ +@@ -189,7 +189,7 @@ HINT :The content is not a legal json format,please check the paramete + parser.add_argument('-w') + parser.add_argument('-s') + parser.add_argument('-remote') +- args = parser.parse_args(['Judy', '-dbs=openeuler']) ++ args = parser.parse_args(['Judy', '-dbs=os_version_1']) + self_depend.do_command(args) + c = self.r.getvalue().strip() + s = """ + +--- a/test/test_module/test_cmd/test_single_package_cmd.py ++++ b/test/test_module/test_cmd/test_single_package_cmd.py +@@ -65,7 +65,7 @@ class TestSinglePackage(unittest.TestCase): + parser.add_argument('packagename') + parser.add_argument('-s') + parser.add_argument('-remote') +- args = parser.parse_args(['openeuler', 'packagename=Judy']) ++ args = parser.parse_args(['os_version_1', 'packagename=Judy']) + single.do_command(args) + c = self.r.getvalue().strip() + s = """ +@@ -125,7 +125,7 @@ File List + parser.add_argument('packagename') + parser.add_argument('-s') + parser.add_argument('-remote') +- args = parser.parse_args(['openeuler', 'packagename=Judy', '-ss']) ++ args = parser.parse_args(['os_version_1', 'packagename=Judy', '-ss']) + single.do_command(args) + c = self.r.getvalue().strip() + s = """ +@@ -201,7 +201,7 @@ No related components + parser.add_argument('packagename') + parser.add_argument('-s') + parser.add_argument('-remote') +- args = parser.parse_args(['openeuler', 'packagename=Judy']) ++ args = parser.parse_args(['os_version_1', 'packagename=Judy']) + single.do_command(args) + c = self.r.getvalue().strip() + s = """ +@@ -223,7 +223,7 @@ Request failed + parser.add_argument('packagename') + parser.add_argument('-s') + parser.add_argument('-remote') +- args = parser.parse_args(['openeuler', 'packagename=Judy']) ++ args = parser.parse_args(['os_version_1', 'packagename=Judy']) + single.do_command(args) + c = self.r.getvalue().strip() + s = """ +@@ -246,7 +246,7 @@ Failed to get package + parser.add_argument('packagename') + parser.add_argument('-s') + parser.add_argument('-remote') +- args = parser.parse_args(['openeuler', 'packagename=Judy']) ++ args = parser.parse_args(['os_version_1', 'packagename=Judy']) + single.do_command(args) + c = self.r.getvalue().strip() + s = """ +@@ -267,7 +267,7 @@ HINT :The content is not a legal json format,please check the paramete + parser.add_argument('packagename') + parser.add_argument('-s') + parser.add_argument('-remote') +- args = parser.parse_args(['openeuler', 'packagename=Judy']) ++ args = parser.parse_args(['os_version_1', 'packagename=Judy']) + single.do_command(args) + c = self.r.getvalue().strip() + s = """ +@@ -289,7 +289,7 @@ HINT :Please check the connection and try again + parser.add_argument('packagename') + parser.add_argument('-s') + parser.add_argument('-remote') +- args = parser.parse_args(['openeuler', 'packagename=Judy']) ++ args = parser.parse_args(['os_version_1', 'packagename=Judy']) + single.do_command(args) + c = self.r.getvalue().strip() + s = """ +@@ -320,7 +320,7 @@ No related components + parser.add_argument('packagename') + parser.add_argument('-s') + parser.add_argument('-remote') +- args = parser.parse_args(['openeuler', 'packagename=Judy', '-ss']) ++ args = parser.parse_args(['os_version_1', 'packagename=Judy', '-ss']) + single.do_command(args) + c = self.r.getvalue().strip() + s = """ +@@ -351,7 +351,7 @@ No related components + parser.add_argument('packagename') + parser.add_argument('-s') + parser.add_argument('-remote') +- args = parser.parse_args(['openeuler', 'packagename=Judy']) ++ args = parser.parse_args(['os_version_1', 'packagename=Judy']) + single.do_command(args) + c = self.r.getvalue().strip() + s = """ + +--- a/test/test_module/test_common/test_remote.py ++++ b/test/test_module/test_common/test_remote.py +@@ -34,7 +34,7 @@ class TestRemoteService(unittest.TestCase): + + def test_request_method_error(self): + """Request mode error""" +- self.remote.request(url="openeuler", method="delete", max_retry=None) ++ self.remote.request(url="os_version_1", method="delete", max_retry=None) + self.assertNotEqual(None, getattr( + self.remote, "_request_error")) + +@@ -42,7 +42,7 @@ class TestRemoteService(unittest.TestCase): + def test_request_get(self, mock_get): + """get request""" + mock_get.return_value = requests.Response() +- self.remote.request(url="openeuler", method="get", max_retry=None) ++ self.remote.request(url="os_version_1", method="get", max_retry=None) + self.assertNotEqual(None, getattr( + self.remote, "_request_error")) + +@@ -50,7 +50,7 @@ class TestRemoteService(unittest.TestCase): + def test_request_post(self, mock_post): + """get request""" + mock_post.return_value = requests.Response() +- self.remote.request(url="openeuler", method="post", max_retry=None) ++ self.remote.request(url="os_version_1", method="post", max_retry=None) + self.assertNotEqual(None, getattr( + self.remote, "_request_error")) + +@@ -60,7 +60,7 @@ class TestRemoteService(unittest.TestCase): + response = requests.Response() + response.status_code = 200 + mock_post.return_value = response +- self.remote.request(url="openeuler", method="post", max_retry=None) ++ self.remote.request(url="os_version_1", method="post", max_retry=None) + self.assertEqual(None, getattr( + self.remote, "_request_error")) + +@@ -70,10 +70,10 @@ class TestRemoteService(unittest.TestCase): + response = requests.Response() + response.status_code = 200 + mock_post.return_value = response +- self.remote.request(url="openeuler", method="post", max_retry=None) ++ self.remote.request(url="os_version_1", method="post", max_retry=None) + self.assertEqual(200, self.remote.status_code) + + def test_response_content(self): + """Content of response""" +- self.remote.request(method="post", url="openeuler") ++ self.remote.request(method="post", url="os_version_1") + self.assertEqual(None, self.remote.text) + +--- a/test/test_module/test_database_query/test_database_query_bedepend/data/JudyBeDepend.json ++++ b/test/test_module/test_database_query/test_database_query_bedepend/data/JudyBeDepend.json +@@ -15,7 +15,7 @@ + "max_score": 0.0, + "hits": [ + { +- "_index": "openeuler-bedepend", ++ "_index": "os_version_1-bedepend", + "_type": "_doc", + "_id": "gX9Z-XYBamC2Cm-g0lHS", + "_score": 0.0, + +--- a/test/test_module/test_database_query/test_database_query_bedepend/test_database_query_bedepend.py ++++ b/test/test_module/test_database_query/test_database_query_bedepend/test_database_query_bedepend.py +@@ -31,13 +31,13 @@ class TestBeDependQuery(TestCase): + def test_normal_query(self): + self.query_instance.session.query = MagicMock(return_value=self.JUDY_BE_DEPEND_INFO) + +- result = self.be_depend_instance.get_be_req(binary_list=['Judy'], database='openeuler') ++ result = self.be_depend_instance.get_be_req(binary_list=['Judy'], database='os_version_1') + expect_value = MockData.read_mock_json_data(os.path.join(MOCK_DATA_FILE, 'returnJudyResult.json')) + + self.assertEqual(result, expect_value) + + def test_not_exist(self): + self.query_instance.session.query = MagicMock(return_value={}) +- result = self.be_depend_instance.get_be_req(binary_list=['Test'], database='openeuler') ++ result = self.be_depend_instance.get_be_req(binary_list=['Test'], database='os_version_1') + + self.assertEqual(result, []) + +--- a/test/test_module/test_database_query/test_database_query_build/data/JudySource.json ++++ b/test/test_module/test_database_query/test_database_query_build/data/JudySource.json +@@ -15,7 +15,7 @@ + "max_score": 0.0, + "hits": [ + { +- "_index": "openeuler-source", ++ "_index": "os_version_1-source", + "_type": "_doc", + "_id": "0n9Y-XYBamC2Cm-gXQvP", + "_score": 0.0, + +--- a/test/test_module/test_database_query/test_database_query_build/data/components_info,json ++++ b/test/test_module/test_database_query/test_database_query_build/data/components_info,json +@@ -15,7 +15,7 @@ + "max_score" : 0.0, + "hits" : [ + { +- "_index" : "openeuler-binary", ++ "_index" : "os_version_1-binary", + "_type" : "_doc", + "_id" : "9JvNx3cBamC2Cm-g6gEb", + "_score" : 0.0, +@@ -373,7 +373,7 @@ + } + }, + { +- "_index" : "openeuler-binary", ++ "_index" : "os_version_1-binary", + "_type" : "_doc", + "_id" : "d5vNx3cBamC2Cm-g8gQh", + "_score" : 0.0, + +--- a/test/test_module/test_database_query/test_database_query_build/data/returnJudyResult.json ++++ b/test/test_module/test_database_query/test_database_query_build/data/returnJudyResult.json +@@ -2,7 +2,7 @@ + { + "source_name": "Judy", + "src_version": "1.0.5", +- "database": "openeuler", ++ "database": "os_version_1", + "requires": [ + { + "component": "coreutils", +@@ -10,7 +10,7 @@ + "com_bin_version": "8.32", + "com_src_name": "coreutils", + "com_src_version": "8.32", +- "com_database": "openeuler" ++ "com_database": "os_version_1" + }, + { + "component": "gawk", +@@ -18,7 +18,7 @@ + "com_bin_version": "5.1.0", + "com_src_name": "gawk", + "com_src_version": "5.1.0", +- "com_database": "openeuler" ++ "com_database": "os_version_1" + } + ] + } + +--- a/test/test_module/test_database_query/test_database_query_build/test_database_query_build.py ++++ b/test/test_module/test_database_query/test_database_query_build/test_database_query_build.py +@@ -34,7 +34,7 @@ MOCK_DATA_FILE = os.path.join(os.path.dirname(os.path.abspath(__file__)), "data" + + + class TestBuildRequireDbQuery(TestCase): +- DATABASE_LIST = ['openeuler', 'fedora'] ++ DATABASE_LIST = ['os_version_1', 'os_version_2'] + JUDY_SOURCE_INFO = MockData.read_mock_json_data(os.path.join(MOCK_DATA_FILE, "JudySource.json")) + COMPONENTS_INFO = MockData.read_mock_json_data(os.path.join(MOCK_DATA_FILE, "components_info,json")) + EXCEPT_RETURN_VALUE = MockData.read_mock_json_data(os.path.join(MOCK_DATA_FILE, "returnJudyResult.json")) +@@ -67,7 +67,7 @@ class TestBuildRequireDbQuery(TestCase): + self.COMPONENTS_INFO + ]) + +- result = self.build_instance.get_build_req(source_list=['Judy'], specify_db='openeuler') ++ result = self.build_instance.get_build_req(source_list=['Judy'], specify_db='os_version_1') + + self.assertEqual(result, self.EXCEPT_RETURN_VALUE) + +@@ -91,6 +91,6 @@ class TestBuildRequireDbQuery(TestCase): + Returns: + """ + self.query_instance.session.query = MagicMock(return_value={}) +- result = self.build_instance.get_build_req(source_list=['Judy'], specify_db='openeuler') ++ result = self.build_instance.get_build_req(source_list=['Judy'], specify_db='os_version_1') + + self.assertEqual(result, []) + +--- a/test/test_module/test_database_query/test_database_query_install/data/JudyBinary.json ++++ b/test/test_module/test_database_query/test_database_query_install/data/JudyBinary.json +@@ -15,7 +15,7 @@ + "max_score": 0.0, + "hits": [ + { +- "_index": "openeuler-binary", ++ "_index": "os_version_1-binary", + "_type": "_doc", + "_id": "-H9Y-XYBamC2Cm-g8xgg", + "_score": 0.0, + +--- a/test/test_module/test_database_query/test_database_query_install/data/filesComponentsInfo.json ++++ b/test/test_module/test_database_query/test_database_query_install/data/filesComponentsInfo.json +@@ -15,7 +15,7 @@ + "max_score": 0.0, + "hits": [ + { +- "_index": "openeuler-binary", ++ "_index": "os_version_1-binary", + "_type": "_doc", + "_id": "OZvNx3cBamC2Cm-g8gUh", + "_score": 0.0, + +--- a/test/test_module/test_database_query/test_database_query_install/data/providesComponentsInfo.json ++++ b/test/test_module/test_database_query/test_database_query_install/data/providesComponentsInfo.json +@@ -15,7 +15,7 @@ + "max_score" : 0.0, + "hits" : [ + { +- "_index" : "openeuler-binary", ++ "_index" : "os_version_1-binary", + "_type" : "_doc", + "_id" : "eJvNx3cBamC2Cm-g6gAb", + "_score" : 0.0, +@@ -231,7 +231,7 @@ + } + }, + { +- "_index" : "openeuler-binary", ++ "_index" : "os_version_1-binary", + "_type" : "_doc", + "_id" : "9JvNx3cBamC2Cm-g6gEb", + "_score" : 0.0, + +--- a/test/test_module/test_database_query/test_database_query_install/data/returnJudyResult.json ++++ b/test/test_module/test_database_query/test_database_query_install/data/returnJudyResult.json +@@ -2,7 +2,7 @@ + { + "binary_name": "Judy", + "bin_version": "1.0.5", +- "database": "openeuler", ++ "database": "os_version_1", + "src_name": "Judy", + "src_version": "1.0.5", + "requires": [ +@@ -12,7 +12,7 @@ + "com_bin_version": "5.0", + "com_src_name": "bash", + "com_src_version": "5.0", +- "com_database": "openeuler" ++ "com_database": "os_version_1" + }, + { + "component": "ld-linux-aarch64.so.1()(64bit)", +@@ -20,7 +20,7 @@ + "com_bin_version": "2.31", + "com_src_name": "glibc", + "com_src_version": "2.31", +- "com_database": "openeuler" ++ "com_database": "os_version_1" + } + ] + } + +--- a/test/test_module/test_database_query/test_database_query_install/test_database_query_install.py ++++ b/test/test_module/test_database_query/test_database_query_install/test_database_query_install.py +@@ -22,7 +22,7 @@ MOCK_DATA_FILE = os.path.join(os.path.dirname(os.path.abspath(__file__)), "data" + + + class TestInstallRequireDbQuery(TestCase): +- DATABASE_LIST = ['openeuler', 'fedora'] ++ DATABASE_LIST = ['os_version_1', 'os_version_2'] + JUDY_BINARY_INFO = MockData.read_mock_json_data(os.path.join(MOCK_DATA_FILE, "JudyBinary.json")) + PROVIDES_COMPONENTS_INFO = MockData.read_mock_json_data(os.path.join(MOCK_DATA_FILE, "providesComponentsInfo.json")) + FILES_COMPONENTS_INFO = MockData.read_mock_json_data(os.path.join(MOCK_DATA_FILE, "filesComponentsInfo.json")) +@@ -72,7 +72,7 @@ class TestInstallRequireDbQuery(TestCase): + self.PROVIDES_COMPONENTS_INFO, + self.FILES_COMPONENTS_INFO]) + +- result = self.install_instance.get_install_req(binary_list=['Judy'], specify_db='openeuler') ++ result = self.install_instance.get_install_req(binary_list=['Judy'], specify_db='os_version_1') + result_require = self._format_return(result) + expect_require = self._format_return(self.EXPECT_VALUE) + +@@ -84,7 +84,7 @@ class TestInstallRequireDbQuery(TestCase): + Returns: + """ + self.query_instance.session.query = MagicMock(return_value={}) +- result = self.install_instance.get_install_req(binary_list=['Judy'], specify_db='openeuler') ++ result = self.install_instance.get_install_req(binary_list=['Judy'], specify_db='os_version_1') + + self.assertEqual(result, []) + + +--- a/test/test_module/test_database_query/test_database_query_package/data/JudyBinary.json ++++ b/test/test_module/test_database_query/test_database_query_package/data/JudyBinary.json +@@ -15,7 +15,7 @@ + "max_score": 0.0, + "hits": [ + { +- "_index": "openeuler-binary", ++ "_index": "os_version_1-binary", + "_type": "_doc", + "_id": "-H9Y-XYBamC2Cm-g8xgg", + "_score": 0.0, + +--- a/test/test_module/test_database_query/test_database_query_package/data/JudySource.json ++++ b/test/test_module/test_database_query/test_database_query_package/data/JudySource.json +@@ -15,7 +15,7 @@ + "max_score": 0.0, + "hits": [ + { +- "_index": "openeuler-source", ++ "_index": "os_version_1-source", + "_type": "_doc", + "_id": "0n9Y-XYBamC2Cm-gXQvP", + "_score": 0.0, + +--- a/test/test_module/test_database_query/test_database_query_package/data/allBinaryNoPaging.json ++++ b/test/test_module/test_database_query/test_database_query_package/data/allBinaryNoPaging.json +@@ -1,6 +1,6 @@ + [ + { +- "_index": "openeuler-binary", ++ "_index": "os_version_1-binary", + "_type": "_doc", + "_id": "1n9Y-XYBamC2Cm-g8xgg", + "_score": 1.0, +@@ -409,7 +409,7 @@ + } + }, + { +- "_index": "openeuler-binary", ++ "_index": "os_version_1-binary", + "_type": "_doc", + "_id": "139Y-XYBamC2Cm-g8xgg", + "_score": 1.0, +@@ -513,7 +513,7 @@ + } + }, + { +- "_index": "openeuler-binary", ++ "_index": "os_version_1-binary", + "_type": "_doc", + "_id": "2H9Y-XYBamC2Cm-g8xgg", + "_score": 1.0, +@@ -588,7 +588,7 @@ + } + }, + { +- "_index": "openeuler-binary", ++ "_index": "os_version_1-binary", + "_type": "_doc", + "_id": "2X9Y-XYBamC2Cm-g8xgg", + "_score": 1.0, +@@ -896,7 +896,7 @@ + } + }, + { +- "_index": "openeuler-binary", ++ "_index": "os_version_1-binary", + "_type": "_doc", + "_id": "2n9Y-XYBamC2Cm-g8xgg", + "_score": 1.0, + +--- a/test/test_module/test_database_query/test_database_query_package/data/allBinaryPaging.json ++++ b/test/test_module/test_database_query/test_database_query_package/data/allBinaryPaging.json +@@ -15,7 +15,7 @@ + "max_score": 1.0, + "hits": [ + { +- "_index": "openeuler-binary", ++ "_index": "os_version_1-binary", + "_type": "_doc", + "_id": "1n9Y-XYBamC2Cm-g8xgg", + "_score": 1.0, +@@ -424,7 +424,7 @@ + } + }, + { +- "_index": "openeuler-binary", ++ "_index": "os_version_1-binary", + "_type": "_doc", + "_id": "139Y-XYBamC2Cm-g8xgg", + "_score": 1.0, +@@ -528,7 +528,7 @@ + } + }, + { +- "_index": "openeuler-binary", ++ "_index": "os_version_1-binary", + "_type": "_doc", + "_id": "2H9Y-XYBamC2Cm-g8xgg", + "_score": 1.0, +@@ -603,7 +603,7 @@ + } + }, + { +- "_index": "openeuler-binary", ++ "_index": "os_version_1-binary", + "_type": "_doc", + "_id": "2X9Y-XYBamC2Cm-g8xgg", + "_score": 1.0, +@@ -911,7 +911,7 @@ + } + }, + { +- "_index": "openeuler-binary", ++ "_index": "os_version_1-binary", + "_type": "_doc", + "_id": "2n9Y-XYBamC2Cm-g8xgg", + "_score": 1.0, + +--- a/test/test_module/test_database_query/test_database_query_package/data/returnJudyResult.json ++++ b/test/test_module/test_database_query/test_database_query_package/data/returnJudyResult.json +@@ -1,7 +1,7 @@ + { + "source_name": "Judy", + "src_version": "1.0.5", +- "database": "openeuler", ++ "database": "os_version_1", + "binary_infos": [ + { + "bin_name": "Judy", + +--- a/test/test_module/test_database_query/test_database_query_package/test_query_bin_info.py ++++ b/test/test_module/test_database_query/test_database_query_package/test_query_bin_info.py +@@ -41,7 +41,7 @@ class TestQueryBinaryPkgInfo(TestCase): + """ + self.session.scan = MagicMock(return_value=self.ALL_BINARY_RPM_INFO) + self.session.count = MagicMock(return_value={"count": 5}) +- query_result = self.query_package.get_bin_info(binary_list=[], database='openeuler', page_num=1, page_size=20, ++ query_result = self.query_package.get_bin_info(binary_list=[], database='os_version_1', page_num=1, page_size=20, + command_line=True) + self.assertIsNotNone(query_result['data']) + +@@ -52,7 +52,7 @@ class TestQueryBinaryPkgInfo(TestCase): + """ + self.session.query = MagicMock(return_value=self.ALL_BINARY_INFO_PAGING) + self.session.count = MagicMock(return_value={"count": 5}) +- query_result = self.query_package.get_bin_info(binary_list=[], database='openeuler', page_num=1, page_size=5, ++ query_result = self.query_package.get_bin_info(binary_list=[], database='os_version_1', page_num=1, page_size=5, + command_line=False) + self.assertEqual(len(query_result['data']), 5) + +@@ -62,7 +62,7 @@ class TestQueryBinaryPkgInfo(TestCase): + Returns: + """ + self.session.query = MagicMock(return_value=self.JUDY_BINARY_INFO) +- query_result = self.query_package.get_bin_info(binary_list=['Judy'], database='openeuler', page_num=1, ++ query_result = self.query_package.get_bin_info(binary_list=['Judy'], database='os_version_1', page_num=1, + page_size=5, command_line=False) + self.assertIsNotNone(query_result['data'][0]['Judy']) + +@@ -72,7 +72,7 @@ class TestQueryBinaryPkgInfo(TestCase): + Returns: + """ + self.session.query = MagicMock(return_value=self.JUDY_BINARY_INFO) +- query_result = self.query_package.get_bin_info(binary_list=['Judy'], database='openeuler', page_num=1, ++ query_result = self.query_package.get_bin_info(binary_list=['Judy'], database='os_version_1', page_num=1, + page_size=5, command_line=True) + self.assertIsNotNone(query_result['data'][0]['Judy']) + +@@ -82,6 +82,6 @@ class TestQueryBinaryPkgInfo(TestCase): + Returns: + """ + self.session.query = MagicMock(return_value=dict(hits={})) +- query_result = self.query_package.get_bin_info(binary_list=['Judy'], database='openeuler', page_num=1, ++ query_result = self.query_package.get_bin_info(binary_list=['Judy'], database='os_version_1', page_num=1, + page_size=5, command_line=False) + self.assertListEqual(query_result['data'], []) + +--- a/test/test_module/test_database_query/test_database_query_package/test_query_bin_name.py ++++ b/test/test_module/test_database_query/test_database_query_package/test_query_bin_name.py +@@ -28,7 +28,7 @@ class TestQueryBinName(TestCase): + Returns: + + """ +- self.query_package = QueryPackage(database_list=['openeuler', 'fedora']) ++ self.query_package = QueryPackage(database_list=['os_version_1', 'os_version_2']) + self.session = self.query_package._db_session + + def test_query_specify_rpm(self): + +--- a/test/test_module/test_database_query/test_database_query_package/test_query_src_info.py ++++ b/test/test_module/test_database_query/test_database_query_package/test_query_src_info.py +@@ -38,7 +38,7 @@ class TestQuerySourcePkgInfo(TestCase): + + """ + self.session.query = MagicMock(return_value=ObtainMockData.get_data("JudySource.json")) +- result = self.query_package.get_src_info(src_list=['Judy'], database='openeuler', page_num=1, page_size=20, ++ result = self.query_package.get_src_info(src_list=['Judy'], database='os_version_1', page_num=1, page_size=20, + command_line=False) + + self.assertIsNotNone(result['data'][0]['Judy']) + +--- a/test/test_module/test_database_query/test_database_query_package/test_query_src_name.py ++++ b/test/test_module/test_database_query/test_database_query_package/test_query_src_name.py +@@ -28,7 +28,7 @@ class TestQuerySrcName(TestCase): + Returns: + + """ +- self.query_package = QueryPackage(database_list=['openeuler', 'fedora']) ++ self.query_package = QueryPackage(database_list=['os_version_1', 'os_version_2']) + self.session = self.query_package._db_session + + def test_query_specify_rpm(self): +@@ -41,7 +41,7 @@ class TestQuerySrcName(TestCase): + result = self.query_package.get_src_name(binary_list=binary_list) + expect_value = {'binary_name': 'Judy', + 'bin_version': '1.0.5', +- 'database': 'openeuler', ++ 'database': 'os_version_1', + 'src_name': 'Judy', + 'src_version': '1.0.5'} + +@@ -78,6 +78,6 @@ class TestQuerySrcName(TestCase): + """ + self.session.query = MagicMock(return_value={}) + binary_list = ["Test123"] +- result = self.query_package.get_src_name(binary_list=binary_list, specify_db='openeuler') ++ result = self.query_package.get_src_name(binary_list=binary_list, specify_db='os_version_1') + + self.assertListEqual(result, []) + +--- a/test/test_module/test_db_priority/data/db_priority.json ++++ b/test/test_module/test_db_priority/data/db_priority.json +@@ -4,5 +4,5 @@ + "_id": "3Hyk23YBamC2Cm-gHrpE", + "_score": 1.0, + "_source": +- {"database_name": "openeuler", ++ {"database_name": "os_version_1", + "priority": 1}}]}} +\ No newline at end of file + +--- a/test/test_module/test_graph/test_graphinfo.py ++++ b/test/test_module/test_graph/test_graphinfo.py +@@ -60,7 +60,7 @@ class TestGraphInfo(unittest.TestCase): + "version": "v1.20.0.1", + "source_name": "Judy", + "level": 2, +- "database": "openeuler-20.03", ++ "database": "os_version_1", + "install": [ + "attr", + "Judy" +@@ -69,7 +69,7 @@ class TestGraphInfo(unittest.TestCase): + }, {"Judy": { + "name": "Judy", + "version": "v1.20.0.1", +- "database": "openeuler-20.03", ++ "database": "os_version_1", + "build": [ + "gcc", + "make" +@@ -77,7 +77,7 @@ class TestGraphInfo(unittest.TestCase): + }, "CUnit": { + "name": "CUnit", + "version": "v1.20.0.1", +- "database": "openeuler-20.03" ++ "database": "os_version_1" + }}) + graph = GraphInfo(depend=BaseDepend()) + + +--- a/test/test_module/test_init/data/error_config_yaml.txt ++++ b/test/test_module/test_init/data/error_config_yaml.txt +@@ -4,7 +4,7 @@ lifecycle: enable + priority: 1 + src_db_file: + - bin_db_file: +- dbname: fedora30 ++ dbname: os_version_2 + lifecycle: enable + priority: 2 + src_db_file: + +deleted file mode 100755 +Binary files a/test/test_module/test_init/data/openeuler-right-binary.sqlite and /dev/null differ + +deleted file mode 100755 +Binary files a/test/test_module/test_init/data/openeuler-right-filelist.sqlite and /dev/null differ + +deleted file mode 100755 +Binary files a/test/test_module/test_init/data/openeuler-right-source.sqlite and /dev/null differ + +new file mode 100755 +Binary files /dev/null and b/test/test_module/test_init/data/os_version_1-right-binary.sqlite differ + +new file mode 100755 +Binary files /dev/null and b/test/test_module/test_init/data/os_version_1-right-filelist.sqlite differ + +new file mode 100755 +Binary files /dev/null and b/test/test_module/test_init/data/os_version_1-right-source.sqlite differ + +--- a/test/test_module/test_init/test_import.py ++++ b/test/test_module/test_init/test_import.py +@@ -36,12 +36,12 @@ class TestImport(unittest.TestCase): + self._init_service = InitializeService() + self._path = os.path.dirname(__file__) + self.src_dbfile = os.path.join( +- self._path, "data", "openeuler-right-source.sqlite") ++ self._path, "data", "os_version_1-right-source.sqlite") + self.bin_dbfile = os.path.join( +- self._path, "data", "openeuler-right-binary.sqlite") ++ self._path, "data", "os_version_1-right-binary.sqlite") + self.filelist_dbfile = os.path.join( +- self._path, "data", "openeuler-right-filelist.sqlite") +- self._repo = dict(dbname="openeuler", src_db_file=self.src_dbfile, ++ self._path, "data", "os_version_1-right-filelist.sqlite") ++ self._repo = dict(dbname="os_version_1", src_db_file=self.src_dbfile, + bin_db_file=self.bin_dbfile, file_list=self.filelist_dbfile, priority=1) + + def test_delete_file(self): +@@ -137,9 +137,9 @@ class TestImport(unittest.TestCase): + mock__clear_all_index.return_value = None + mock___iter__.return_value = iter([self._repo]) + mock__sqlite_file.return_value = None +- mock__create_index.return_value = ["openeuler"] ++ mock__create_index.return_value = ["os_version_1"] + init_service = InitializeService() +- setattr(init_service, "_repo", dict(dbname="openeuler")) ++ setattr(init_service, "_repo", dict(dbname="os_version_1")) + self.assertEqual(None, init_service.import_depend(path="")) + + @mock.patch.object(Elasticsearch, "__init__") +@@ -206,7 +206,7 @@ class TestImport(unittest.TestCase): + with mock.patch("packageship.application.initialize.integration.RepoConfig.validate", + new_callable=mock.PropertyMock) as mock_validate: + mock_validate.return_value = True +- mock_get_db_priority.return_value = ["openeuler"] ++ mock_get_db_priority.return_value = ["os_version_1"] + mock___init__.return_value = None + elastic = ElasticSearch() + elastic.delete_index = lambda x: None +@@ -236,14 +236,14 @@ class TestImport(unittest.TestCase): + + mock___init__.return_value = None + elastic = ElasticSearch() +- elastic.create_index = lambda x: ["openeuler"] ++ elastic.create_index = lambda x: ["os_version_1"] + elastic.delete_index = lambda x: None + mock_connection.return_value = elastic + init_service = InitializeService() + setattr(init_service, "_repo", self._repo) + init_service.import_depend(path="") + self.assertEqual( +- ["openeuler"], getattr(init_service, "_fail")) ++ ["os_version_1"], getattr(init_service, "_fail")) + + @mock.patch.object(Elasticsearch, "__init__") + @mock.patch.object(DatabaseSession, "connection") +@@ -269,12 +269,12 @@ class TestImport(unittest.TestCase): + mock__source_depend.side_effect = TypeError() + mock__create_index.return_value = [] + elastic = ElasticSearch() +- elastic.delete_index = lambda x: ["openeuler"] ++ elastic.delete_index = lambda x: ["os_version_1"] + mock_connection.return_value = elastic + init_service = InitializeService() + setattr(init_service, "_repo", self._repo) + init_service.import_depend(path="") +- self.assertEqual(["openeuler"], getattr(init_service, "_fail")) ++ self.assertEqual(["os_version_1"], getattr(init_service, "_fail")) + + def test_query_sqlite(self): + """query sqlite database""" +@@ -288,7 +288,7 @@ class TestImport(unittest.TestCase): + def test_esjson_set_item(self): + """json set data""" + es_json = ESJson() +- es_json.database = "openeuler" ++ es_json.database = "os_version_1" + + def test_load_config_exception(self): + """Error loading configuration file""" +@@ -358,4 +358,4 @@ class TestImport(unittest.TestCase): + init_service = InitializeService() + setattr(init_service, "_repo", self._repo) + init_service.import_depend(path="") +- self.assertEqual(["openeuler"], getattr(init_service, "_fail")) ++ self.assertEqual(["os_version_1"], getattr(init_service, "_fail")) + +--- a/test/test_module/test_init/test_init_config.py ++++ b/test/test_module/test_init/test_init_config.py +@@ -51,22 +51,22 @@ class TestLoadConfig(unittest.TestCase): + + def test_repo_database_error(self): + """Database error in repo source""" +- setattr(self.repo_config, "_repo", ["openeuler"]) ++ setattr(self.repo_config, "_repo", ["os_version_1"]) + self.assertEqual(False, self.repo_config.validate) + + setattr(self.repo_config, "_repo", [dict(database="test-database")]) + self.assertEqual(False, self.repo_config.validate) + + setattr(self.repo_config, "_repo", [ +- dict(dbname="openeuler"), dict(dbname="openeuler")]) ++ dict(dbname="os_version_1"), dict(dbname="os_version_1")]) + self.assertEqual(False, self.repo_config.validate) + + setattr(self.repo_config, "_repo", [ +- dict(dbname="openeuler"), dict(dbname="")]) ++ dict(dbname="os_version_1"), dict(dbname="")]) + self.assertEqual(False, self.repo_config.validate) + + setattr(self.repo_config, "_repo", [ +- dict(dbname="openeuler"), dict(dbname="openEuler20.09")]) ++ dict(dbname="os_version_1"), dict(dbname="openEuler20.09")]) + self.assertEqual(False, self.repo_config.validate) + + @mock.patch.object(RepoConfig, "_validate_priority") +@@ -81,7 +81,7 @@ class TestLoadConfig(unittest.TestCase): + setattr(self.repo_config, "_repo", [dict()]) + self.assertEqual(False, self.repo_config.validate) + +- setattr(self.repo_config, "_repo", [dict(src_db_file="openeuler-src")]) ++ setattr(self.repo_config, "_repo", [dict(src_db_file="os_version_1-src")]) + self.assertEqual(False, self.repo_config.validate) + + setattr(self.repo_config, "_repo", [dict(src_db_file="http://127.0.0.1:5000/repo", +@@ -95,10 +95,10 @@ class TestLoadConfig(unittest.TestCase): + setattr(self.repo_config, "_repo", [""]) + self.assertEqual(False, self.repo_config.validate) + +- setattr(self.repo_config, "_repo", [dict(dbname="openeuler")]) ++ setattr(self.repo_config, "_repo", [dict(dbname="os_version_1")]) + self.assertEqual(False, self.repo_config.validate) + +- setattr(self.repo_config, "_repo", [dict(priority="openeuler")]) ++ setattr(self.repo_config, "_repo", [dict(priority="os_version_1")]) + self.assertEqual(False, self.repo_config.validate) + + setattr(self.repo_config, "_repo", [dict(priority=-1)]) +@@ -110,11 +110,11 @@ class TestLoadConfig(unittest.TestCase): + def test_validate_failed(self): + """validate failed""" + setattr(self.repo_config, "_repo", [ +- dict(dbname="openeuler", priority=1)]) ++ dict(dbname="os_version_1", priority=1)]) + self.assertEqual(False, self.repo_config.validate) + self.assertIsNotNone(self.repo_config.message) + for repo in self.repo_config: + self.assertIsNotNone(repo) + setattr(self.repo_config, "_repo", [ +- dict(database="openeuler", priority=1)]) ++ dict(database="os_version_1", priority=1)]) + self.assertEqual(False, self.repo_config.validate) + +--- a/test/test_module/test_init/test_repo.py ++++ b/test/test_module/test_init/test_repo.py +@@ -84,7 +84,7 @@ class TestRepoFile(unittest.TestCase): + mock_status_code.return_value = 200 + with mock.patch("packageship.application.common.remote.RemoteService.content", + new_callable=mock.PropertyMock) as mock_content: +- mock_content.return_value = "openeuler".encode("utf-8") ++ mock_content.return_value = "os_version_1".encode("utf-8") + with self.assertRaises(FileNotFoundError): + self.repo_file.remote_file(path="http://127.0.0.1") + with self.assertRaises(FileNotFoundError): +@@ -97,7 +97,7 @@ class TestRepoFile(unittest.TestCase): + + def test_location_file_not_regex(self): + """Incorrect local file path match""" +- self.assertEqual(None, self.repo_file.location_file(path="openeuler")) ++ self.assertEqual(None, self.repo_file.location_file(path="os_version_1")) + + @mock.patch.object(Unpack, "dispatch") + @mock.patch.object(shutil, "copyfile") +@@ -122,13 +122,13 @@ class TestRepoFile(unittest.TestCase): + @mock.patch.object(RepoFile, "_location") + def test_location_file(self, mock__location): + """local file""" +- mock__location.return_value = "/openeuler/repo" ++ mock__location.return_value = "/os_version_1/repo" + with self.assertRaises(FileNotFoundError): +- self.repo_file.location_file(path="openeuler") ++ self.repo_file.location_file(path="os_version_1") + with mock.patch.object(RepoFile, "_unzip_file") as mock__unzip_file: +- mock__unzip_file.return_value = "/openeuler/repo" +- self.assertEqual("/openeuler/repo", +- self.repo_file.location_file(path="openeuler")) ++ mock__unzip_file.return_value = "/os_version_1/repo" ++ self.assertEqual("/os_version_1/repo", ++ self.repo_file.location_file(path="os_version_1")) + + def test_extract_file_path(self): + """Remote file matching""" +@@ -137,15 +137,15 @@ class TestRepoFile(unittest.TestCase): + mock_status_code.return_value = 200 + with mock.patch("packageship.application.common.remote.RemoteService.text", + new_callable=mock.PropertyMock) as mock_text: +- mock_text.return_value = "openeuler" ++ mock_text.return_value = "os_version_1" + with self.assertRaises(FileNotFoundError): + self.repo_file.remote_file( +- path="openeuler", file_type="primary") ++ path="os_version_1", file_type="primary") + mock_text.return_value = 'href="https://openeuler/src.primary.sqlite.bz2"' + mock_status_code.side_effect = [200, 200, 404] + with self.assertRaises(FileNotFoundError): + self.repo_file.remote_file( +- path="openeuler", file_type="primary") ++ path="os_version_1", file_type="primary") + + @mock.patch.object(shutil, "copyfile") + @mock.patch("re.match", new_callable=mock.PropertyMock) + +--- a/test/test_module/test_install/data/empty_require_except_bin.json ++++ b/test/test_module/test_install/data/empty_require_except_bin.json +@@ -1 +1 @@ +-{"Judy": {"name": "Judy", "version": "1.0.5", "source_name": "Judy", "database": "openeuler", "install": []}} +\ No newline at end of file ++{"Judy": {"name": "Judy", "version": "1.0.5", "source_name": "Judy", "database": "os_version_1", "install": []}} +\ No newline at end of file + +--- a/test/test_module/test_install/data/empty_require_except_src.json ++++ b/test/test_module/test_install/data/empty_require_except_src.json +@@ -1 +1 @@ +-{"Judy": {"name": "Judy", "version": "1.0.5", "database": "openeuler"}} +\ No newline at end of file ++{"Judy": {"name": "Judy", "version": "1.0.5", "database": "os_version_1"}} +\ No newline at end of file + +--- a/test/test_module/test_install/data/empty_require_install_info.json ++++ b/test/test_module/test_install/data/empty_require_install_info.json +@@ -1 +1 @@ +-[{"binary_name": "Judy", "bin_version": "1.0.5", "database": "openeuler", "src_name": "Judy", "src_version": "1.0.5", "requires": []}] +\ No newline at end of file ++[{"binary_name": "Judy", "bin_version": "1.0.5", "database": "os_version_1", "src_name": "Judy", "src_version": "1.0.5", "requires": []}] +\ No newline at end of file + +--- a/test/test_module/test_install/data/expect_bin.json ++++ b/test/test_module/test_install/data/expect_bin.json +@@ -1 +1 @@ +-{"Judy": {"name": "Judy", "version": "1.0.5", "source_name": "Judy", "database": "openeuler", "install": ["bash", "glibc"]}} +\ No newline at end of file ++{"Judy": {"name": "Judy", "version": "1.0.5", "source_name": "Judy", "database": "os_version_1", "install": ["bash", "glibc"]}} +\ No newline at end of file + +--- a/test/test_module/test_install/data/expect_src.json ++++ b/test/test_module/test_install/data/expect_src.json +@@ -1 +1 @@ +-{"Judy": {"name": "Judy", "version": "1.0.5", "database": "openeuler"}} +\ No newline at end of file ++{"Judy": {"name": "Judy", "version": "1.0.5", "database": "os_version_1"}} +\ No newline at end of file + +--- a/test/test_module/test_install/data/level_1_expect_bin.json ++++ b/test/test_module/test_install/data/level_1_expect_bin.json +@@ -1 +1 @@ +-{"bash": {"name": "bash", "version": "5.0", "source_name": "bash", "database": "openeuler"}, "glibc": {"name": "glibc", "version": "2.31", "source_name": "glibc", "database": "openeuler"}, "Judy": {"name": "Judy", "version": "1.0.5", "source_name": "Judy", "database": "openeuler", "install": ["bash", "glibc"]}} +\ No newline at end of file ++{"bash": {"name": "bash", "version": "5.0", "source_name": "bash", "database": "os_version_1"}, "glibc": {"name": "glibc", "version": "2.31", "source_name": "glibc", "database": "os_version_1"}, "Judy": {"name": "Judy", "version": "1.0.5", "source_name": "Judy", "database": "os_version_1", "install": ["bash", "glibc"]}} +\ No newline at end of file + +--- a/test/test_module/test_install/data/level_1_expect_src.json ++++ b/test/test_module/test_install/data/level_1_expect_src.json +@@ -1 +1 @@ +-{"bash": {"name": "bash", "version": "5.0", "database": "openeuler"}, "glibc": {"name": "glibc", "version": "2.31", "database": "openeuler"}, "Judy": {"name": "Judy", "version": "1.0.5", "database": "openeuler"}} +\ No newline at end of file ++{"bash": {"name": "bash", "version": "5.0", "database": "os_version_1"}, "glibc": {"name": "glibc", "version": "2.31", "database": "os_version_1"}, "Judy": {"name": "Judy", "version": "1.0.5", "database": "os_version_1"}} +\ No newline at end of file + +--- a/test/test_module/test_install/data/params_with_expect_bin.json ++++ b/test/test_module/test_install/data/params_with_expect_bin.json +@@ -1 +1 @@ +-{"Judy": {"name": "Judy", "version": "1.0.5", "source_name": "Judy", "database": "openeuler", "install": ["bash", "glibc"]}} +\ No newline at end of file ++{"Judy": {"name": "Judy", "version": "1.0.5", "source_name": "Judy", "database": "os_version_1", "install": ["bash", "glibc"]}} +\ No newline at end of file + +--- a/test/test_module/test_install/data/params_with_expect_src.json ++++ b/test/test_module/test_install/data/params_with_expect_src.json +@@ -1 +1 @@ +-{"Judy": {"name": "Judy", "version": "1.0.5", "database": "openeuler"}} +\ No newline at end of file ++{"Judy": {"name": "Judy", "version": "1.0.5", "database": "os_version_1"}} +\ No newline at end of file + +--- a/test/test_module/test_install/data/true_install_info.json ++++ b/test/test_module/test_install/data/true_install_info.json +@@ -1 +1 @@ +-[{"binary_name": "Judy", "bin_version": "1.0.5", "database": "openeuler", "src_name": "Judy", "src_version": "1.0.5", "requires": [{"component": "/bin/sh", "com_bin_name": "bash", "com_bin_version": "5.0", "com_src_name": "bash", "com_src_version": "5.0", "com_database": "openeuler"}, {"component": "/bin/sh", "com_bin_name": "bash", "com_bin_version": "5.0", "com_src_name": "bash", "com_src_version": "5.0", "com_database": "openeuler"}, {"component": "ld-linux-aarch64.so.1()(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "openeuler"}, {"component": "ld-linux-aarch64.so.1(GLIBC_2.17)(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "openeuler"}, {"component": "rtld(GNU_HASH)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "openeuler"}, {"component": "libc.so.6(GLIBC_2.17)(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "openeuler"}]}] +\ No newline at end of file ++[{"binary_name": "Judy", "bin_version": "1.0.5", "database": "os_version_1", "src_name": "Judy", "src_version": "1.0.5", "requires": [{"component": "/bin/sh", "com_bin_name": "bash", "com_bin_version": "5.0", "com_src_name": "bash", "com_src_version": "5.0", "com_database": "os_version_1"}, {"component": "/bin/sh", "com_bin_name": "bash", "com_bin_version": "5.0", "com_src_name": "bash", "com_src_version": "5.0", "com_database": "os_version_1"}, {"component": "ld-linux-aarch64.so.1()(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "os_version_1"}, {"component": "ld-linux-aarch64.so.1(GLIBC_2.17)(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "os_version_1"}, {"component": "rtld(GNU_HASH)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "os_version_1"}, {"component": "libc.so.6(GLIBC_2.17)(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "os_version_1"}]}] +\ No newline at end of file + +--- a/test/test_module/test_install/data/wrong_install_info.json ++++ b/test/test_module/test_install/data/wrong_install_info.json +@@ -1 +1 @@ +-[{"binary_name": "Judy", "bin_version": "1.0.5", "database": "openeuler", "src_name": "Judy", "src_version": "1.0.5", "requires": [{"component": "/bin/sh", "com_bin_name": "bash", "com_bin_version": "5.0", "com_src_name": "bash", "com_src_version": "5.0", "com_database": "openeuler"}, {"component": "/bin/sh", "com_bin_name": "bash", "com_bin_version": "5.0", "com_src_name": "bash", "com_src_version": "5.0", "com_database": "openeuler"}, {"component": "ld-linux-aarch64.so.1()(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "openeuler"}, {"component": "ld-linux-aarch64.so.1(GLIBC_2.17)(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "openeuler"}, {"component": "rtld(GNU_HASH)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "openeuler"}, {"component": "libc.so.6(GLIBC_2.17)(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "openeuler"}]},{}] +\ No newline at end of file ++[{"binary_name": "Judy", "bin_version": "1.0.5", "database": "os_version_1", "src_name": "Judy", "src_version": "1.0.5", "requires": [{"component": "/bin/sh", "com_bin_name": "bash", "com_bin_version": "5.0", "com_src_name": "bash", "com_src_version": "5.0", "com_database": "os_version_1"}, {"component": "/bin/sh", "com_bin_name": "bash", "com_bin_version": "5.0", "com_src_name": "bash", "com_src_version": "5.0", "com_database": "os_version_1"}, {"component": "ld-linux-aarch64.so.1()(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "os_version_1"}, {"component": "ld-linux-aarch64.so.1(GLIBC_2.17)(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "os_version_1"}, {"component": "rtld(GNU_HASH)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "os_version_1"}, {"component": "libc.so.6(GLIBC_2.17)(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "os_version_1"}]},{}] +\ No newline at end of file + +--- a/test/test_module/test_install/test_get_install_depend.py ++++ b/test/test_module/test_install/test_get_install_depend.py +@@ -40,7 +40,7 @@ param = { + "packagename": ["Judy"], + "depend_type": "installdep", + "parameter": { +- "db_priority": ["openeuler"], ++ "db_priority": ["os_version_1"], + "level": 2 + } + } +@@ -58,7 +58,7 @@ class TestInstallDdepend(unittest.TestCase): + + """ + mock1.return_value = [] +- install = InstallDepend(db_list=['openeuler']) ++ install = InstallDepend(db_list=['os_version_1']) + install.install_depend(bin_name=["Judy111"]) + binary, source = install.depend_dict + self.assertEqual(binary, {}, "Error in testing package not exists.") +@@ -71,7 +71,7 @@ class TestInstallDdepend(unittest.TestCase): + + """ + mock1.return_value = EMPTY_REQUIRES +- install = InstallDepend(db_list=['openeuler']) ++ install = InstallDepend(db_list=['os_version_1']) + install.install_depend(bin_name=["Judy"]) + binary, source = install.depend_dict + self.assertDictEqual(binary, REQUIRE_EXPECT_BIN, "Error in testing empty requires.") +@@ -84,7 +84,7 @@ class TestInstallDdepend(unittest.TestCase): + + """ + mock1.return_value = WRONG_INSTALL_INFO +- install = InstallDepend(db_list=['openeuler']) ++ install = InstallDepend(db_list=['os_version_1']) + install.install_depend(bin_name=["Judy", "Judy1111"]) + binary, source = install.depend_dict + binary["Judy"]["install"] = sorted(binary["Judy"]["install"]) +@@ -98,7 +98,7 @@ class TestInstallDdepend(unittest.TestCase): + + """ + mock1.return_value = TRUE_INSTALL_INFO +- install = InstallDepend(db_list=['openeuler']) ++ install = InstallDepend(db_list=['os_version_1']) + install.install_depend(bin_name=["Judy"], level=1) + binary, source = install.depend_dict + binary["Judy"]["install"] = sorted(binary["Judy"]["install"]) +@@ -121,7 +121,7 @@ class TestInstallDdepend(unittest.TestCase): + + """ + with self.assertRaises(AttributeError): +- install = InstallDepend(db_list=['openeuler']) ++ install = InstallDepend(db_list=['os_version_1']) + install.install_depend(bin_name="Judy") + + @mock.patch.object(Redis, "exists") +@@ -137,7 +137,7 @@ class TestInstallDdepend(unittest.TestCase): + False + ] + InstallRequires.get_install_req = mock.Mock(return_value=TRUE_INSTALL_INFO) +- install = InstallDepend(db_list=['openeuler']) ++ install = InstallDepend(db_list=['os_version_1']) + install(**param) + binary, source = install.depend_dict + binary["Judy"]["install"] = sorted(binary["Judy"]["install"]) +@@ -151,7 +151,7 @@ class TestInstallDdepend(unittest.TestCase): + + """ + mock1.return_value = TRUE_INSTALL_INFO +- install = InstallDepend(db_list=['openeuler']) ++ install = InstallDepend(db_list=['os_version_1']) + install.install_depend(bin_name=["Judy"]) + binary, source = install.depend_dict + binary["Judy"]["install"] = sorted(binary["Judy"]["install"]) + +--- a/test/test_module/test_packages/test_all_bin_package/test_get_all_bin_package.py ++++ b/test/test_module/test_packages/test_all_bin_package/test_get_all_bin_package.py +@@ -35,7 +35,7 @@ class TestAllBinPackage(unittest.TestCase): + + def setUp(self) -> None: + database.get_db_priority = mock.Mock( +- return_value=["openeuler", "fedora"]) ++ return_value=["os_version_1", "os_version_2"]) + + @patch.object(QueryPackage, "get_bin_info") + def test_get_empty_bin_info(self, mock1): +@@ -77,7 +77,7 @@ class TestAllBinPackage(unittest.TestCase): + + """ + mock1.return_value = {"total": 2} +- res = pkg.all_bin_packages("openeuler", page_num=1, page_size=20) ++ res = pkg.all_bin_packages("os_version_1", page_num=1, page_size=20) + self.assertEqual(res, {}, "Error in testing wrong bin info.") + + @patch.object(QueryPackage, "get_bin_info") +@@ -89,5 +89,5 @@ class TestAllBinPackage(unittest.TestCase): + """ + ALL_BIN_INFO = MockData.read_mock_json_data(os.path.join(MOCK_DATA_FILE, "all_bin_package_info.json")) + mock1.return_value = ALL_BIN_INFO +- res = pkg.all_bin_packages("openeuler", page_num=1, page_size=20) ++ res = pkg.all_bin_packages("os_version_1", page_num=1, page_size=20) + self.assertNotEqual(res, {}, "Error in testing true response.") + +--- a/test/test_module/test_packages/test_all_src_package/test_get_all_src_package.py ++++ b/test/test_module/test_packages/test_all_src_package/test_get_all_src_package.py +@@ -36,7 +36,7 @@ class TestAllSrcPackage(unittest.TestCase): + + def setUp(self) -> None: + database.get_db_priority = mock.Mock( +- return_value=["openeuler", "fedora"]) ++ return_value=["os_version_1", "os_version_2"]) + + @patch.object(QueryPackage, "get_src_info") + def test_get_empty_src_info(self, mock1): +@@ -78,7 +78,7 @@ class TestAllSrcPackage(unittest.TestCase): + + """ + mock1.return_value = {"total": 2} +- res = pkg.all_src_packages("openeuler", page_num=1, page_size=20) ++ res = pkg.all_src_packages("os_version_1", page_num=1, page_size=20) + self.assertEqual(res, {}, "Error in testing wrong src info.") + + @patch.object(QueryPackage, "get_src_info") +@@ -90,5 +90,5 @@ class TestAllSrcPackage(unittest.TestCase): + """ + ALL_SRC_INFO = MockData.read_mock_json_data(os.path.join(MOCK_DATA_FILE, "all_src_package_info.json")) + mock1.return_value = ALL_SRC_INFO +- res = pkg.all_src_packages("openeuler", page_num=1, page_size=20) ++ res = pkg.all_src_packages("os_version_1", page_num=1, page_size=20) + self.assertNotEqual(res, {}, "Error in testing true result.") + +--- a/test/test_module/test_packages/test_single_package_info/data/build_requires_info.json ++++ b/test/test_module/test_packages/test_single_package_info/data/build_requires_info.json +@@ -1,2 +1,2 @@ +-[{"source_name": "Judy", "src_version": "1.0.5", "database": "openeuler", +- "requires": [{"component": "coreutils", "com_bin_name": "coreutils", "com_bin_version": "8.32", "com_src_name": "coreutils", "com_src_version": "8.32", "com_database": "openeuler"}, {"component": "gawk", "com_bin_name": "gawk", "com_bin_version": "5.1.0", "com_src_name": "gawk", "com_src_version": "5.1.0", "com_database": "openeuler"}, {"component": "gcc", "com_bin_name": "gcc", "com_bin_version": "9.3.1", "com_src_name": "gcc", "com_src_version": "9.3.1", "com_database": "openeuler"}, {"component": "make", "com_bin_name": "make", "com_bin_version": "4.3", "com_src_name": "make", "com_src_version": "4.3", "com_database": "openeuler"}, {"component": "sed", "com_bin_name": "sed", "com_bin_version": "4.8", "com_src_name": "sed", "com_src_version": "4.8", "com_database": "openeuler"}]}] +\ No newline at end of file ++[{"source_name": "Judy", "src_version": "1.0.5", "database": "os_version_1", ++ "requires": [{"component": "coreutils", "com_bin_name": "coreutils", "com_bin_version": "8.32", "com_src_name": "coreutils", "com_src_version": "8.32", "com_database": "os_version_1"}, {"component": "gawk", "com_bin_name": "gawk", "com_bin_version": "5.1.0", "com_src_name": "gawk", "com_src_version": "5.1.0", "com_database": "os_version_1"}, {"component": "gcc", "com_bin_name": "gcc", "com_bin_version": "9.3.1", "com_src_name": "gcc", "com_src_version": "9.3.1", "com_database": "os_version_1"}, {"component": "make", "com_bin_name": "make", "com_bin_version": "4.3", "com_src_name": "make", "com_src_version": "4.3", "com_database": "os_version_1"}, {"component": "sed", "com_bin_name": "sed", "com_bin_version": "4.8", "com_src_name": "sed", "com_src_version": "4.8", "com_database": "os_version_1"}]}] +\ No newline at end of file + +--- a/test/test_module/test_packages/test_single_package_info/data/empty_filelist_for_res.json ++++ b/test/test_module/test_packages/test_single_package_info/data/empty_filelist_for_res.json +@@ -1 +1 @@ +-{"openeuler": [{"bin_name": "Judy", "version": "1.0.5", "url": "http://sourceforge.net/projects/judy/", "license": "LGPLv2+", "release": "19.oe1", "summary": "C library array", "description": "The package provides the most advanced core technology, the main\nadvantages are scalability, high performance and memory efficiency.", "src_name": "Judy", "provides": [{"component": "Judy", "required_by_bin": ["Judy-devel"], "required_by_src": ["T"]}, {"component": "Judy(aarch-64)", "required_by_bin": [], "required_by_src": []}, {"component": "libJudy.so.1()(64bit)", "required_by_bin": ["mariadb-oqgraph-engine"], "required_by_src": []}], "requires": [{"component": "/bin/sh", "provided_by": ["bash"]}, {"component": "ld-linux-aarch64.so.1()(64bit)", "provided_by": ["glibc"]}, {"component": "ld-linux-aarch64.so.1(GLIBC_2.17)(64bit)", "provided_by": ["glibc"]}, {"component": "rtld(GNU_HASH)", "provided_by": ["glibc"]}, {"component": "libc.so.6(GLIBC_2.17)(64bit)", "provided_by": ["glibc"]}], "filelist": {}}]} +\ No newline at end of file ++{"os_version_1": [{"bin_name": "Judy", "version": "1.0.5", "url": "http://sourceforge.net/projects/judy/", "license": "LGPLv2+", "release": "19.oe1", "summary": "C library array", "description": "The package provides the most advanced core technology, the main\nadvantages are scalability, high performance and memory efficiency.", "src_name": "Judy", "provides": [{"component": "Judy", "required_by_bin": ["Judy-devel"], "required_by_src": ["T"]}, {"component": "Judy(aarch-64)", "required_by_bin": [], "required_by_src": []}, {"component": "libJudy.so.1()(64bit)", "required_by_bin": ["mariadb-oqgraph-engine"], "required_by_src": []}], "requires": [{"component": "/bin/sh", "provided_by": ["bash"]}, {"component": "ld-linux-aarch64.so.1()(64bit)", "provided_by": ["glibc"]}, {"component": "ld-linux-aarch64.so.1(GLIBC_2.17)(64bit)", "provided_by": ["glibc"]}, {"component": "rtld(GNU_HASH)", "provided_by": ["glibc"]}, {"component": "libc.so.6(GLIBC_2.17)(64bit)", "provided_by": ["glibc"]}], "filelist": {}}]} +\ No newline at end of file + +--- a/test/test_module/test_packages/test_single_package_info/data/empty_filelist_info.json ++++ b/test/test_module/test_packages/test_single_package_info/data/empty_filelist_info.json +@@ -1 +1 @@ +-{"openeuler": [{"bin_name": "Judy", "version": "1.0.5", "url": "http://sourceforge.net/projects/judy/", "license": "LGPLv2+", "release": "19.oe1", "summary": "C library array", "description": "The package provides the most advanced core technology, the main\nadvantages are scalability, high performance and memory efficiency.", "src_name": "Judy", "provides": [{"component": "Judy", "required_by_bin": ["Judy-devel"], "required_by_src": ["T"]}, {"component": "Judy(aarch-64)", "required_by_bin": [], "required_by_src": []}, {"component": "libJudy.so.1()(64bit)", "required_by_bin": ["mariadb-oqgraph-engine"], "required_by_src": []}], "requires": [{"component": "/bin/sh", "provided_by": ["bash"]}, {"component": "ld-linux-aarch64.so.1()(64bit)", "provided_by": ["glibc"]}, {"component": "ld-linux-aarch64.so.1(GLIBC_2.17)(64bit)", "provided_by": ["glibc"]}, {"component": "rtld(GNU_HASH)", "provided_by": ["glibc"]}, {"component": "libc.so.6(GLIBC_2.17)(64bit)", "provided_by": ["glibc"]}], "filelist": {}}]} +\ No newline at end of file ++{"os_version_1": [{"bin_name": "Judy", "version": "1.0.5", "url": "http://sourceforge.net/projects/judy/", "license": "LGPLv2+", "release": "19.oe1", "summary": "C library array", "description": "The package provides the most advanced core technology, the main\nadvantages are scalability, high performance and memory efficiency.", "src_name": "Judy", "provides": [{"component": "Judy", "required_by_bin": ["Judy-devel"], "required_by_src": ["T"]}, {"component": "Judy(aarch-64)", "required_by_bin": [], "required_by_src": []}, {"component": "libJudy.so.1()(64bit)", "required_by_bin": ["mariadb-oqgraph-engine"], "required_by_src": []}], "requires": [{"component": "/bin/sh", "provided_by": ["bash"]}, {"component": "ld-linux-aarch64.so.1()(64bit)", "provided_by": ["glibc"]}, {"component": "ld-linux-aarch64.so.1(GLIBC_2.17)(64bit)", "provided_by": ["glibc"]}, {"component": "rtld(GNU_HASH)", "provided_by": ["glibc"]}, {"component": "libc.so.6(GLIBC_2.17)(64bit)", "provided_by": ["glibc"]}], "filelist": {}}]} +\ No newline at end of file + +--- a/test/test_module/test_packages/test_single_package_info/data/empty_install_for_res.json ++++ b/test/test_module/test_packages/test_single_package_info/data/empty_install_for_res.json +@@ -1 +1 @@ +-{"openeuler": [{"src_name": "Judy1", "license": "LGPLv2+", "version": "1.0.5", "url": "http://sourceforge.net/projects/judy/", "summary": "C library array", "description": "The package provides the most advanced core technology, the main\nadvantages are scalability, high performance and memory efficiency.", "build_dep": ["coreutils", "gawk", "gcc", "make", "sed"], "subpacks": [{"bin_name": "Judy", "provides": [{"component": "Judy", "required_by_bin": ["Judy-devel"], "required_by_src": ["T"]}, {"component": "Judy(aarch-64)", "required_by_bin": [], "required_by_src": []}, {"component": "libJudy.so.1()(64bit)", "required_by_bin": ["mariadb-oqgraph-engine"], "required_by_src": []}], "requires": []}]}]} +\ No newline at end of file ++{"os_version_1": [{"src_name": "Judy1", "license": "LGPLv2+", "version": "1.0.5", "url": "http://sourceforge.net/projects/judy/", "summary": "C library array", "description": "The package provides the most advanced core technology, the main\nadvantages are scalability, high performance and memory efficiency.", "build_dep": ["coreutils", "gawk", "gcc", "make", "sed"], "subpacks": [{"bin_name": "Judy", "provides": [{"component": "Judy", "required_by_bin": ["Judy-devel"], "required_by_src": ["T"]}, {"component": "Judy(aarch-64)", "required_by_bin": [], "required_by_src": []}, {"component": "libJudy.so.1()(64bit)", "required_by_bin": ["mariadb-oqgraph-engine"], "required_by_src": []}], "requires": []}]}]} +\ No newline at end of file + +--- a/test/test_module/test_packages/test_single_package_info/data/true_bin_for_res.json ++++ b/test/test_module/test_packages/test_single_package_info/data/true_bin_for_res.json +@@ -1 +1 @@ +-{"openeuler": [{"bin_name": "Judy", "version": "1.0.5", "url": "http://sourceforge.net/projects/judy/", "license": "LGPLv2+", "release": "19.oe1", "summary": "C library array", "description": "The package provides the most advanced core technology, the main\nadvantages are scalability, high performance and memory efficiency.", "src_name": "Judy", "provides": [{"component": "Judy", "required_by_bin": ["Judy-devel"], "required_by_src": ["T"]}, {"component": "Judy(aarch-64)", "required_by_bin": [], "required_by_src": []}, {"component": "libJudy.so.1()(64bit)", "required_by_bin": ["mariadb-oqgraph-engine"], "required_by_src": []}], "requires": [{"component": "/bin/sh", "provided_by": ["bash"]}, {"component": "ld-linux-aarch64.so.1()(64bit)", "provided_by": ["glibc"]}, {"component": "ld-linux-aarch64.so.1(GLIBC_2.17)(64bit)", "provided_by": ["glibc"]}, {"component": "rtld(GNU_HASH)", "provided_by": ["glibc"]}, {"component": "libc.so.6(GLIBC_2.17)(64bit)", "provided_by": ["glibc"]}], "filelist": {"dir": ["/usr/share/licenses/Judy"], "file": ["/usr/share/licenses/Judy/COPYING", "/etc/ima/digest_lists.tlv/0-metadata_list-compact_tlv-Judy-1.0.5-19.oe1.aarch64", "/usr/lib64/libJudy.so.1", "/usr/lib64/libJudy.so.1.0.3"], "ghost": ["/etc/ima/digest_lists/0-metadata_list-compact-Judy-1.0.5-19.oe1.aarch64"]}}], "fedora": [{"bin_name": "Judy", "version": "1.0.5", "url": "http://sourceforge.net/projects/judy/", "license": "LGPLv2+", "release": "19.oe1", "summary": "C library array", "description": "The package provides the most advanced core technology, the main\nadvantages are scalability, high performance and memory efficiency.", "src_name": "Judy", "provides": [{"component": "Judy", "required_by_bin": ["Judy-devel"], "required_by_src": ["T"]}, {"component": "Judy(aarch-64)", "required_by_bin": [], "required_by_src": []}, {"component": "libJudy.so.1()(64bit)", "required_by_bin": ["mariadb-oqgraph-engine"], "required_by_src": []}], "requires": [{"component": "/bin/sh", "provided_by": ["bash"]}, {"component": "ld-linux-aarch64.so.1()(64bit)", "provided_by": ["glibc"]}, {"component": "ld-linux-aarch64.so.1(GLIBC_2.17)(64bit)", "provided_by": ["glibc"]}, {"component": "rtld(GNU_HASH)", "provided_by": ["glibc"]}, {"component": "libc.so.6(GLIBC_2.17)(64bit)", "provided_by": ["glibc"]}], "filelist": {"dir": ["/usr/share/licenses/Judy"], "file": ["/usr/share/licenses/Judy/COPYING", "/etc/ima/digest_lists.tlv/0-metadata_list-compact_tlv-Judy-1.0.5-19.oe1.aarch64", "/usr/lib64/libJudy.so.1", "/usr/lib64/libJudy.so.1.0.3"], "ghost": ["/etc/ima/digest_lists/0-metadata_list-compact-Judy-1.0.5-19.oe1.aarch64"]}}]} +\ No newline at end of file ++{"os_version_1": [{"bin_name": "Judy", "version": "1.0.5", "url": "http://sourceforge.net/projects/judy/", "license": "LGPLv2+", "release": "19.oe1", "summary": "C library array", "description": "The package provides the most advanced core technology, the main\nadvantages are scalability, high performance and memory efficiency.", "src_name": "Judy", "provides": [{"component": "Judy", "required_by_bin": ["Judy-devel"], "required_by_src": ["T"]}, {"component": "Judy(aarch-64)", "required_by_bin": [], "required_by_src": []}, {"component": "libJudy.so.1()(64bit)", "required_by_bin": ["mariadb-oqgraph-engine"], "required_by_src": []}], "requires": [{"component": "/bin/sh", "provided_by": ["bash"]}, {"component": "ld-linux-aarch64.so.1()(64bit)", "provided_by": ["glibc"]}, {"component": "ld-linux-aarch64.so.1(GLIBC_2.17)(64bit)", "provided_by": ["glibc"]}, {"component": "rtld(GNU_HASH)", "provided_by": ["glibc"]}, {"component": "libc.so.6(GLIBC_2.17)(64bit)", "provided_by": ["glibc"]}], "filelist": {"dir": ["/usr/share/licenses/Judy"], "file": ["/usr/share/licenses/Judy/COPYING", "/etc/ima/digest_lists.tlv/0-metadata_list-compact_tlv-Judy-1.0.5-19.oe1.aarch64", "/usr/lib64/libJudy.so.1", "/usr/lib64/libJudy.so.1.0.3"], "ghost": ["/etc/ima/digest_lists/0-metadata_list-compact-Judy-1.0.5-19.oe1.aarch64"]}}], "os_version_2": [{"bin_name": "Judy", "version": "1.0.5", "url": "http://sourceforge.net/projects/judy/", "license": "LGPLv2+", "release": "19.oe1", "summary": "C library array", "description": "The package provides the most advanced core technology, the main\nadvantages are scalability, high performance and memory efficiency.", "src_name": "Judy", "provides": [{"component": "Judy", "required_by_bin": ["Judy-devel"], "required_by_src": ["T"]}, {"component": "Judy(aarch-64)", "required_by_bin": [], "required_by_src": []}, {"component": "libJudy.so.1()(64bit)", "required_by_bin": ["mariadb-oqgraph-engine"], "required_by_src": []}], "requires": [{"component": "/bin/sh", "provided_by": ["bash"]}, {"component": "ld-linux-aarch64.so.1()(64bit)", "provided_by": ["glibc"]}, {"component": "ld-linux-aarch64.so.1(GLIBC_2.17)(64bit)", "provided_by": ["glibc"]}, {"component": "rtld(GNU_HASH)", "provided_by": ["glibc"]}, {"component": "libc.so.6(GLIBC_2.17)(64bit)", "provided_by": ["glibc"]}], "filelist": {"dir": ["/usr/share/licenses/Judy"], "file": ["/usr/share/licenses/Judy/COPYING", "/etc/ima/digest_lists.tlv/0-metadata_list-compact_tlv-Judy-1.0.5-19.oe1.aarch64", "/usr/lib64/libJudy.so.1", "/usr/lib64/libJudy.so.1.0.3"], "ghost": ["/etc/ima/digest_lists/0-metadata_list-compact-Judy-1.0.5-19.oe1.aarch64"]}}]} +\ No newline at end of file + +--- a/test/test_module/test_packages/test_single_package_info/data/true_install_for_res.json ++++ b/test/test_module/test_packages/test_single_package_info/data/true_install_for_res.json +@@ -1 +1 @@ +-{"openeuler": [{"src_name": "Judy1", "license": "LGPLv2+", "version": "1.0.5", "url": "http://sourceforge.net/projects/judy/", "summary": "C library array", "description": "The package provides the most advanced core technology, the main\nadvantages are scalability, high performance and memory efficiency.", "build_dep": ["coreutils", "gawk", "gcc", "make", "sed"], "subpacks": [{"bin_name": "Judy", "provides": [{"component": "Judy", "required_by_bin": ["Judy-devel"], "required_by_src": ["T"]}, {"component": "Judy(aarch-64)", "required_by_bin": [], "required_by_src": []}, {"component": "libJudy.so.1()(64bit)", "required_by_bin": ["mariadb-oqgraph-engine"], "required_by_src": []}], "requires": [{"component": "/bin/sh", "provided_by": ["bash"]}, {"component": "ld-linux-aarch64.so.1()(64bit)", "provided_by": ["glibc"]}, {"component": "ld-linux-aarch64.so.1(GLIBC_2.17)(64bit)", "provided_by": ["glibc"]}, {"component": "rtld(GNU_HASH)", "provided_by": ["glibc"]}, {"component": "libc.so.6(GLIBC_2.17)(64bit)", "provided_by": ["glibc"]}]}]}]} +\ No newline at end of file ++{"os_version_1": [{"src_name": "Judy1", "license": "LGPLv2+", "version": "1.0.5", "url": "http://sourceforge.net/projects/judy/", "summary": "C library array", "description": "The package provides the most advanced core technology, the main\nadvantages are scalability, high performance and memory efficiency.", "build_dep": ["coreutils", "gawk", "gcc", "make", "sed"], "subpacks": [{"bin_name": "Judy", "provides": [{"component": "Judy", "required_by_bin": ["Judy-devel"], "required_by_src": ["T"]}, {"component": "Judy(aarch-64)", "required_by_bin": [], "required_by_src": []}, {"component": "libJudy.so.1()(64bit)", "required_by_bin": ["mariadb-oqgraph-engine"], "required_by_src": []}], "requires": [{"component": "/bin/sh", "provided_by": ["bash"]}, {"component": "ld-linux-aarch64.so.1()(64bit)", "provided_by": ["glibc"]}, {"component": "ld-linux-aarch64.so.1(GLIBC_2.17)(64bit)", "provided_by": ["glibc"]}, {"component": "rtld(GNU_HASH)", "provided_by": ["glibc"]}, {"component": "libc.so.6(GLIBC_2.17)(64bit)", "provided_by": ["glibc"]}]}]}]} +\ No newline at end of file + +--- a/test/test_module/test_packages/test_single_package_info/data/true_install_info.json ++++ b/test/test_module/test_packages/test_single_package_info/data/true_install_info.json +@@ -1 +1 @@ +-[{"binary_name": "Judy", "bin_version": "1.0.5", "database": "openeuler", "src_name": "Judy", "src_version": "1.0.5", "requires": [{"component": "/bin/sh", "com_bin_name": "bash", "com_bin_version": "5.0", "com_src_name": "bash", "com_src_version": "5.0", "com_database": "openeuler"}, {"component": "/bin/sh", "com_bin_name": "bash", "com_bin_version": "5.0", "com_src_name": "bash", "com_src_version": "5.0", "com_database": "openeuler"}, {"component": "ld-linux-aarch64.so.1()(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "openeuler"}, {"component": "ld-linux-aarch64.so.1(GLIBC_2.17)(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "openeuler"}, {"component": "rtld(GNU_HASH)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "openeuler"}, {"component": "libc.so.6(GLIBC_2.17)(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "openeuler"}]}] +\ No newline at end of file ++[{"binary_name": "Judy", "bin_version": "1.0.5", "database": "os_version_1", "src_name": "Judy", "src_version": "1.0.5", "requires": [{"component": "/bin/sh", "com_bin_name": "bash", "com_bin_version": "5.0", "com_src_name": "bash", "com_src_version": "5.0", "com_database": "os_version_1"}, {"component": "/bin/sh", "com_bin_name": "bash", "com_bin_version": "5.0", "com_src_name": "bash", "com_src_version": "5.0", "com_database": "os_version_1"}, {"component": "ld-linux-aarch64.so.1()(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "os_version_1"}, {"component": "ld-linux-aarch64.so.1(GLIBC_2.17)(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "os_version_1"}, {"component": "rtld(GNU_HASH)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "os_version_1"}, {"component": "libc.so.6(GLIBC_2.17)(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "os_version_1"}]}] +\ No newline at end of file + +--- a/test/test_module/test_packages/test_single_package_info/data/true_result_with_default_database.json ++++ b/test/test_module/test_packages/test_single_package_info/data/true_result_with_default_database.json +@@ -1 +1 @@ +-{"openeuler": [{"src_name": "Judy1", "license": "LGPLv2+", "version": "1.0.5", "url": "http://sourceforge.net/projects/judy/", "release": "19.oe1", "summary": "C library array", "description": "The package provides the most advanced core technology, the main\nadvantages are scalability, high performance and memory efficiency.", "buildrequired": ["coreutils", "gawk", "gcc", "make", "sed"], "subpacks": [{"bin_name": "Judy", "provides": [{"component": "Judy", "required_by_bin": ["Judy-devel"], "required_by_src": ["T"]}, {"component": "Judy(aarch-64)", "required_by_bin": [], "required_by_src": []}, {"component": "libJudy.so.1()(64bit)", "required_by_bin": ["mariadb-oqgraph-engine"], "required_by_src": []}], "requires": [{"component": "/bin/sh", "provided_by": ["bash"]}, {"component": "ld-linux-aarch64.so.1()(64bit)", "provided_by": ["glibc"]}, {"component": "ld-linux-aarch64.so.1(GLIBC_2.17)(64bit)", "provided_by": ["glibc"]}, {"component": "rtld(GNU_HASH)", "provided_by": ["glibc"]}, {"component": "libc.so.6(GLIBC_2.17)(64bit)", "provided_by": ["glibc"]}]}]}], "fedora": [{"src_name": "Judy1", "license": "LGPLv2+", "version": "1.0.5", "url": "http://sourceforge.net/projects/judy/", "release": "19.oe1", "summary": "C library array", "description": "The package provides the most advanced core technology, the main\nadvantages are scalability, high performance and memory efficiency.", "buildrequired": [], "subpacks": [{"bin_name": "Judy", "provides": [], "requires": []}]}]} +\ No newline at end of file ++{"os_version_1": [{"src_name": "Judy1", "license": "LGPLv2+", "version": "1.0.5", "url": "http://sourceforge.net/projects/judy/", "release": "19.oe1", "summary": "C library array", "description": "The package provides the most advanced core technology, the main\nadvantages are scalability, high performance and memory efficiency.", "buildrequired": ["coreutils", "gawk", "gcc", "make", "sed"], "subpacks": [{"bin_name": "Judy", "provides": [{"component": "Judy", "required_by_bin": ["Judy-devel"], "required_by_src": ["T"]}, {"component": "Judy(aarch-64)", "required_by_bin": [], "required_by_src": []}, {"component": "libJudy.so.1()(64bit)", "required_by_bin": ["mariadb-oqgraph-engine"], "required_by_src": []}], "requires": [{"component": "/bin/sh", "provided_by": ["bash"]}, {"component": "ld-linux-aarch64.so.1()(64bit)", "provided_by": ["glibc"]}, {"component": "ld-linux-aarch64.so.1(GLIBC_2.17)(64bit)", "provided_by": ["glibc"]}, {"component": "rtld(GNU_HASH)", "provided_by": ["glibc"]}, {"component": "libc.so.6(GLIBC_2.17)(64bit)", "provided_by": ["glibc"]}]}]}], "os_version_2": [{"src_name": "Judy1", "license": "LGPLv2+", "version": "1.0.5", "url": "http://sourceforge.net/projects/judy/", "release": "19.oe1", "summary": "C library array", "description": "The package provides the most advanced core technology, the main\nadvantages are scalability, high performance and memory efficiency.", "buildrequired": [], "subpacks": [{"bin_name": "Judy", "provides": [], "requires": []}]}]} +\ No newline at end of file + +--- a/test/test_module/test_packages/test_single_package_info/data/true_result_with_input_database.json ++++ b/test/test_module/test_packages/test_single_package_info/data/true_result_with_input_database.json +@@ -1 +1 @@ +-{"openeuler": [{"src_name": "Judy1", "license": "LGPLv2+", "version": "1.0.5", "url": "http://sourceforge.net/projects/judy/", "summary": "C library array", "description": "The package provides the most advanced core technology, the main\nadvantages are scalability, high performance and memory efficiency.", "build_dep": ["coreutils", "gawk", "gcc", "make", "sed"], "subpacks": [{"bin_name": "Judy", "provides": [{"component": "Judy", "required_by_bin": ["Judy-devel"], "required_by_src": ["T"]}, {"component": "Judy(aarch-64)", "required_by_bin": [], "required_by_src": []}, {"component": "libJudy.so.1()(64bit)", "required_by_bin": ["mariadb-oqgraph-engine"], "required_by_src": []}], "requires": [{"component": "/bin/sh", "provided_by": ["bash"]}, {"component": "ld-linux-aarch64.so.1()(64bit)", "provided_by": ["glibc"]}, {"component": "ld-linux-aarch64.so.1(GLIBC_2.17)(64bit)", "provided_by": ["glibc"]}, {"component": "rtld(GNU_HASH)", "provided_by": ["glibc"]}, {"component": "libc.so.6(GLIBC_2.17)(64bit)", "provided_by": ["glibc"]}]}]}]} ++{"os_version_1": [{"src_name": "Judy1", "license": "LGPLv2+", "version": "1.0.5", "url": "http://sourceforge.net/projects/judy/", "summary": "C library array", "description": "The package provides the most advanced core technology, the main\nadvantages are scalability, high performance and memory efficiency.", "build_dep": ["coreutils", "gawk", "gcc", "make", "sed"], "subpacks": [{"bin_name": "Judy", "provides": [{"component": "Judy", "required_by_bin": ["Judy-devel"], "required_by_src": ["T"]}, {"component": "Judy(aarch-64)", "required_by_bin": [], "required_by_src": []}, {"component": "libJudy.so.1()(64bit)", "required_by_bin": ["mariadb-oqgraph-engine"], "required_by_src": []}], "requires": [{"component": "/bin/sh", "provided_by": ["bash"]}, {"component": "ld-linux-aarch64.so.1()(64bit)", "provided_by": ["glibc"]}, {"component": "ld-linux-aarch64.so.1(GLIBC_2.17)(64bit)", "provided_by": ["glibc"]}, {"component": "rtld(GNU_HASH)", "provided_by": ["glibc"]}, {"component": "libc.so.6(GLIBC_2.17)(64bit)", "provided_by": ["glibc"]}]}]}]} + +--- a/test/test_module/test_packages/test_single_package_info/data/wrong_build_for_res.json ++++ b/test/test_module/test_packages/test_single_package_info/data/wrong_build_for_res.json +@@ -1 +1 @@ +-{"openeuler": [{"src_name": "Judy1", "license": "LGPLv2+", "version": "1.0.5", "url": "http://sourceforge.net/projects/judy/", "summary": "C library array", "description": "The package provides the most advanced core technology, the main\nadvantages are scalability, high performance and memory efficiency.", "build_dep": [], "subpacks": [{"bin_name": "Judy", "provides": [{"component": "Judy", "required_by_bin": ["Judy-devel"], "required_by_src": ["T"]}, {"component": "Judy(aarch-64)", "required_by_bin": [], "required_by_src": []}, {"component": "libJudy.so.1()(64bit)", "required_by_bin": ["mariadb-oqgraph-engine"], "required_by_src": []}], "requires": [{"component": "/bin/sh", "provided_by": ["bash"]}, {"component": "ld-linux-aarch64.so.1()(64bit)", "provided_by": ["glibc"]}, {"component": "ld-linux-aarch64.so.1(GLIBC_2.17)(64bit)", "provided_by": ["glibc"]}, {"component": "rtld(GNU_HASH)", "provided_by": ["glibc"]}, {"component": "libc.so.6(GLIBC_2.17)(64bit)", "provided_by": ["glibc"]}]}]}]} +\ No newline at end of file ++{"os_version_1": [{"src_name": "Judy1", "license": "LGPLv2+", "version": "1.0.5", "url": "http://sourceforge.net/projects/judy/", "summary": "C library array", "description": "The package provides the most advanced core technology, the main\nadvantages are scalability, high performance and memory efficiency.", "build_dep": [], "subpacks": [{"bin_name": "Judy", "provides": [{"component": "Judy", "required_by_bin": ["Judy-devel"], "required_by_src": ["T"]}, {"component": "Judy(aarch-64)", "required_by_bin": [], "required_by_src": []}, {"component": "libJudy.so.1()(64bit)", "required_by_bin": ["mariadb-oqgraph-engine"], "required_by_src": []}], "requires": [{"component": "/bin/sh", "provided_by": ["bash"]}, {"component": "ld-linux-aarch64.so.1()(64bit)", "provided_by": ["glibc"]}, {"component": "ld-linux-aarch64.so.1(GLIBC_2.17)(64bit)", "provided_by": ["glibc"]}, {"component": "rtld(GNU_HASH)", "provided_by": ["glibc"]}, {"component": "libc.so.6(GLIBC_2.17)(64bit)", "provided_by": ["glibc"]}]}]}]} +\ No newline at end of file + +--- a/test/test_module/test_packages/test_single_package_info/data/wrong_build_info.json ++++ b/test/test_module/test_packages/test_single_package_info/data/wrong_build_info.json +@@ -1,2 +1,2 @@ +-[{"source_name": "Judy", "src_version": "1.0.5", "database": "openeuler", ++[{"source_name": "Judy", "src_version": "1.0.5", "database": "os_version_1", + "requires": null}] +\ No newline at end of file + +--- a/test/test_module/test_packages/test_single_package_info/data/wrong_depend_for_res.json ++++ b/test/test_module/test_packages/test_single_package_info/data/wrong_depend_for_res.json +@@ -1 +1 @@ +-{"openeuler": [{"src_name": "Judy1", "license": "LGPLv2+", "version": "1.0.5", "url": "http://sourceforge.net/projects/judy/", "summary": "C library array", "description": "The package provides the most advanced core technology, the main\nadvantages are scalability, high performance and memory efficiency.", "build_dep": ["coreutils", "gawk", "gcc", "make", "sed"], "subpacks": [{"bin_name": "Judy", "provides": [], "requires": [{"component": "/bin/sh", "provided_by": ["bash"]}, {"component": "ld-linux-aarch64.so.1()(64bit)", "provided_by": ["glibc"]}, {"component": "ld-linux-aarch64.so.1(GLIBC_2.17)(64bit)", "provided_by": ["glibc"]}, {"component": "rtld(GNU_HASH)", "provided_by": ["glibc"]}, {"component": "libc.so.6(GLIBC_2.17)(64bit)", "provided_by": ["glibc"]}]}]}], "fedora": [{"src_name": "Judy1", "license": "LGPLv2+", "version": "1.0.5", "url": "http://sourceforge.net/projects/judy/", "summary": "C library array", "description": "The package provides the most advanced core technology, the main\nadvantages are scalability, high performance and memory efficiency.", "build_dep": ["coreutils", "gawk", "gcc", "make", "sed"], "subpacks": [{"bin_name": "Judy", "provides": [], "requires": [{"component": "/bin/sh", "provided_by": ["bash"]}, {"component": "ld-linux-aarch64.so.1()(64bit)", "provided_by": ["glibc"]}, {"component": "ld-linux-aarch64.so.1(GLIBC_2.17)(64bit)", "provided_by": ["glibc"]}, {"component": "rtld(GNU_HASH)", "provided_by": ["glibc"]}, {"component": "libc.so.6(GLIBC_2.17)(64bit)", "provided_by": ["glibc"]}]}]}]} +\ No newline at end of file ++{"os_version_1": [{"src_name": "Judy1", "license": "LGPLv2+", "version": "1.0.5", "url": "http://sourceforge.net/projects/judy/", "summary": "C library array", "description": "The package provides the most advanced core technology, the main\nadvantages are scalability, high performance and memory efficiency.", "build_dep": ["coreutils", "gawk", "gcc", "make", "sed"], "subpacks": [{"bin_name": "Judy", "provides": [], "requires": [{"component": "/bin/sh", "provided_by": ["bash"]}, {"component": "ld-linux-aarch64.so.1()(64bit)", "provided_by": ["glibc"]}, {"component": "ld-linux-aarch64.so.1(GLIBC_2.17)(64bit)", "provided_by": ["glibc"]}, {"component": "rtld(GNU_HASH)", "provided_by": ["glibc"]}, {"component": "libc.so.6(GLIBC_2.17)(64bit)", "provided_by": ["glibc"]}]}]}], "os_version_2": [{"src_name": "Judy1", "license": "LGPLv2+", "version": "1.0.5", "url": "http://sourceforge.net/projects/judy/", "summary": "C library array", "description": "The package provides the most advanced core technology, the main\nadvantages are scalability, high performance and memory efficiency.", "build_dep": ["coreutils", "gawk", "gcc", "make", "sed"], "subpacks": [{"bin_name": "Judy", "provides": [], "requires": [{"component": "/bin/sh", "provided_by": ["bash"]}, {"component": "ld-linux-aarch64.so.1()(64bit)", "provided_by": ["glibc"]}, {"component": "ld-linux-aarch64.so.1(GLIBC_2.17)(64bit)", "provided_by": ["glibc"]}, {"component": "rtld(GNU_HASH)", "provided_by": ["glibc"]}, {"component": "libc.so.6(GLIBC_2.17)(64bit)", "provided_by": ["glibc"]}]}]}]} +\ No newline at end of file + +--- a/test/test_module/test_packages/test_single_package_info/data/wrong_install_for_res.json ++++ b/test/test_module/test_packages/test_single_package_info/data/wrong_install_for_res.json +@@ -1 +1 @@ +-{"openeuler": [{"src_name": "Judy1", "license": "LGPLv2+", "version": "1.0.5", "url": "http://sourceforge.net/projects/judy/", "summary": "C library array", "description": "The package provides the most advanced core technology, the main\nadvantages are scalability, high performance and memory efficiency.", "build_dep": ["coreutils", "gawk", "gcc", "make", "sed"], "subpacks": [{"bin_name": "Judy", "provides": [{"component": "Judy", "required_by_bin": ["Judy-devel"], "required_by_src": ["T"]}, {"component": "Judy(aarch-64)", "required_by_bin": [], "required_by_src": []}, {"component": "libJudy.so.1()(64bit)", "required_by_bin": ["mariadb-oqgraph-engine"], "required_by_src": []}], "requires": []}]}]} +\ No newline at end of file ++{"os_version_1": [{"src_name": "Judy1", "license": "LGPLv2+", "version": "1.0.5", "url": "http://sourceforge.net/projects/judy/", "summary": "C library array", "description": "The package provides the most advanced core technology, the main\nadvantages are scalability, high performance and memory efficiency.", "build_dep": ["coreutils", "gawk", "gcc", "make", "sed"], "subpacks": [{"bin_name": "Judy", "provides": [{"component": "Judy", "required_by_bin": ["Judy-devel"], "required_by_src": ["T"]}, {"component": "Judy(aarch-64)", "required_by_bin": [], "required_by_src": []}, {"component": "libJudy.so.1()(64bit)", "required_by_bin": ["mariadb-oqgraph-engine"], "required_by_src": []}], "requires": []}]}]} +\ No newline at end of file + +--- a/test/test_module/test_packages/test_single_package_info/data/wrong_install_info.json ++++ b/test/test_module/test_packages/test_single_package_info/data/wrong_install_info.json +@@ -1 +1 @@ +-[{"binary_name": "Judy", "bin_version": "1.0.5", "database": "openeuler", "src_name": "Judy", "src_version": "1.0.5"}] +\ No newline at end of file ++[{"binary_name": "Judy", "bin_version": "1.0.5", "database": "os_version_1", "src_name": "Judy", "src_version": "1.0.5"}] +\ No newline at end of file + +--- a/test/test_module/test_packages/test_single_package_info/test_get_bin_package_info.py ++++ b/test/test_module/test_packages/test_single_package_info/test_get_bin_package_info.py +@@ -41,7 +41,7 @@ class TestBinPackageInfo(unittest.TestCase): + + def setUp(self) -> None: + database.get_db_priority = mock.Mock( +- return_value=["openeuler", "fedora"]) ++ return_value=["os_version_1", "os_version_2"]) + + + @patch.object(QueryPackage, "get_bin_info") +@@ -52,7 +52,7 @@ class TestBinPackageInfo(unittest.TestCase): + """ + mock1.return_value = {} + bin_pkg = BinaryPackage() +- res = bin_pkg.bin_package_info(["Judy"], ["openeuler"]) ++ res = bin_pkg.bin_package_info(["Judy"], ["os_version_1"]) + self.assertEqual(res, {}, "Error in testing get empty bin info.") + + @patch.object(QueryPackage, "get_bin_info") +@@ -63,7 +63,7 @@ class TestBinPackageInfo(unittest.TestCase): + """ + mock1.return_value = {None} + bin_pkg = BinaryPackage() +- res = bin_pkg.bin_package_info(["Judy"], ["openeuler"]) ++ res = bin_pkg.bin_package_info(["Judy"], ["os_version_1"]) + self.assertEqual(res, {}, "Error in testing wrong bin info.") + + @patch.object(QueryPackage, "get_bin_info") +@@ -80,7 +80,7 @@ class TestBinPackageInfo(unittest.TestCase): + mock2.return_value = BE_DEPEND_INFO + mock3.return_value = EMPTY_FILELIST_INFO + bin_pkg = BinaryPackage() +- output_res = bin_pkg.bin_package_info(["Judy"], ["openeuler"]) ++ output_res = bin_pkg.bin_package_info(["Judy"], ["os_version_1"]) + self.assertEqual(output_res, {}, "Error in testing empty filelist info.") + + +@@ -98,7 +98,7 @@ class TestBinPackageInfo(unittest.TestCase): + mock2.return_value = BE_DEPEND_INFO + mock3.return_value = ERROR_FILELIST_INFO + bin_pkg = BinaryPackage() +- output_res = bin_pkg.bin_package_info(["Judy"], ["openeuler"]) ++ output_res = bin_pkg.bin_package_info(["Judy"], ["os_version_1"]) + EXPECT_RES = MockData.read_mock_json_data(os.path.join(MOCK_DATA_FILE, + "empty_filelist_for_res.json")) + self.assertEqual(output_res, EXPECT_RES, "Error in testing error filelist info.") +@@ -117,7 +117,7 @@ class TestBinPackageInfo(unittest.TestCase): + mock2.return_value = BE_DEPEND_INFO + mock3.return_value = WRONG_TYPE_FILELIST_INFO + bin_pkg = BinaryPackage() +- output_res = bin_pkg.bin_package_info(["Judy"], ["openeuler"]) ++ output_res = bin_pkg.bin_package_info(["Judy"], ["os_version_1"]) + EXPECT_RES = MockData.read_mock_json_data(os.path.join(MOCK_DATA_FILE, + "empty_filelist_for_res.json")) + self.assertEqual(output_res, EXPECT_RES, "Error in testing wrong type filelist info.") +@@ -150,7 +150,7 @@ class TestBinPackageInfo(unittest.TestCase): + with self.assertRaises(DatabaseConfigException): + mock1.side_effect = DatabaseConfigException() + src_pkg = BinaryPackage() +- res = src_pkg.bin_package_info(["Judy"], ["openeuler"]) ++ res = src_pkg.bin_package_info(["Judy"], ["os_version_1"]) + self.assertEqual(res, {}, "Error in testing config exception.") + + @mock.patch.object(QueryPackage, "get_bin_info") +@@ -163,6 +163,6 @@ class TestBinPackageInfo(unittest.TestCase): + with self.assertRaises(ElasticSearchQueryException): + mock1.side_effect = ElasticSearchQueryException() + src_pkg = BinaryPackage() +- res = src_pkg.bin_package_info(["Judy"], ["openeuler"]) ++ res = src_pkg.bin_package_info(["Judy"], ["os_version_1"]) + self.assertEqual(res, {}, "Error in testing es query exception.") + + +--- a/test/test_module/test_packages/test_single_package_info/test_get_src_package_info.py ++++ b/test/test_module/test_packages/test_single_package_info/test_get_src_package_info.py +@@ -42,7 +42,7 @@ class TestSrcPackageInfo(unittest.TestCase): + + def setUp(self) -> None: + database.get_db_priority = mock.Mock( +- return_value=["openeuler", "fedora"]) ++ return_value=["os_version_1", "os_version_2"]) + + + @patch.object(QueryPackage, "get_src_info") +@@ -53,7 +53,7 @@ class TestSrcPackageInfo(unittest.TestCase): + """ + src_pkg = SourcePackage() + mock1.return_value = {} +- res = src_pkg.src_package_info(["Judy"], ["openeuler"]) ++ res = src_pkg.src_package_info(["Judy"], ["os_version_1"]) + self.assertEqual(res, {}, "Error in testing get empty src info.") + + @patch.object(QueryPackage, "get_src_info") +@@ -64,7 +64,7 @@ class TestSrcPackageInfo(unittest.TestCase): + """ + src_pkg = SourcePackage() + mock1.return_value = {} +- res = src_pkg.src_package_info(["Judy1"], ["openeuler"]) ++ res = src_pkg.src_package_info(["Judy1"], ["os_version_1"]) + self.assertEqual(res, {}, "Error in testing package not exists.") + + @patch.object(QueryPackage, "get_src_info") +@@ -75,7 +75,7 @@ class TestSrcPackageInfo(unittest.TestCase): + """ + src_pkg = SourcePackage() + mock1.return_value = {None} +- res = src_pkg.src_package_info(["Judy"], ["openeuler"]) ++ res = src_pkg.src_package_info(["Judy"], ["os_version_1"]) + self.assertEqual(res, {}, "Error in testing wrong src info.") + + @patch.object(QueryPackage, "get_src_info") +@@ -92,8 +92,8 @@ class TestSrcPackageInfo(unittest.TestCase): + mock3.return_value = [] + mock4.return_value = TRUE_SRC_INFO + src_pkg = SourcePackage() +- res = src_pkg.src_package_info(["Judy"], ["openeuler"]) +- build_dep = res["openeuler"][0]["build_dep"] ++ res = src_pkg.src_package_info(["Judy"], ["os_version_1"]) ++ build_dep = res["os_version_1"][0]["build_dep"] + self.assertEqual(build_dep, [], "Error in testing empty build info.") + + +@@ -111,7 +111,7 @@ class TestSrcPackageInfo(unittest.TestCase): + mock3.return_value = WRONG_BUILD + mock4.return_value = TRUE_SRC_INFO + src_pkg = SourcePackage() +- output_res = src_pkg.src_package_info(["Judy"], ["openeuler"]) ++ output_res = src_pkg.src_package_info(["Judy"], ["os_version_1"]) + EXPECT_RES = MockData.read_mock_json_data(os.path.join(MOCK_DATA_FILE, + "wrong_build_for_res.json")) + self.assertEqual(output_res, EXPECT_RES, "Error in testing wrong build info.") +@@ -126,8 +126,8 @@ class TestSrcPackageInfo(unittest.TestCase): + mock1.return_value = [None] + mock2.return_value = EMPTY_SUBPACK_INFO + src_pkg = SourcePackage() +- res = src_pkg.src_package_info(["Judy"], ["openeuler"]) +- self.assertEqual(res["openeuler"][0]["subpacks"], [], "Error in testing empty subpack info.") ++ res = src_pkg.src_package_info(["Judy"], ["os_version_1"]) ++ self.assertEqual(res["os_version_1"][0]["subpacks"], [], "Error in testing empty subpack info.") + + @patch.object(QueryPackage, "get_src_info") + @patch.object(BuildRequires, "get_build_req") +@@ -143,8 +143,8 @@ class TestSrcPackageInfo(unittest.TestCase): + mock3.return_value = BUILD_REQUIRES_INFO + mock4.return_value = TRUE_SRC_INFO + src_pkg = SourcePackage() +- res = src_pkg.src_package_info(["Judy"], ["openeuler"]) +- output_provides = res["openeuler"][0]["subpacks"][0]["provides"] ++ res = src_pkg.src_package_info(["Judy"], ["os_version_1"]) ++ output_provides = res["os_version_1"][0]["subpacks"][0]["provides"] + self.assertEqual(output_provides, [], "Error in testing empty provides info.") + + @patch.object(QueryPackage, "get_src_info") +@@ -180,7 +180,7 @@ class TestSrcPackageInfo(unittest.TestCase): + mock3.return_value = BUILD_REQUIRES_INFO + mock4.return_value = TRUE_SRC_INFO + src_pkg = SourcePackage() +- output_res = src_pkg.src_package_info(["Judy"], ["openeuler"]) ++ output_res = src_pkg.src_package_info(["Judy"], ["os_version_1"]) + EMPTY_INSTALL_RES = MockData.read_mock_json_data(os.path.join(MOCK_DATA_FILE, + "empty_install_for_res.json")) + self.assertEqual(output_res, EMPTY_INSTALL_RES, "Error in testing empty install info.") +@@ -199,7 +199,7 @@ class TestSrcPackageInfo(unittest.TestCase): + mock3.return_value = BUILD_REQUIRES_INFO + mock4.return_value = TRUE_SRC_INFO + src_pkg = SourcePackage() +- output_res = src_pkg.src_package_info(["Judy"], ["openeuler"]) ++ output_res = src_pkg.src_package_info(["Judy"], ["os_version_1"]) + EMPTY_INSTALL_RES = MockData.read_mock_json_data(os.path.join(MOCK_DATA_FILE, + "wrong_install_for_res.json")) + self.assertEqual(output_res, EMPTY_INSTALL_RES, "Error in testing wrong install info.") +@@ -220,7 +220,7 @@ class TestSrcPackageInfo(unittest.TestCase): + mock3.return_value = BUILD_REQUIRES_INFO + mock4.return_value = TRUE_SRC_INFO + src_pkg = SourcePackage() +- output_res = src_pkg.src_package_info(["Judy"], ["openeuler"]) ++ output_res = src_pkg.src_package_info(["Judy"], ["os_version_1"]) + TRUE_INSTALL_RES = MockData.read_mock_json_data(os.path.join(MOCK_DATA_FILE, + "true_install_for_res.json")) + self.assertDictEqual(output_res, TRUE_INSTALL_RES, "Error in testing true install info.") +@@ -239,7 +239,7 @@ class TestSrcPackageInfo(unittest.TestCase): + mock3.return_value = BUILD_REQUIRES_INFO + mock4.return_value = TRUE_SRC_INFO + src_pkg = SourcePackage() +- output_res = src_pkg.src_package_info(["Judy"], ["openeuler"]) ++ output_res = src_pkg.src_package_info(["Judy"], ["os_version_1"]) + EXPECT_RES = MockData.read_mock_json_data(os.path.join(MOCK_DATA_FILE, + "true_result_with_input_database.json")) + self.assertEqual(output_res, EXPECT_RES, "Error in testing true result with input database.") +@@ -253,7 +253,7 @@ class TestSrcPackageInfo(unittest.TestCase): + with self.assertRaises(DatabaseConfigException): + mock1.side_effect = DatabaseConfigException() + src_pkg = SourcePackage() +- res = src_pkg.src_package_info(["Judy"], ["openeuler"]) ++ res = src_pkg.src_package_info(["Judy"], ["os_version_1"]) + self.assertEqual(res, {}, "Error in testing config exception.") + + @mock.patch.object(QueryPackage, "get_src_info") +@@ -266,6 +266,6 @@ class TestSrcPackageInfo(unittest.TestCase): + with self.assertRaises(ElasticSearchQueryException): + mock1.side_effect = ElasticSearchQueryException() + src_pkg = SourcePackage() +- res = src_pkg.src_package_info(["Judy"], ["openeuler"]) ++ res = src_pkg.src_package_info(["Judy"], ["os_version_1"]) + self.assertEqual(res, {}, "Error in testing es query exception.") + + +--- a/test/test_module/test_selfbuild/data/bin_name_info.json ++++ b/test/test_module/test_selfbuild/data/bin_name_info.json +@@ -1 +1 @@ +-[{"source_name": "Judy", "src_version": "1.0.5", "database": "openeuler", "binary_infos": [{"bin_name": "Judy", "bin_version": "1.0.5"}, {"bin_name": "Judy-devel", "bin_version": "1.0.5"}, {"bin_name": "Judy-help", "bin_version": "1.0.5"}]}] +\ No newline at end of file ++[{"source_name": "Judy", "src_version": "1.0.5", "database": "os_version_1", "binary_infos": [{"bin_name": "Judy", "bin_version": "1.0.5"}, {"bin_name": "Judy-devel", "bin_version": "1.0.5"}, {"bin_name": "Judy-help", "bin_version": "1.0.5"}]}] +\ No newline at end of file + +--- a/test/test_module/test_selfbuild/data/except_bin.json ++++ b/test/test_module/test_selfbuild/data/except_bin.json +@@ -1 +1 @@ +-{"Judy": {"name": "Judy", "version": "1.0.5", "source_name": "Judy", "database": "openeuler", "install": ["bash", "glibc"]}} +\ No newline at end of file ++{"Judy": {"name": "Judy", "version": "1.0.5", "source_name": "Judy", "database": "os_version_1", "install": ["bash", "glibc"]}} +\ No newline at end of file + +--- a/test/test_module/test_selfbuild/data/except_src.json ++++ b/test/test_module/test_selfbuild/data/except_src.json +@@ -1 +1 @@ +-{"Judy": {"name": "Judy", "version": "1.0.5", "database": "openeuler", "build": ["sed"]}} +\ No newline at end of file ++{"Judy": {"name": "Judy", "version": "1.0.5", "database": "os_version_1", "build": ["sed"]}} +\ No newline at end of file + +--- a/test/test_module/test_selfbuild/data/true_build_info.json ++++ b/test/test_module/test_selfbuild/data/true_build_info.json +@@ -1 +1 @@ +-[{"source_name": "Judy", "src_version": "1.0.5", "database": "openeuler", "requires": [{"component": "sed", "com_bin_name": "sed", "com_bin_version": "4.8", "com_src_name": "sed", "com_src_version": "4.8", "com_database": "openeuler"}]}] +\ No newline at end of file ++[{"source_name": "Judy", "src_version": "1.0.5", "database": "os_version_1", "requires": [{"component": "sed", "com_bin_name": "sed", "com_bin_version": "4.8", "com_src_name": "sed", "com_src_version": "4.8", "com_database": "os_version_1"}]}] +\ No newline at end of file + +--- a/test/test_module/test_selfbuild/data/true_install_info.json ++++ b/test/test_module/test_selfbuild/data/true_install_info.json +@@ -1 +1 @@ +-[{"binary_name": "Judy", "bin_version": "1.0.5", "database": "openeuler", "src_name": "Judy", "src_version": "1.0.5", "requires": [{"component": "/bin/sh", "com_bin_name": "bash", "com_bin_version": "5.0", "com_src_name": "bash", "com_src_version": "5.0", "com_database": "openeuler"}, {"component": "/bin/sh", "com_bin_name": "bash", "com_bin_version": "5.0", "com_src_name": "bash", "com_src_version": "5.0", "com_database": "openeuler"}, {"component": "ld-linux-aarch64.so.1()(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "openeuler"}, {"component": "ld-linux-aarch64.so.1(GLIBC_2.17)(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "openeuler"}, {"component": "rtld(GNU_HASH)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "openeuler"}, {"component": "libc.so.6(GLIBC_2.17)(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "openeuler"}]}] +\ No newline at end of file ++[{"binary_name": "Judy", "bin_version": "1.0.5", "database": "os_version_1", "src_name": "Judy", "src_version": "1.0.5", "requires": [{"component": "/bin/sh", "com_bin_name": "bash", "com_bin_version": "5.0", "com_src_name": "bash", "com_src_version": "5.0", "com_database": "os_version_1"}, {"component": "/bin/sh", "com_bin_name": "bash", "com_bin_version": "5.0", "com_src_name": "bash", "com_src_version": "5.0", "com_database": "os_version_1"}, {"component": "ld-linux-aarch64.so.1()(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "os_version_1"}, {"component": "ld-linux-aarch64.so.1(GLIBC_2.17)(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "os_version_1"}, {"component": "rtld(GNU_HASH)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "os_version_1"}, {"component": "libc.so.6(GLIBC_2.17)(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "os_version_1"}]}] +\ No newline at end of file + +--- a/test/test_module/test_selfbuild/data/wrong_update_db_except_bin.json ++++ b/test/test_module/test_selfbuild/data/wrong_update_db_except_bin.json +@@ -1 +1 @@ +-{"Judy": {"name": "Judy", "version": "1.0.5", "source_name": "Judy", "database": "openeuler1", "install": ["bash","glibc"]}} +\ No newline at end of file ++{"Judy": {"name": "Judy", "version": "1.0.5", "source_name": "Judy", "database": "os_version_11", "install": ["bash","glibc"]}} +\ No newline at end of file + +--- a/test/test_module/test_selfbuild/data/wrong_update_db_install.json ++++ b/test/test_module/test_selfbuild/data/wrong_update_db_install.json +@@ -1 +1 @@ +-[{"binary_name": "Judy", "bin_version": "1.0.5", "database": "openeuler1", "src_name": "Judy", "src_version": "1.0.5", "requires": [{"component": "/bin/sh", "com_bin_name": "bash", "com_bin_version": "5.0", "com_src_name": "bash", "com_src_version": "5.0", "com_database": "openeuler"}, {"component": "/bin/sh", "com_bin_name": "bash", "com_bin_version": "5.0", "com_src_name": "bash", "com_src_version": "5.0", "com_database": "openeuler"}, {"component": "ld-linux-aarch64.so.1()(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "openeuler"}, {"component": "ld-linux-aarch64.so.1(GLIBC_2.17)(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "openeuler"}, {"component": "rtld(GNU_HASH)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "openeuler"}, {"component": "libc.so.6(GLIBC_2.17)(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "openeuler"}]}] +\ No newline at end of file ++[{"binary_name": "Judy", "bin_version": "1.0.5", "database": "os_version_11", "src_name": "Judy", "src_version": "1.0.5", "requires": [{"component": "/bin/sh", "com_bin_name": "bash", "com_bin_version": "5.0", "com_src_name": "bash", "com_src_version": "5.0", "com_database": "os_version_1"}, {"component": "/bin/sh", "com_bin_name": "bash", "com_bin_version": "5.0", "com_src_name": "bash", "com_src_version": "5.0", "com_database": "os_version_1"}, {"component": "ld-linux-aarch64.so.1()(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "os_version_1"}, {"component": "ld-linux-aarch64.so.1(GLIBC_2.17)(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "os_version_1"}, {"component": "rtld(GNU_HASH)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "os_version_1"}, {"component": "libc.so.6(GLIBC_2.17)(64bit)", "com_bin_name": "glibc", "com_bin_version": "2.31", "com_src_name": "glibc", "com_src_version": "2.31", "com_database": "os_version_1"}]}] +\ No newline at end of file + +--- a/test/test_module/test_selfbuild/test_get_self_depend_info.py ++++ b/test/test_module/test_selfbuild/test_get_self_depend_info.py +@@ -39,7 +39,7 @@ param = { + "packagename": ["Judy"], + "depend_type": "selfdep", + "parameter": { +- "db_priority": ["openeuler"], ++ "db_priority": ["os_version_1"], + "self_build": True, + "packtype": "source", + "with_subpack": True +@@ -63,7 +63,7 @@ class TestSelfBuildDdepend(unittest.TestCase): + mock1.return_value = TRUE_INSTALL_INFO + mock2.return_value = TRUE_BUILD_INFO + mock3.return_value = [None] +- self_depend = SelfDepend(db_list=['openeuler']) ++ self_depend = SelfDepend(db_list=['os_version_1']) + self_depend.self_depend(pkg_name=["Judy"], pkgtype="source") + binary, source = self_depend.depend_dict + self.assertDictEqual(binary, {}, "Error in testing wrong subpack.") +@@ -82,7 +82,7 @@ class TestSelfBuildDdepend(unittest.TestCase): + mock1.return_value = TRUE_INSTALL_INFO + mock2.return_value = TRUE_BUILD_INFO + mock3.return_value = [] +- self_depend = SelfDepend(db_list=['openeuler']) ++ self_depend = SelfDepend(db_list=['os_version_1']) + self_depend.self_depend(pkg_name=["Judy"], pkgtype="source") + binary, source = self_depend.depend_dict + self.assertEqual(binary, {}, "Error in testing empty subpack.") +@@ -101,7 +101,7 @@ class TestSelfBuildDdepend(unittest.TestCase): + mock1.return_value = TRUE_INSTALL_INFO + mock2.return_value = TRUE_BUILD_INFO + mock3.return_value = BIN_NAME_INFO +- self_depend = SelfDepend(db_list=['openeuler']) ++ self_depend = SelfDepend(db_list=['os_version_1']) + self_depend.self_depend(pkg_name=["Judy"], pkgtype="source", with_subpack=True) + binary, source = self_depend.depend_dict + binary["Judy"]["install"] = sorted(binary["Judy"]["install"]) +@@ -120,7 +120,7 @@ class TestSelfBuildDdepend(unittest.TestCase): + mock1.return_value = TRUE_INSTALL_INFO + mock2.return_value = TRUE_BUILD_INFO + mock3.return_value = WRONG_BIN_NAME_INFO +- self_depend = SelfDepend(db_list=['openeuler']) ++ self_depend = SelfDepend(db_list=['os_version_1']) + self_depend.self_depend(pkg_name=["Judy"], pkgtype="source", with_subpack=True) + binary, source = self_depend.depend_dict + self.assertDictEqual(binary, {}, "Error in empty db src name.") +@@ -136,11 +136,11 @@ class TestSelfBuildDdepend(unittest.TestCase): + """ + mock1.return_value = WRONG_UPDATE_DB + mock2.return_value = TRUE_BUILD_INFO +- self_depend = SelfDepend(db_list=['openeuler', 'fedora30']) ++ self_depend = SelfDepend(db_list=['os_version_1', 'os_version_2']) + self_depend.self_depend(pkg_name=["Judy"]) + binary, source = self_depend.depend_dict + binary["Judy"]["install"] = sorted(binary["Judy"]["install"]) +- EXPECT_SRC = {'Judy': {'name': 'Judy', 'version': '1.0.5', 'database': 'openeuler1'}} ++ EXPECT_SRC = {'Judy': {'name': 'Judy', 'version': '1.0.5', 'database': 'os_version_11'}} + self.assertDictEqual(binary, WRONG_UPDATE_DB_EXCEPT_BIN, "Error in testing wrong update db.") + self.assertDictEqual(source, EXPECT_SRC, "Error in testing wrong update db.") + +@@ -154,7 +154,7 @@ class TestSelfBuildDdepend(unittest.TestCase): + """ + mock1.return_value = TRUE_INSTALL_INFO + mock2.return_value = TRUE_BUILD_INFO +- self_depend = SelfDepend(db_list=['openeuler', 'fedora30']) ++ self_depend = SelfDepend(db_list=['os_version_1', 'os_version_2']) + self_depend.self_depend(pkg_name=["Judy"]) + binary, source = self_depend.depend_dict + binary["Judy"]["install"] = sorted(binary["Judy"]["install"]) +@@ -167,7 +167,7 @@ class TestSelfBuildDdepend(unittest.TestCase): + + """ + with self.assertRaises(AttributeError): +- self_depend = SelfDepend(db_list=['openeuler']) ++ self_depend = SelfDepend(db_list=['os_version_1']) + self_depend.self_depend(pkg_name="Judy") + + +@@ -196,7 +196,7 @@ class TestSelfBuildDdepend(unittest.TestCase): + InstallRequires.get_install_req = mock.Mock(return_value=TRUE_INSTALL_INFO) + BuildRequires.get_build_req = mock.Mock(return_value=TRUE_BUILD_INFO) + QueryPackage.get_bin_name = mock.Mock(return_value=BIN_NAME_INFO) +- self_depend = SelfDepend(db_list=['openeuler']) ++ self_depend = SelfDepend(db_list=['os_version_1']) + self_depend(**param) + binary, source = self_depend.depend_dict + binary["Judy"]["install"] = sorted(binary["Judy"]["install"]) diff --git a/0006-add-check-service-status-when-init.patch b/0006-add-check-service-status-when-init.patch new file mode 100644 index 0000000..6ba408b --- /dev/null +++ b/0006-add-check-service-status-when-init.patch @@ -0,0 +1,38 @@ +--- a/packageship/application/cli/commands/initialize.py ++++ b/packageship/application/cli/commands/initialize.py +@@ -15,9 +15,12 @@ Description: Entry method for custom commands + Class: InitDatabaseCommand + """ + import os ++import threading + import time ++ + import pwd +-import threading ++from requests import RequestException ++ + from packageship.application.cli.base import BaseCommand + from packageship.application.common.exc import InitializeError, ResourceCompetitionError + +@@ -59,6 +62,7 @@ class InitDatabaseCommand(BaseCommand): + self.params = [ + ('-filepath', 'str', 'specify the path of conf.yaml', '', 'store')] + self._char = ["/", "-", "\\"] ++ self._success_code = 200 + + def register(self): + """ +@@ -94,6 +98,13 @@ class InitDatabaseCommand(BaseCommand): + if self.login_user not in ["root", "pkgshipuser"]: + print("The current user does not have initial execution permission") + return ++ try: ++ _query_version_response = self.request.get("{}/version".format(self.read_host)) ++ except RequestException: ++ _query_version_response = None ++ if not _query_version_response or _query_version_response.status_code != self._success_code: ++ print("The pkgship service is not started,please start the service first") ++ return + + from packageship.application.initialize.integration import InitializeService + init = InitializeService() diff --git a/0007-update-readme.patch b/0007-update-readme.patch new file mode 100644 index 0000000..32028c7 --- /dev/null +++ b/0007-update-readme.patch @@ -0,0 +1,45 @@ +--- a/README.md ++++ b/README.md +@@ -11,6 +11,7 @@ + - [配置参数](#配置参数) + - [服务启动和停止](#服务启动和停止) + - [工具使用](#工具使用) ++ - [日志查看和转储](#日志查看和转储) + + + +@@ -91,7 +92,9 @@ pkgship是一款管理OS软件包依赖关系，提供依赖和被依赖关系 + /bin/bash auto_install_pkgship_requires.sh elasticsearch + ``` + +- 或者 ++> 目前由于rpm包方式安装Elasticsearch默认为无密码模式，且pkgship需使用无密码设置的Elasticsearch，所以建议Elasticsearch和pkgship安装在同一服务器，以通过网络隔离提高安全性。后续将支持Elasticsearch设置用户名密码。 ++ ++或者 + + ``` + /bin/bash auto_install_pkgship_requires.sh redis +@@ -114,10 +117,12 @@ vim /etc/pkgship/package.ini + ; 初始化数据库时导入的yaml文件存放位置，该yaml中记录导入的sqlite文件位置。 + init_conf_path=/etc/pkgship/conf.yaml + +-; 数据库端口。 ++; 若部署为客户端-服务端方式，服务端需保证query_ip_addr为本机ip或者0.0.0.0， ++; 并且客户端可通过query_ip_addr加query_port访问服务端，或者通过设置映射的remote_host访问服务端。 ++; 服务查询端口。 + query_port=8090 + +-; 数据库ip地址。 ++; 服务查询ip。 + query_ip_addr=127.0.0.1 + + ; 远程服务的地址，命令行可以直接调用远程服务来完成数据请求。 +@@ -162,7 +167,7 @@ redis_port=6379 + redis_max_connections=10 + + [DATABASE-数据库] +-;数据库访问地址，默认为本机地址 ++;数据库访问地址，建议设置为本机地址 + database_host=127.0.0.1 + + ;数据库访问端口，默认为9200 diff --git a/0008-update-patch-import.patch b/0008-update-patch-import.patch new file mode 100644 index 0000000..3584be4 --- /dev/null +++ b/0008-update-patch-import.patch @@ -0,0 +1,84 @@ +--- a/test/test_module/test_build/test_get_build_depend.py ++++ b/test/test_module/test_build/test_get_build_depend.py +@@ -16,7 +16,7 @@ test get binary package info + import unittest + import os + from unittest import mock +-from mock import patch ++from unittest.mock import patch + from redis import Redis + + from packageship.application.core.depend.build_depend import BuildDepend + +--- a/test/test_module/test_install/test_get_install_depend.py ++++ b/test/test_module/test_install/test_get_install_depend.py +@@ -16,8 +16,7 @@ test get install depend info + import unittest + import os + from unittest import mock +- +-from mock import patch ++from unittest.mock import patch + from redis import Redis + + from packageship.application.core.depend.install_depend import InstallDepend + +--- a/test/test_module/test_packages/test_all_bin_package/test_get_all_bin_package.py ++++ b/test/test_module/test_packages/test_all_bin_package/test_get_all_bin_package.py +@@ -16,7 +16,7 @@ test get all bin package + import os + import unittest + from unittest import mock +-from mock import patch ++from unittest.mock import patch + + from packageship.application.common.exc import PackageInfoGettingError, DatabaseConfigException, \ + ElasticSearchQueryException + +--- a/test/test_module/test_packages/test_all_src_package/test_get_all_src_package.py ++++ b/test/test_module/test_packages/test_all_src_package/test_get_all_src_package.py +@@ -16,7 +16,7 @@ test get all src package + import unittest + import os + from unittest import mock +-from mock import patch ++from unittest.mock import patch + + from packageship.application.common.exc import PackageInfoGettingError, DatabaseConfigException, \ + ElasticSearchQueryException + +--- a/test/test_module/test_packages/test_single_package_info/test_get_bin_package_info.py ++++ b/test/test_module/test_packages/test_single_package_info/test_get_bin_package_info.py +@@ -16,7 +16,7 @@ test get binary package info + import unittest + import os + from unittest import mock +-from mock import patch ++from unittest.mock import patch + + from packageship.application.common.exc import DatabaseConfigException, ElasticSearchQueryException + from packageship.application.core.pkginfo.pkg import BinaryPackage + +--- a/test/test_module/test_packages/test_single_package_info/test_get_src_package_info.py ++++ b/test/test_module/test_packages/test_single_package_info/test_get_src_package_info.py +@@ -16,7 +16,7 @@ test get src package info + import unittest + import os + from unittest import mock +-from mock import patch ++from unittest.mock import patch + + from packageship.application.common.exc import DatabaseConfigException, ElasticSearchQueryException + from packageship.application.core. pkginfo.pkg import SourcePackage + +--- a/test/test_module/test_selfbuild/test_get_self_depend_info.py ++++ b/test/test_module/test_selfbuild/test_get_self_depend_info.py +@@ -16,7 +16,7 @@ test get self_build depend info + import unittest + import os + from unittest import mock +-from mock import patch ++from unittest.mock import patch + from redis import Redis + + from packageship.application.core.depend.self_depend import SelfDepend diff --git a/0009-add-es-insert-test-cases.patch b/0009-add-es-insert-test-cases.patch new file mode 100644 index 0000000..9445c62 --- /dev/null +++ b/0009-add-es-insert-test-cases.patch @@ -0,0 +1,168 @@ +--- a/test/coverage_count.py ++++ b/test/coverage_count.py +@@ -56,22 +56,24 @@ if __name__ == "__main__": + os.path.join(TEST_CASE_PATH, "test_module/test_pkgship_version/"), + os.path.join(TEST_CASE_PATH, "test_module/test_selfbuild/"), + os.path.join(TEST_CASE_PATH, "test_module/test_install/"), +- os.path.join(TEST_CASE_PATH, "test_module/test_build/"),] +- # os.path.join(TEST_CASE_PATH, "test_module/test_bedepend/test_database_query/")] ++ os.path.join(TEST_CASE_PATH, "test_module/test_build/"), ++ os.path.join(TEST_CASE_PATH, "test_module/test_graph/") ++ ] ++ + errors = [] + failures = [] + for file in test_case_files: + runner_result = runner.run(specify_case(file)) + errors.extend(runner_result.errors) + failures.extend(runner_result.failures) +- ++ + if any([errors, failures]): + sys.exit(1) +- ++ + cov.stop() + try: + cov.report(show_missing=True) + # cov.html_report() + except CoverageException: + print("No data to report") +- sys.exit(1) +\ No newline at end of file ++ sys.exit(1) + +--- /dev/null ++++ b/test/test_module/test_database/data/__init__.py +@@ -0,0 +1,12 @@ ++#!/usr/bin/python3 ++# ****************************************************************************** ++# Copyright (c) Huawei Technologies Co., Ltd. 2020-2020. All rights reserved. ++# licensed under the Mulan PSL v2. ++# You can use this software according to the terms and conditions of the Mulan PSL v2. ++# You may obtain a copy of Mulan PSL v2 at: ++# http://license.coscl.org.cn/MulanPSL2 ++# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR ++# IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR ++# PURPOSE. ++# See the Mulan PSL v2 for more details. ++# ******************************************************************************/ + +--- /dev/null ++++ b/test/test_module/test_database/data/mapping.json +@@ -0,0 +1,5 @@ ++{ ++"name": "test_name", ++"version": "1.0.1", ++"release": 2 ++} +\ No newline at end of file + +--- a/test/test_module/test_database/test_es_query.py ++++ b/test/test_module/test_database/test_es_query.py +@@ -10,13 +10,19 @@ + # PURPOSE. + # See the Mulan PSL v2 for more details. + # ******************************************************************************/ ++import os + from unittest import TestCase, mock ++from unittest.mock import MagicMock + + from elasticsearch import Elasticsearch, helpers ++from elasticsearch.client.indices import IndicesClient ++from elasticsearch.exceptions import ElasticsearchException, TransportError + + from packageship.application.common.exc import ElasticSearchQueryException, DatabaseConfigException + from packageship.application.database.engines.elastic import ElasticSearch + ++MOCK_DATA_FILE = os.path.join(os.path.dirname(os.path.abspath(__file__)), "data/mapping.json") ++ + + class TestEsQuery(TestCase): + +@@ -112,6 +118,85 @@ class TestEsQuery(TestCase): + es2 = ElasticSearch(host="127.0.0.1") + self.assertIs(es1, es2) + ++ def test_create_index_success(self): ++ """ ++ Test create indices success ++ Returns: ++ """ ++ IndicesClient.exists = MagicMock(side_effect=[False, False]) ++ IndicesClient.create = MagicMock(side_effect=[True, True]) ++ ++ es_instance = self._es_init() ++ indices = [dict(file=MOCK_DATA_FILE, name="test1"), dict(file=MOCK_DATA_FILE, name="test2")] ++ result = es_instance.create_index(indices) ++ self.assertEqual(result, []) ++ ++ def test_create_index_fail(self): ++ """ ++ Test create indices failed ++ Returns: ++ """ ++ IndicesClient.exists = MagicMock(side_effect=[False]) ++ IndicesClient.create = MagicMock(side_effect=[ElasticsearchException]) ++ ++ es_instance = self._es_init() ++ indices = [dict(file=MOCK_DATA_FILE, name="test1")] ++ result = es_instance.create_index(indices) ++ self.assertEqual(result, ["test1"]) ++ ++ def test_delete_index_fail(self): ++ """ ++ Test delete indices success ++ Returns: ++ """ ++ IndicesClient.exists = MagicMock(side_effect=[True]) ++ IndicesClient.delete = MagicMock(side_effect=[TransportError]) ++ ++ es_instance = self._es_init() ++ indices = [dict(file=MOCK_DATA_FILE, name="test1")] ++ result = es_instance.create_index(indices) ++ self.assertEqual(result, ["test1"]) ++ ++ def test_load_mapping_fail(self): ++ """ ++ Test load mapping success ++ Returns: ++ """ ++ es_instance = self._es_init() ++ indices = dict(file=MOCK_DATA_FILE + "1", name="test1") ++ result = es_instance.create_index(indices) ++ self.assertEqual(result, ["test1"]) ++ ++ def test_insert_fail(self): ++ """ ++ Test insert indices success ++ Returns: ++ """ ++ es_instance = self._es_init() ++ with self.assertRaises(ElasticSearchQueryException): ++ es_instance.insert(index="test", body={}) ++ ++ def test_delete_index_none(self): ++ """ ++ Test delete indices is none ++ Returns: ++ """ ++ es_instance = self._es_init() ++ result = es_instance.delete_index(index="") ++ self.assertIsNone(result) ++ ++ def test_delete_many_indices_fail(self): ++ """ ++ Test delete indices failed ++ Returns: ++ """ ++ IndicesClient.delete = MagicMock(side_effect=[TransportError]) ++ ++ es_instance = self._es_init() ++ indices = ['test1', 'test2'] ++ result = es_instance.delete_index(indices) ++ self.assertEqual(result, "test1,test2") ++ + @staticmethod + def _es_init(): + return ElasticSearch(host="127.0.0.1", port="9200") diff --git a/pkgship.spec b/pkgship.spec index 0f05c83..d812ff8 100644 --- a/pkgship.spec +++ b/pkgship.spec @@ -1,11 +1,21 @@ Name: pkgship Version: 2.1.0 -Release: 7 +Release: 8 Summary: Pkgship implements rpm package dependence ,maintainer, patch query and so on. License: Mulan 2.0 URL: https://gitee.com/openeuler/pkgship Source0: https://gitee.com/openeuler/pkgship-%{version}.tar.gz +patch0001: 0001-optimization-printing-progress-bar.patch +patch0002: 0002-update-doc.patch +patch0003: 0003-fix-pkginfo-queries.patch +patch0004: 0004-wrong-judgment-of-startup-success.patch +patch0005: 0005-canonical-naming.patch +patch0006: 0006-add-check-service-status-when-init.patch +patch0007: 0007-update-readme.patch +patch0008: 0008-update-patch-import.patch +patch0009: 0009-add-es-insert-test-cases.patch + BuildArch: noarch BuildRequires: shadow python3-mock @@ -24,7 +34,7 @@ Requires: python3-elasticsearch python3-concurrent-log-handler Pkgship implements rpm package dependence ,maintainer, patch query and so no. %prep -%autosetup -n pkgship-%{version} +%autosetup -n pkgship-%{version} -p1 %build %py3_build @@ -109,14 +119,17 @@ create_dir_file /var/log/pkgship-operation 700 d %attr(0640,pkgshipuser,pkgshipuser) /lib/systemd/system/pkgship.service %changelog +* Sat Mar 20 2021 Haiwei Li - 2.1.0-8 +- add patchs from the previous version + * Fri Mar 19 2021 Yiru Wang - 2.1.0-7 -- rm hidden file such as .git file from tar file +- check the pkgship service before pkgship init * Thu Mar 11 2021 zhang tao - 2.1.0-6 - In the build phase, modify the path of the log file to solve the permission problem - add python3-mock to BuildRequires and Requires to solve check error -* Tue Mar 5 2021 Haiwei Li - 2.1.0-5 +* Fri Mar 5 2021 Haiwei Li - 2.1.0-5 - Modify the log logrotate scheme * Tue Mar 2 2021 Yiru Wang - 2.1.0-4 @@ -134,9 +147,6 @@ create_dir_file /var/log/pkgship-operation 700 d Tue Jan 5 2021 Shenmei Tu - Analyze bedepend and selfbuild dependency result for command line -* Thu Dec 17 2020 Yiru Wang -- Add the basic schema file for pkgship based on elasticsearch - * Wed Dec 23 2020 Pengju Jiang - Four kinds of dependent zip download batch upload - Write the parsed data to CSV part of the code for uploading @@ -149,7 +159,7 @@ create_dir_file /var/log/pkgship-operation 700 d * Mon Dec 21 2020 Pengju Jiang - Four kinds of dependent zip download batch upload - be_depend data parsing -* Tue Dec 17 2020 Pengju Jiang +* Thu Dec 17 2020 Pengju Jiang - Four kinds of dependent zip download batch upload - build dependent data parsing * Thu Dec 17 2020 Chengqiang Bao @@ -161,6 +171,9 @@ create_dir_file /var/log/pkgship-operation 700 d * Thu Dec 17 2020 Chengqiang Bao - Add not_found_packages in output result for be depend interface +* Thu Dec 17 2020 Yiru Wang +- Add the basic schema file for pkgship based on elasticsearch + * Tue Dec 15 2020 Shenmei Tu - Add batch query for self depend interface and dependinfo self depend interface @@ -197,7 +210,7 @@ create_dir_file /var/log/pkgship-operation 700 d * Sat Nov 28 2020 Shenmei Tu - Test case refactoring-upload in batches 4 -* Fir Nov 27 2020 Shenmei Tu +* Fri Nov 27 2020 Shenmei Tu - Test case refactoring-upload in batches 3 * Thu Nov 26 2020 Chengqiang Bao @@ -209,7 +222,7 @@ create_dir_file /var/log/pkgship-operation 700 d * Mon Nov 23 2020 Shenmei Tu - Modification of add_sig_info interface bug, adding test cases for this interface -* Mon Nov 18 2020 Pengju Jiang +* Wed Nov 18 2020 Pengju Jiang - Upload zip file download in batches-basic code * Tue Nov 10 2020 Shenmei Tu @@ -281,7 +294,7 @@ create_dir_file /var/log/pkgship-operation 700 d * Thu Sep 24 2020 Yiru Wang - 1.1.0-10 - rm queue_maxsize param from package.ini and this parameter is not customizable -* Tue Sep 21 2020 Shenmei Tu - 1.0-0-9 +* Mon Sep 21 2020 Shenmei Tu - 1.0-0-9 - Solve the problem of data duplication, increase the maximum queue length judgment, - and avoid occupying too much memory