code
stringlengths 1
1.05M
| repo_name
stringlengths 6
83
| path
stringlengths 3
242
| language
stringclasses 222
values | license
stringclasses 20
values | size
int64 1
1.05M
|
|---|---|---|---|---|---|
"""Stable Diffusion WebUI 管理工具"""
import os
import sys
from pathlib import Path
from typing import Literal
from sd_webui_all_in_one import git_warpper
from sd_webui_all_in_one.logger import get_logger
from sd_webui_all_in_one.config import LOGGER_COLOR, LOGGER_LEVEL
from sd_webui_all_in_one.downloader import download_file
from sd_webui_all_in_one.manager.base_manager import BaseManager
from sd_webui_all_in_one.mirror_manager import set_mirror
from sd_webui_all_in_one.env_check.fix_torch import fix_torch_libomp
from sd_webui_all_in_one.env_check.fix_numpy import check_numpy
from sd_webui_all_in_one.utils import warning_unexpected_params
from sd_webui_all_in_one.optimize.cuda_malloc import set_cuda_malloc
from sd_webui_all_in_one.env import configure_env_var, configure_pip
from sd_webui_all_in_one.env_check.fix_dependencies import py_dependency_checker
from sd_webui_all_in_one.colab_tools import is_colab_environment, mount_google_drive
from sd_webui_all_in_one.env_check.onnxruntime_gpu_check import check_onnxruntime_gpu
from sd_webui_all_in_one.env_manager import install_manager_depend, install_pytorch, install_requirements
from sd_webui_all_in_one.env_check.sd_webui_extension_dependency_installer import install_extension_requirements
logger = get_logger(
name="SD WebUI Manager",
level=LOGGER_LEVEL,
color=LOGGER_COLOR,
)
class SDWebUIManager(BaseManager):
"""Stable Diffusion WebUI 管理工具"""
def mount_drive(
self,
extras: list[dict[str, str | bool]] = None,
) -> None:
"""挂载 Google Drive 并创建 Stable Diffusion WebUI 输出文件夹
挂载额外目录需要使用`link_dir`指定要挂载的路径, 并且使用相对路径指定
相对路径的起始位置为`{self.workspace}/{self.workfolder}`
若额外链接路径为文件, 需指定`is_file`属性为`True`
例如:
```python
extras = [
{"link_dir": "models/loras"},
{"link_dir": "custom_nodes"},
{"link_dir": "extra_model_paths.yaml", "is_file": True},
]
```
默认挂载的目录和文件: `outputs`, `config_states`, `params.txt`, `config.json`, `ui-config.json`, `styles.csv`
Args:
extras (list[dict[str, str | bool]]): 挂载额外目录
Raises:
RuntimeError: 挂载 Google Drive 失败
"""
if not is_colab_environment():
logger.warning("当前环境非 Colab, 无法挂载 Google Drive")
return
drive_path = Path("/content/drive")
if not (drive_path / "MyDrive").exists():
if not mount_google_drive(drive_path):
raise RuntimeError("挂载 Google Drive 失败, 请尝试重新挂载 Google Drive")
drive_output = drive_path / "MyDrive" / "sd_webui_output"
sd_webui_path = self.workspace / self.workfolder
links: list[dict[str, str | bool]] = [
{"link_dir": "outputs"},
{"link_dir": "config_states"},
{"link_dir": "params.txt", "is_file": True},
{"link_dir": "config.json", "is_file": True},
{"link_dir": "ui-config.json", "is_file": True},
{"link_dir": "styles.csv", "is_file": True},
]
if extras is not None:
links += extras
self.link_to_google_drive(
base_dir=sd_webui_path,
drive_path=drive_output,
links=links,
)
def get_sd_model(
self,
url: str,
filename: str = None,
model_type: str | None = "Stable-diffusion",
) -> Path | None:
"""下载模型
Args:
url (str): 模型的下载链接
filename (str | None): 模型下载后保存的名称
model_type (str | None): 模型的类型
Returns:
(Path | None): 模型保存路径
"""
if model_type == "embeddings":
path = self.workspace / self.workfolder / model_type
else:
path = self.workspace / self.workfolder / "models" / model_type
return self.get_model(url=url, path=path, filename=filename, tool="aria2")
def get_sd_model_from_list(
self,
model_list: list[dict[str, str]],
) -> None:
"""从模型列表下载模型
`model_list`需要指定`url`(模型下载链接), 可选参数为`type`(模型类型), `filename`(模型保存名称), 例如
```python
model_list = [
{"url": "url1", "type": "Stable-diffusion"},
{"url": "url2", "filename": "file.safetensors"},
{"url": "url3", "type": "loras", "filename": "lora1.safetensors"},
{"url": "url4"},
]
```
Args:
model_list (list[dict[str, str]]): 模型列表
"""
for model in model_list:
url = model.get("url")
filename = model.get("filename")
model_type = model.get("type", "Stable-diffusion")
self.get_sd_model(url=url, filename=filename, model_type=model_type)
def install_config(
self,
setting: str | None = None,
requirements: str | None = None,
requirements_file: str | None = None,
) -> None:
"""下载 Stable Diffusion WebUI 配置文件
Args:
setting (str | None): Stable Diffusion WebUI 设置文件下载链接, 下载后将保存在`{self.workspace}/{self.workfolder}/config.json`
requirements (str | None): Stable Diffusion WebUI 依赖表文件下载链接, 下载后将保存在`{self.workspace}/{self.workfolder}/{requirements_file}`
requirements_file (str | None): Stable Diffusion WebUI 依赖表文件名
"""
setting_path = self.workspace / self.workfolder
logger.info("下载配置文件")
if setting is not None:
download_file(
url=setting,
path=setting_path,
save_name="config.json",
)
if requirements is not None:
try:
(setting_path / requirements_file).unlink(missing_ok=True)
download_file(
url=requirements,
path=setting_path,
save_name=requirements_file,
)
except Exception as e:
logger.error("下载 Stable Diffusion WebUI 依赖文件出现错误: %s", e)
def install_extension(
self,
extension: str,
) -> Path | None:
"""安装 Stable Diffusion WebUI 扩展
Args:
extension (str): 扩展下载地址
Returns:
(Path | None): 扩展安装路径
"""
extension_path = self.workspace / self.workfolder / "extensions"
name = os.path.basename(extension)
install_path = extension_path / name
logger.info("安装 %s 扩展中", name)
p = git_warpper.clone(repo=extension, path=install_path)
if p is not None:
logger.info("安装 %s 扩展完成", name)
return p
logger.error("安装 %s 扩展失败", name)
return None
def install_extensions_from_list(
self,
extension_list: list[str],
) -> None:
"""安装 Stable Diffusion WebUI 扩展
Args:
extension_list (list[str]): 扩展列表
"""
logger.info("安装 Stable Diffusion WebUI 扩展中")
for extension in extension_list:
self.install_extension(extension)
logger.info("安装 Stable Diffusion WebUI 扩展完成")
def update_extensions(self) -> None:
"""更新 Stable Diffusion WebUI 扩展"""
extension_path = self.workspace / self.workfolder / "extensions"
extension_list = [x for x in extension_path.iterdir() if x.is_dir() and (x / ".git").is_dir()]
for i in extension_list:
logger.info("更新 %s 扩展中", i.name)
if git_warpper.update(i):
logger.info("更新 %s 扩展成功", i.name)
else:
logger.info("更新 %s 扩展失败", i.name)
def check_env(
self,
use_uv: bool | None = True,
requirements_file: str | None = "requirements_versions.txt",
) -> None:
"""检查 Stable Diffusion WebUI 运行环境
Args:
use_uv (bool | None): 使用 uv 安装依赖
requirements_file (str | None): 依赖文件名
"""
sd_webui_path = self.workspace / self.workfolder
requirement_path = sd_webui_path / requirements_file
py_dependency_checker(
requirement_path=requirement_path,
name="Stable Diffusion WebUI",
use_uv=use_uv,
)
install_extension_requirements(sd_webui_base_path=sd_webui_path)
fix_torch_libomp()
check_onnxruntime_gpu(use_uv=use_uv, ignore_ort_install=True)
check_numpy(use_uv=use_uv)
def get_launch_command(
self,
params: list[str] | str | None = None,
) -> str:
"""获取 Stable Diffusion WebUI 启动命令
Args:
params (list[str] | str | None): 启动 Stable Diffusion WebUI 的参数
Returns:
str: 完整的启动 Stable Diffusion WebUI 的命令
"""
sd_webui_path = self.workspace / self.workfolder
cmd = [Path(sys.executable).as_posix(), (sd_webui_path / "launch.py").as_posix()]
if params is not None:
if isinstance(params, str):
cmd += self.parse_cmd_str_to_list(params)
else:
cmd += params
return self.parse_cmd_list_to_str(cmd)
def run(
self,
params: list[str] | str | None = None,
display_mode: Literal["terminal", "jupyter"] | None = None,
) -> None:
"""启动 Stable Diffusion WebUI
Args:
params (list[str] | str | None): 启动 Stable Diffusion WebUI 的参数
display_mode (Literal["terminal", "jupyter"] | None): 执行子进程时使用的输出模式
"""
self.launch(
name="Stable Diffusion WebUI",
base_path=self.workspace / self.workfolder,
cmd=self.get_launch_command(params),
display_mode=display_mode,
)
def install(
self,
torch_ver: str | list[str] | None = None,
xformers_ver: str | list[str] | None = None,
use_uv: bool | None = True,
pypi_index_mirror: str | None = None,
pypi_extra_index_mirror: str | None = None,
pypi_find_links_mirror: str | None = None,
github_mirror: str | list[str] | None = None,
huggingface_mirror: str | None = None,
pytorch_mirror: str | None = None,
sd_webui_repo: str | None = None,
sd_webui_branch: str | None = None,
sd_webui_requirements: str | None = None,
sd_webui_requirements_url: str | None = None,
sd_webui_setting: str | None = None,
extension_list: list[str] | None = None,
model_list: list[dict[str, str]] | None = None,
check_avaliable_gpu: bool | None = False,
enable_tcmalloc: bool | None = True,
enable_cuda_malloc: bool | None = True,
custom_sys_pkg_cmd: list[list[str]] | list[str] | bool | None = None,
huggingface_token: str | None = None,
modelscope_token: str | None = None,
update_core: bool | None = True,
*args,
**kwargs,
) -> None:
"""安装 Stable Diffusion WebUI
Args:
torch_ver (str | list[str] | None): 指定的 PyTorch 软件包包名, 并包括版本号
xformers_ver (str | list[str] | None): 指定的 xFormers 软件包包名, 并包括版本号
use_uv (bool | None): 使用 uv 替代 Pip 进行 Python 软件包的安装
pypi_index_mirror (str | None): PyPI Index 镜像源链接
pypi_extra_index_mirror (str | None): PyPI Extra Index 镜像源链接
pypi_find_links_mirror (str | None): PyPI Find Links 镜像源链接
github_mirror (str | list[str] | None): Github 镜像源链接或者镜像源链接列表
huggingface_mirror (str | None): HuggingFace 镜像源链接
pytorch_mirror (str | None): PyTorch 镜像源链接
sd_webui_repo (str | None): Stable Diffusion WebUI 仓库地址
sd_webui_branch (str | None): Stable Diffusion WebUI 分支
sd_webui_requirements (str | None): Stable Diffusion WebUI 依赖文件名
sd_webui_requirements_url (str | None): Stable Diffusion WebUI 依赖文件下载地址
sd_webui_setting (str | None): Stable Diffusion WebUI 预设文件下载链接
extension_list (list[str] | None): 扩展列表
model_list (list[dict[str, str]] | None): 模型下载列表
check_avaliable_gpu (bool | None): 是否检查可用的 GPU, 当检查时没有可用 GPU 将引发`Exception`
enable_tcmalloc (bool | None): 是否启用 TCMalloc 内存优化
enable_cuda_malloc (bool | None): 启用 CUDA 显存优化
custom_sys_pkg_cmd (list[list[str]] | list[str] | bool | None): 自定义调用系统包管理器命令, 设置为 True / None 为使用默认的调用命令, 设置为 False 则禁用该功能
huggingface_token (str | None): 配置 HuggingFace Token
modelscope_token (str | None): 配置 ModelScope Token
update_core (bool | None): 安装时更新内核和扩展
Raises:
Exception: GPU 不可用
"""
warning_unexpected_params(
message="SDWebUIManager.install() 接收到不期望参数, 请检查参数输入是否正确",
args=args,
kwargs=kwargs,
)
logger.info("开始安装 Stable Diffusion WebUI")
if custom_sys_pkg_cmd is False:
custom_sys_pkg_cmd = []
elif custom_sys_pkg_cmd is True:
custom_sys_pkg_cmd = None
os.chdir(self.workspace)
sd_webui_path = self.workspace / self.workfolder
sd_webui_repo = "https://github.com/AUTOMATIC1111/stable-diffusion-webui" if sd_webui_repo is None else sd_webui_repo
sd_webui_setting = "https://github.com/licyk/sd-webui-all-in-one/raw/main/config/sd_webui_config.json" if sd_webui_setting is None else sd_webui_setting
requirements_path = sd_webui_path / ("requirements_versions.txt" if sd_webui_requirements is None else sd_webui_requirements)
if check_avaliable_gpu:
self.check_avaliable_gpu()
set_mirror(
pypi_index_mirror=pypi_index_mirror,
pypi_extra_index_mirror=pypi_extra_index_mirror,
pypi_find_links_mirror=pypi_find_links_mirror,
github_mirror=github_mirror,
huggingface_mirror=huggingface_mirror,
)
configure_pip()
configure_env_var()
install_manager_depend(
use_uv=use_uv,
custom_sys_pkg_cmd=custom_sys_pkg_cmd,
)
git_warpper.clone(sd_webui_repo, sd_webui_path)
if extension_list is not None:
self.install_extensions_from_list(extension_list)
if update_core:
git_warpper.update(sd_webui_path)
self.update_extensions()
if sd_webui_branch is not None:
git_warpper.switch_branch(
path=sd_webui_path,
branch=sd_webui_branch,
recurse_submodules=True,
)
install_pytorch(
torch_package=torch_ver,
xformers_package=xformers_ver,
pytorch_mirror=pytorch_mirror,
use_uv=use_uv,
)
self.install_config(
setting=sd_webui_setting,
requirements=sd_webui_requirements_url,
requirements_file=requirements_path.name,
)
install_requirements(
path=requirements_path,
use_uv=use_uv,
cwd=sd_webui_path,
)
if model_list is not None:
self.get_sd_model_from_list(model_list)
self.restart_repo_manager(
hf_token=huggingface_token,
ms_token=modelscope_token,
)
if enable_tcmalloc:
self.tcmalloc.configure_tcmalloc()
if enable_cuda_malloc:
set_cuda_malloc()
logger.info("Stable Diffusion WebUI 安装完成")
|
2301_81996401/sd-webui-all-in-one
|
sd_webui_all_in_one/manager/sd_webui_manager.py
|
Python
|
agpl-3.0
| 16,578
|
"""PyPI / Github / HuggingFace 镜像管理工具"""
import os
from pathlib import Path
from tempfile import TemporaryDirectory
from sd_webui_all_in_one.cmd import run_cmd
from sd_webui_all_in_one.logger import get_logger
from sd_webui_all_in_one.file_manager import remove_files
from sd_webui_all_in_one.config import LOGGER_LEVEL, LOGGER_COLOR
logger = get_logger(
name="Mirror Manager",
level=LOGGER_LEVEL,
color=LOGGER_COLOR,
)
def set_pypi_index_mirror(mirror: str | None = None) -> None:
"""设置 PyPI Index 镜像源
Args:
mirror (str | None): PyPI 镜像源链接, 当不传入镜像源链接时则清除镜像源
"""
if mirror is not None:
logger.info("使用 PIP_INDEX_URL, UV_DEFAULT_INDEX 环境变量设置 PyPI Index 镜像源")
os.environ["PIP_INDEX_URL"] = mirror
os.environ["UV_DEFAULT_INDEX"] = mirror
else:
logger.info("清除 PIP_INDEX_URL, UV_DEFAULT_INDEX 环境变量, 取消使用 PyPI Index 镜像源")
os.environ.pop("PIP_INDEX_URL", None)
os.environ.pop("UV_DEFAULT_INDEX", None)
def set_pypi_extra_index_mirror(mirror: str | None = None) -> None:
"""设置 PyPI Extra Index 镜像源
Args:
mirror (str | None): PyPI 镜像源链接, 当不传入镜像源链接时则清除镜像源
"""
if mirror is not None:
logger.info("使用 PIP_EXTRA_INDEX_URL, UV_INDEX 环境变量设置 PyPI Extra Index 镜像源")
os.environ["PIP_EXTRA_INDEX_URL"] = mirror
os.environ["UV_INDEX"] = mirror
else:
logger.info("清除 PIP_EXTRA_INDEX_URL, UV_INDEX 环境变量, 取消使用 PyPI Extra Index 镜像源")
os.environ.pop("PIP_EXTRA_INDEX_URL", None)
os.environ.pop("UV_INDEX", None)
def set_pypi_find_links_mirror(mirror: str | None = None) -> None:
"""设置 PyPI Find Links 镜像源
Args:
mirror (str | None): PyPI 镜像源链接, 当不传入镜像源链接时则清除镜像源
"""
if mirror is not None:
logger.info("使用 PIP_FIND_LINKS, UV_FIND_LINKS 环境变量设置 PyPI Find Links 镜像源")
os.environ["PIP_FIND_LINKS"] = " ".join([x.strip() for x in mirror.strip().split()])
# UV_FIND_LINKS 使用 `,` 分割镜像源: https://github.com/astral-sh/uv/pull/10477
os.environ["UV_FIND_LINKS"] = ",".join([x.strip() for x in mirror.strip().split()])
else:
logger.info("清除 PIP_FIND_LINKS, UV_FIND_LINKS 环境变量, 取消使用 PyPI Find Links 镜像源")
os.environ.pop("PIP_FIND_LINKS", None)
os.environ.pop("UV_FIND_LINKS", None)
def set_github_mirror(mirror: str | list[str] | None = None, config_path: Path | str = None) -> None:
"""设置 Github 镜像源
当`mirror`传入的是 Github 镜像源地址, 则直接设置 GIT_CONFIG_GLOBAL 环境变量并直接使用该镜像源地址
如果传入的是镜像源列表, 则自动测试可用的 Github 镜像源并设置 GIT_CONFIG_GLOBAL 环境变量
当不传入参数时则清除 GIT_CONFIG_GLOBAL 环境变量并删除 GIT_CONFIG_GLOBAL 环境变量对应的 Git 配置文件
使用:
```python
set_github_mirror() # 不传入参数时则清除 Github 镜像源
set_github_mirror("https://ghfast.top/https://github.com") # 只设置一个 Github 镜像源时将直接使用该 Github 镜像源
set_github_mirror( # 传入 Github 镜像源列表时将自动测试可用的 Github 镜像源并设置
[
"https://ghfast.top/https://github.com",
"https://mirror.ghproxy.com/https://github.com",
"https://ghproxy.net/https://github.com",
"https://gh.api.99988866.xyz/https://github.com",
"https://gh-proxy.com/https://github.com",
"https://ghps.cc/https://github.com",
"https://gh.idayer.com/https://github.com",
"https://ghproxy.1888866.xyz/github.com",
"https://slink.ltd/https://github.com",
"https://github.boki.moe/github.com",
"https://github.moeyy.xyz/https://github.com",
"https://gh-proxy.net/https://github.com",
"https://gh-proxy.ygxz.in/https://github.com",
"https://wget.la/https://github.com",
"https://kkgithub.com",
"https://gitclone.com/github.com",
]
)
```
Args:
mirror (str | list[str] | None): Github 镜像源地址
config_path (Path | str): Git 配置文件路径
"""
if mirror is None:
logger.info("清除 GIT_CONFIG_GLOBAL 环境变量, 取消使用 Github 镜像源")
git_config = os.environ.pop("GIT_CONFIG_GLOBAL", None)
if git_config is not None:
p = Path(git_config)
if p.exists():
p.unlink()
return
if config_path is None:
config_path = os.getcwd()
config_path = Path(config_path) if not isinstance(config_path, Path) and config_path is not None else config_path
git_config_path = config_path / ".gitconfig"
os.environ["GIT_CONFIG_GLOBAL"] = git_config_path.as_posix()
if isinstance(mirror, str):
logger.info("通过 GIT_CONFIG_GLOBAL 环境变量设置 Github 镜像源")
try:
run_cmd(
[
"git",
"config",
"--global",
f"url.{mirror}.insteadOf",
"https://github.com",
]
)
except Exception as e:
logger.error("设置 Github 镜像源时发生错误: %s", e)
elif isinstance(mirror, list):
with TemporaryDirectory() as tmp_dir:
mirror_test_path = tmp_dir / "__github_mirror_test__"
custon_env = os.environ.copy()
custon_env.pop("GIT_CONFIG_GLOBAL", None)
for gh in mirror:
logger.info("测试 Github 镜像源: %s", gh)
test_repo = f"{gh}/licyk/empty"
if mirror_test_path.exists():
remove_files(mirror_test_path)
try:
run_cmd(
["git", "clone", test_repo, mirror_test_path.as_posix()],
custom_env=custon_env,
live=False,
)
if mirror_test_path.exists():
remove_files(mirror_test_path)
run_cmd(
[
"git",
"config",
"--global",
f"url.{gh}.insteadOf",
"https://github.com",
]
)
logger.info("该镜像源可用")
return
except Exception as _:
logger.info("镜像源不可用")
logger.info("无可用的 Github 镜像源, 取消使用 Github 镜像源")
if git_config_path.exists():
git_config_path.unlink()
os.environ.pop("GIT_CONFIG_GLOBAL", None)
else:
logger.info("未知镜像源参数类型: %s", type(mirror))
return
def set_huggingface_mirror(mirror: str | None = None) -> None:
"""设置 HuggingFace 镜像源
Args:
mirror (str | None): HuggingFace 镜像源链接, 当不传入镜像源链接时则清除镜像源
"""
if mirror is not None:
logger.info("使用 HF_ENDPOINT 环境变量设置 HuggingFace 镜像源")
os.environ["HF_ENDPOINT"] = mirror
else:
logger.info("清除 HF_ENDPOINT 环境变量, 取消使用 HuggingFace 镜像源")
os.environ.pop("HF_ENDPOINT", None)
def set_mirror(
pypi_index_mirror: str | None = None,
pypi_extra_index_mirror: str | None = None,
pypi_find_links_mirror: str | None = None,
github_mirror: str | list[str] | None = None,
huggingface_mirror: str | None = None,
) -> None:
"""镜像源设置
Args:
pypi_index_mirror (str | None): PyPI Index 镜像源链接
pypi_extra_index_mirror (str | None): PyPI Extra Index 镜像源链接
pypi_find_links_mirror (str | None): PyPI Find Links 镜像源链接
github_mirror (str | list[str] | None): Github 镜像源链接或者镜像源链接列表
huggingface_mirror (str | None): HuggingFace 镜像源链接
"""
logger.info("配置镜像源中")
set_pypi_index_mirror(pypi_index_mirror)
set_pypi_extra_index_mirror(pypi_extra_index_mirror)
set_pypi_find_links_mirror(pypi_find_links_mirror)
set_github_mirror(github_mirror)
set_huggingface_mirror(huggingface_mirror)
logger.info("镜像源配置完成")
|
2301_81996401/sd-webui-all-in-one
|
sd_webui_all_in_one/mirror_manager.py
|
Python
|
agpl-3.0
| 8,789
|
"""CUDA Malloc 配置工具"""
import os
import ctypes
import subprocess
import importlib.util
from sd_webui_all_in_one.logger import get_logger
from sd_webui_all_in_one.config import LOGGER_LEVEL, LOGGER_COLOR
logger = get_logger(
name="CUDA Malloc",
level=LOGGER_LEVEL,
color=LOGGER_COLOR,
)
def get_gpu_names() -> set[str]:
"""获取 GPU 的列表
Returns:
set[str]: GPU 名称列表
"""
if os.name == "nt":
class DisplayDevicea(ctypes.Structure):
"""显示设备信息结构类型"""
_fields_ = [
("cb", ctypes.c_ulong),
("DeviceName", ctypes.c_char * 32),
("DeviceString", ctypes.c_char * 128),
("StateFlags", ctypes.c_ulong),
("DeviceID", ctypes.c_char * 128),
("DeviceKey", ctypes.c_char * 128),
]
cb = None
# Load user32.dll
user32 = ctypes.windll.user32
# Call EnumDisplayDevicesA
def enum_display_devices():
device_info = DisplayDevicea()
device_info.cb = ctypes.sizeof(device_info)
device_index = 0
gpu_names = set()
while user32.EnumDisplayDevicesA(None, device_index, ctypes.byref(device_info), 0):
device_index += 1
gpu_names.add(device_info.DeviceString.decode("utf-8"))
return gpu_names
return enum_display_devices()
else:
gpu_names = set()
out = subprocess.check_output(["nvidia-smi", "-L"])
for line in out.split(b"\n"):
if len(line) > 0:
gpu_names.add(line.decode("utf-8").split(" (UUID")[0])
return gpu_names
GPU_BLACKLIST = {
"GeForce GTX TITAN X",
"GeForce GTX 980",
"GeForce GTX 970",
"GeForce GTX 960",
"GeForce GTX 950",
"GeForce 945M",
"GeForce 940M",
"GeForce 930M",
"GeForce 920M",
"GeForce 910M",
"GeForce GTX 750",
"GeForce GTX 745",
"Quadro K620",
"Quadro K1200",
"Quadro K2200",
"Quadro M500",
"Quadro M520",
"Quadro M600",
"Quadro M620",
"Quadro M1000",
"Quadro M1200",
"Quadro M2000",
"Quadro M2200",
"Quadro M3000",
"Quadro M4000",
"Quadro M5000",
"Quadro M5500",
"Quadro M6000",
"GeForce MX110",
"GeForce MX130",
"GeForce 830M",
"GeForce 840M",
"GeForce GTX 850M",
"GeForce GTX 860M",
"GeForce GTX 1650",
"GeForce GTX 1630",
"Tesla M4",
"Tesla M6",
"Tesla M10",
"Tesla M40",
"Tesla M60",
}
NVIDIA_GPU_KEYWORD = ["NVIDIA", "GeForce", "Tesla", "Quadro"]
def cuda_malloc_supported() -> bool:
"""检查是否有支持 CUDA Malloc 的 GPU
Returns:
bool: 有支持 CUDA Malloc 的 GPU 时返回 True
"""
try:
names = get_gpu_names()
except Exception as _:
names = set()
for x in names:
if any(keyword in x for keyword in NVIDIA_GPU_KEYWORD):
for b in GPU_BLACKLIST:
if b in x:
return False
return True
def is_nvidia_device():
"""检查 GPU 是否为 Nvidia 的 GPU
Returns:
bool: 当 GPU 为 Nvidia 的 GPU 时返回 True
"""
try:
names = get_gpu_names()
except Exception as _:
names = set()
for x in names:
if any(keyword in x for keyword in NVIDIA_GPU_KEYWORD):
return True
return False
def get_pytorch_cuda_alloc_conf(is_cuda: bool | None = True) -> str | None:
"""获取用于配置 PYTORCH_CUDA_ALLOC_CONF / PYTORCH_ALLOC_CONF 环境变量的配置
Args:
is_cuda (bool | None): 是否为 CUDA 设备
Returns:
(str | None): CUDA Malloc 配置
"""
if is_nvidia_device():
if cuda_malloc_supported():
if is_cuda:
return "cuda_malloc"
else:
return "pytorch_malloc"
else:
return "pytorch_malloc"
else:
return None
def set_cuda_malloc() -> None:
"""配置 CUDA Malloc 内存优化, 通过 PYTORCH_CUDA_ALLOC_CONF / PYTORCH_ALLOC_CONF 环境变量进行配置"""
try:
version = ""
torch_spec = importlib.util.find_spec("torch")
for folder in torch_spec.submodule_search_locations:
ver_file = os.path.join(folder, "version.py")
if os.path.isfile(ver_file):
spec = importlib.util.spec_from_file_location("torch_version_import", ver_file)
module = importlib.util.module_from_spec(spec)
spec.loader.exec_module(module)
version = module.__version__
if int(version[0]) >= 2: # enable by default for torch version 2.0 and up
if "+cu" in version: # only on cuda torch
malloc_type = get_pytorch_cuda_alloc_conf()
else:
malloc_type = get_pytorch_cuda_alloc_conf(False)
else:
malloc_type = None
except Exception as _:
malloc_type = None
if malloc_type == "cuda_malloc":
logger.info("设置 CUDA 内存分配器为 CUDA 内置异步分配器")
os.environ["PYTORCH_CUDA_ALLOC_CONF"] = "backend:cudaMallocAsync" # PyTorch 将弃用该参数
os.environ["PYTORCH_ALLOC_CONF"] = "backend:cudaMallocAsync"
elif malloc_type == "pytorch_malloc":
logger.info("设置 CUDA 内存分配器为 PyTorch 原生分配器")
os.environ["PYTORCH_CUDA_ALLOC_CONF"] = ( # PyTorch 将弃用该参数
"garbage_collection_threshold:0.9,max_split_size_mb:512"
)
os.environ["PYTORCH_ALLOC_CONF"] = "garbage_collection_threshold:0.9,max_split_size_mb:512"
else:
logger.warning("显卡非 Nvidia 显卡, 无法设置 CUDA 内存分配器")
|
2301_81996401/sd-webui-all-in-one
|
sd_webui_all_in_one/optimize/cuda_malloc.py
|
Python
|
agpl-3.0
| 5,837
|
"""TC Malloc 内存优化配置工具"""
import os
import re
import subprocess
from pathlib import Path
from sd_webui_all_in_one.logger import get_logger
from sd_webui_all_in_one.downloader import download_file
from sd_webui_all_in_one.colab_tools import is_colab_environment
from sd_webui_all_in_one.config import LOGGER_LEVEL, LOGGER_COLOR
from sd_webui_all_in_one.package_analyzer.ver_cmp import CommonVersionComparison
logger = get_logger(
name="TC Malloc",
level=LOGGER_LEVEL,
color=LOGGER_COLOR,
)
class TCMalloc:
"""TCMalloc 配置工具
Attributes:
workspace (str | Path): 工作区路径
tcmalloc_has_configure (bool): TCMalloc 配置状态
"""
def __init__(self, workspace: str | Path) -> None:
"""TCMalloc 配置工具初始化
Args:
workspace (str | Path): 工作区路径
"""
self.workspace = Path(workspace)
self.tcmalloc_has_configure = False
def configure_tcmalloc_common(self) -> bool:
"""使用 TCMalloc 优化内存的占用, 通过 LD_PRELOAD 环境变量指定 TCMalloc
Args:
bool: 配置成功时返回`True`
"""
# 检查 glibc 版本
try:
result = subprocess.run(["ldd", "--version"], capture_output=True, text=True)
libc_ver_line = result.stdout.split("\n")[0]
libc_ver = re.search(r"(\d+\.\d+)", libc_ver_line)
if libc_ver:
libc_ver = libc_ver.group(1)
logger.info("glibc 版本: %s", libc_ver)
else:
logger.error("无法确定 glibc 版本")
return False
except Exception as e:
logger.error("检查 glibc 版本时出错: %s", e)
return False
# 从 2.34 开始, libpthread 已经集成到 libc.so 中
libc_v234 = "2.34"
# 定义 Tcmalloc 库数组
tcmalloc_libs = [r"libtcmalloc(_minimal|)\.so\.\d+", r"libtcmalloc\.so\.\d+"]
# 遍历数组
for lib_pattern in tcmalloc_libs:
try:
# 获取系统库缓存信息
result = subprocess.run(
["ldconfig", "-p"],
capture_output=True,
text=True,
env=dict(os.environ, PATH="/usr/sbin:" + os.getenv("PATH")),
)
libraries = result.stdout.split("\n")
# 查找匹配的 TCMalloc 库
for lib in libraries:
if re.search(lib_pattern, lib):
# 解析库信息
match = re.search(r"(.+?)\s+=>\s+(.+)", lib)
if match:
lib_name, lib_path = (
match.group(1).strip(),
match.group(2).strip(),
)
logger.info("检查 TCMalloc: %s => %s", lib_name, lib_path)
# 确定库是否链接到 libpthread 和解析未定义符号: pthread_key_create
if CommonVersionComparison(libc_ver) < CommonVersionComparison(libc_v234):
# glibc < 2.34, pthread_key_create 在 libpthread.so 中。检查链接到 libpthread.so
ldd_result = subprocess.run(["ldd", lib_path], capture_output=True, text=True)
if "libpthread" in ldd_result.stdout:
logger.info(
"%s 链接到 libpthread, 执行 LD_PRELOAD=%s",
lib_name,
lib_path,
)
# 设置完整路径 LD_PRELOAD
if "LD_PRELOAD" in os.environ and os.environ["LD_PRELOAD"]:
os.environ["LD_PRELOAD"] = os.environ["LD_PRELOAD"] + ":" + lib_path
else:
os.environ["LD_PRELOAD"] = lib_path
return True
else:
logger.info(
"%s 没有链接到 libpthread, 将触发未定义符号: pthread_Key_create 错误",
lib_name,
)
else:
# libc.so (glibc) 的 2.34 版本已将 pthread 库集成到 glibc 内部
logger.info(
"%s 链接到 libc.so, 执行 LD_PRELOAD=%s",
lib_name,
lib_path,
)
# 设置完整路径 LD_PRELOAD
if "LD_PRELOAD" in os.environ and os.environ["LD_PRELOAD"]:
os.environ["LD_PRELOAD"] = os.environ["LD_PRELOAD"] + ":" + lib_path
else:
os.environ["LD_PRELOAD"] = lib_path
return True
except Exception as e:
logger.error("检查 TCMalloc 库时出错: %s", e)
continue
if "LD_PRELOAD" not in os.environ:
logger.warning("无法定位 TCMalloc。未在系统上找到 tcmalloc 或 google-perftool, 取消加载内存优化")
return False
def configure_tcmalloc_colab(self) -> bool:
"""配置 TCMalloc (Colab)
Returns:
bool: TCMalloc (Colab) 配置结果
"""
logger.info("配置 TCMalloc 内存优化")
url = "https://github.com/licyk/sd-webui-all-in-one/raw/main/config/libtcmalloc_minimal.so.4"
libtcmalloc_path = self.workspace / "libtcmalloc_minimal.so.4"
status = download_file(url=url, path=self.workspace, save_name="libtcmalloc_minimal.so.4")
if status is None:
logger.error("下载 TCMalloc 库失败, 无法配置 TCMalloc")
return False
if "LD_PRELOAD" in os.environ and os.environ["LD_PRELOAD"]:
os.environ["LD_PRELOAD"] = os.environ["LD_PRELOAD"] + ":" + libtcmalloc_path.as_posix()
else:
os.environ["LD_PRELOAD"] = libtcmalloc_path.as_posix()
return True
def configure_tcmalloc(self) -> bool:
"""配置 TCMalloc
Returns:
bool: TCMalloc 配置结果
"""
if self.tcmalloc_has_configure:
logger.info("TCMalloc 内存优化已配置")
return True
if is_colab_environment():
status = self.configure_tcmalloc_colab()
else:
status = self.configure_tcmalloc_common()
if not status:
logger.error("配置 TCMalloc 内存优化失败")
return False
logger.info("TCMalloc 内存优化配置完成")
self.tcmalloc_has_configure = True
return True
|
2301_81996401/sd-webui-all-in-one
|
sd_webui_all_in_one/optimize/tcmalloc.py
|
Python
|
agpl-3.0
| 7,212
|
"""Python 软件包检查工具"""
import os
import re
import importlib.metadata
from typing import Any
from pathlib import Path
from sd_webui_all_in_one.logger import get_logger
from sd_webui_all_in_one.config import LOGGER_LEVEL, LOGGER_COLOR
from sd_webui_all_in_one.package_analyzer.py_ver_cmp import PyWhlVersionComparison
from sd_webui_all_in_one.package_analyzer.py_whl_parse import ParsedPyWhlRequirement, RequirementParser, get_parse_bindings
logger = get_logger(
name="PyPkgCheck",
level=LOGGER_LEVEL,
color=LOGGER_COLOR,
)
def version_string_is_canonical(version: str) -> bool:
"""判断版本号标识符是否符合标准
Args:
version (str): 版本号字符串
Returns:
bool: 如果版本号标识符符合 PEP 440 标准, 则返回`True`
"""
return (
re.match(
r"^([1-9][0-9]*!)?(0|[1-9][0-9]*)(\.(0|[1-9][0-9]*))*((a|b|rc)(0|[1-9][0-9]*))?(\.post(0|[1-9][0-9]*))?(\.dev(0|[1-9][0-9]*))?$",
version,
)
is not None
)
def is_package_has_version(package: str) -> bool:
"""检查 Python 软件包是否指定版本号
Args:
package (str): Python 软件包名
Returns:
bool: 如果 Python 软件包存在版本声明, 如`torch==2.3.0`, 则返回`True`
"""
return package != (package.replace("===", "").replace("~=", "").replace("!=", "").replace("<=", "").replace(">=", "").replace("<", "").replace(">", "").replace("==", ""))
def get_package_name(package: str) -> str:
"""获取 Python 软件包的包名, 去除末尾的版本声明
Args:
package (str): Python 软件包名
Returns:
str: 返回去除版本声明后的 Python 软件包名
"""
return package.split("===")[0].split("~=")[0].split("!=")[0].split("<=")[0].split(">=")[0].split("<")[0].split(">")[0].split("==")[0].strip()
def get_package_version(package: str) -> str:
"""获取 Python 软件包的包版本号
Args:
package (str): Python 软件包名
返回值:
str: 返回 Python 软件包的包版本号
"""
return package.split("===").pop().split("~=").pop().split("!=").pop().split("<=").pop().split(">=").pop().split("<").pop().split(">").pop().split("==").pop().strip()
WHEEL_PATTERN = r"""
^ # 字符串开始
(?P<distribution>[^-]+) # 包名 (匹配第一个非连字符段)
- # 分隔符
(?: # 版本号和可选构建号组合
(?P<version>[^-]+) # 版本号 (至少一个非连字符段)
(?:-(?P<build>\d\w*))? # 可选构建号 (以数字开头)
)
- # 分隔符
(?P<python>[^-]+) # Python 版本标签
- # 分隔符
(?P<abi>[^-]+) # ABI 标签
- # 分隔符
(?P<platform>[^-]+) # 平台标签
\.whl$ # 固定后缀
"""
"""解析 Python Wheel 名的的正则表达式"""
REPLACE_PACKAGE_NAME_DICT = {
"sam2": "SAM-2",
}
"""Python 软件包名替换表"""
def parse_wheel_filename(filename: str) -> str:
"""解析 Python wheel 文件名并返回 distribution 名称
Args:
filename (str): wheel 文件名, 例如 pydantic-1.10.15-py3-none-any.whl
Returns:
str: distribution 名称, 例如 pydantic
Raises:
ValueError: 如果文件名不符合 PEP491 规范
"""
match = re.fullmatch(WHEEL_PATTERN, filename, re.VERBOSE)
if not match:
logger.debug("未知的 Wheel 文件名: %s", filename)
raise ValueError(f"未知的 Wheel 文件名: {filename}")
return match.group("distribution")
def parse_wheel_version(filename: str) -> str:
"""解析 Python wheel 文件名并返回 version 名称
Args:
filename (str): wheel 文件名, 例如 pydantic-1.10.15-py3-none-any.whl
Returns:
str: version 名称, 例如 1.10.15
Raises:
ValueError: 如果文件名不符合 PEP491 规范
"""
match = re.fullmatch(WHEEL_PATTERN, filename, re.VERBOSE)
if not match:
logger.debug("未知的 Wheel 文件名: %s", filename)
raise ValueError(f"未知的 Wheel 文件名: {filename}")
return match.group("version")
def parse_wheel_to_package_name(filename: str) -> str:
"""解析 Python wheel 文件名并返回 <distribution>==<version>
Args:
filename (str): wheel 文件名, 例如 pydantic-1.10.15-py3-none-any.whl
Returns:
str: <distribution>==<version> 名称, 例如 pydantic==1.10.15
"""
distribution = parse_wheel_filename(filename)
version = parse_wheel_version(filename)
return f"{distribution}=={version}"
def remove_optional_dependence_from_package(filename: str) -> str:
"""移除 Python 软件包声明中可选依赖
Args:
filename (str): Python 软件包名
Returns:
str: 移除可选依赖后的软件包名, e.g. diffusers[torch]==0.10.2 -> diffusers==0.10.2
"""
return re.sub(r"\[.*?\]", "", filename)
def get_correct_package_name(name: str) -> str:
"""将原 Python 软件包名替换成正确的 Python 软件包名
Args:
name (str): 原 Python 软件包名
Returns:
str: 替换成正确的软件包名, 如果原有包名正确则返回原包名
"""
return REPLACE_PACKAGE_NAME_DICT.get(name, name)
def parse_requirement(
text: str,
bindings: dict[str, str],
) -> ParsedPyWhlRequirement:
"""解析依赖声明的主函数
Args:
text (str): 依赖声明文本
bindings (dict[str, str]): 解析 Python 软件包名的语法字典
Returns:
ParsedPyWhlRequirement: 解析结果元组
"""
parser = RequirementParser(text, bindings)
return parser.parse()
def evaluate_marker(marker: Any) -> bool:
"""评估 marker 表达式, 判断当前环境是否符合要求
Args:
marker (Any): marker 表达式
Returns:
bool: 评估结果
"""
if marker is None:
return True
if isinstance(marker, tuple):
op = marker[0]
if op in ("and", "or"):
left = evaluate_marker(marker[1])
right = evaluate_marker(marker[2])
if op == "and":
return left and right
else: # 'or'
return left or right
else:
# 处理比较操作
left = marker[1]
right = marker[2]
if op in ["<", "<=", ">", ">=", "==", "!=", "~=", "==="]:
try:
left_ver = PyWhlVersionComparison(str(left).lower())
right_ver = PyWhlVersionComparison(str(right).lower())
if op == "<":
return left_ver < right_ver
elif op == "<=":
return left_ver <= right_ver
elif op == ">":
return left_ver > right_ver
elif op == ">=":
return left_ver >= right_ver
elif op == "==":
return left_ver == right_ver
elif op == "!=":
return left_ver != right_ver
elif op == "~=":
return left_ver >= ~right_ver
elif op == "===":
# 任意相等, 直接比较字符串
return str(left).lower() == str(right).lower()
except Exception:
# 如果版本比较失败, 回退到字符串比较
left_str = str(left).lower()
right_str = str(right).lower()
if op == "<":
return left_str < right_str
elif op == "<=":
return left_str <= right_str
elif op == ">":
return left_str > right_str
elif op == ">=":
return left_str >= right_str
elif op == "==":
return left_str == right_str
elif op == "!=":
return left_str != right_str
elif op == "~=":
# 简化处理
return left_str >= right_str
elif op == "===":
return left_str == right_str
# 处理 in 和 not in 操作
elif op == "in":
# 将右边按逗号分割, 检查左边是否在其中
values = [v.strip() for v in str(right).lower().split(",")]
return str(left).lower() in values
elif op == "not in":
# 将右边按逗号分割, 检查左边是否不在其中
values = [v.strip() for v in str(right).lower().split(",")]
return str(left).lower() not in values
return False
def parse_requirement_to_list(text: str) -> list[str]:
"""解析依赖声明并返回依赖列表
Args:
text (str): 依赖声明
Returns:
list[str]: 解析后的依赖声明表
"""
try:
bindings = get_parse_bindings()
name, _, version_specs, marker = parse_requirement(text, bindings)
except Exception as e:
logger.debug("解析失败: %s", e)
return []
# 检查marker条件
if not evaluate_marker(marker):
return []
# 构建依赖列表
dependencies = []
# 如果是 URL 依赖
if isinstance(version_specs, str):
# URL 依赖只返回包名
dependencies.append(name)
else:
# 版本依赖
if version_specs:
# 有版本约束, 为每个约束创建一个依赖项
for op, version in version_specs:
dependencies.append(f"{name}{op}{version}")
else:
# 没有版本约束, 只返回包名
dependencies.append(name)
return dependencies
def parse_requirement_list(requirements: list[str]) -> list[str]:
"""将 Python 软件包声明列表解析成标准 Python 软件包名列表
例如有以下的 Python 软件包声明列表:
```python
requirements = [
'torch==2.3.0',
'diffusers[torch]==0.10.2',
'NUMPY',
'-e .',
'--index-url https://pypi.python.org/simple',
'--extra-index-url https://download.pytorch.org/whl/cu124',
'--find-links https://download.pytorch.org/whl/torch_stable.html',
'-e git+https://github.com/Nerogar/mgds.git@2c67a5a#egg=mgds',
'git+https://github.com/WASasquatch/img2texture.git',
'https://github.com/Panchovix/pydantic-fixreforge/releases/download/main_v1/pydantic-1.10.15-py3-none-any.whl',
'prodigy-plus-schedule-free==1.9.1 # prodigy+schedulefree optimizer',
'protobuf<5,>=4.25.3',
]
```
上述例子中的软件包名声明列表将解析成:
```python
requirements = [
'torch==2.3.0',
'diffusers==0.10.2',
'numpy',
'mgds',
'img2texture',
'pydantic==1.10.15',
'prodigy-plus-schedule-free==1.9.1',
'protobuf<5',
'protobuf>=4.25.3',
]
```
Args:
requirements (list[str]): Python 软件包名声明列表
Returns:
list[str]: 将 Python 软件包名声明列表解析成标准声明列表
"""
def _extract_repo_name(url_string: str) -> str | None:
"""从包含 Git 仓库 URL 的字符串中提取仓库名称
Args:
url_string (str): 包含 Git 仓库 URL 的字符串
Returns:
(str | None): 提取到的仓库名称, 如果未找到则返回 None
"""
# 模式1: 匹配 git+https:// 或 git+ssh:// 开头的 URL
# 模式2: 匹配直接以 git+ 开头的 URL
patterns = [
# 匹配 git+protocol://host/path/to/repo.git 格式
r"git\+[a-z]+://[^/]+/(?:[^/]+/)*([^/@]+?)(?:\.git)?(?:@|$)",
# 匹配 git+https://host/owner/repo.git 格式
r"git\+https://[^/]+/[^/]+/([^/@]+?)(?:\.git)?(?:@|$)",
# 匹配 git+ssh://git@host:owner/repo.git 格式
r"git\+ssh://git@[^:]+:[^/]+/([^/@]+?)(?:\.git)?(?:@|$)",
# 通用模式: 匹配最后一个斜杠后的内容, 直到遇到 @ 或 .git 或字符串结束
r"/([^/@]+?)(?:\.git)?(?:@|$)",
]
for pattern in patterns:
match = re.search(pattern, url_string)
if match:
return match.group(1)
return None
package_list: list[str] = []
canonical_package_list: list[str] = []
for requirement in requirements:
# 清理注释内容
# prodigy-plus-schedule-free==1.9.1 # prodigy+schedulefree optimizer -> prodigy-plus-schedule-free==1.9.1
requirement = re.sub(r"\s*#.*$", "", requirement).strip()
logger.debug("原始 Python 软件包名: %s", requirement)
if (
requirement is None
or requirement == ""
or requirement.startswith("#")
or "# skip_verify" in requirement
or requirement.startswith("--index-url")
or requirement.startswith("--extra-index-url")
or requirement.startswith("--find-links")
or requirement.startswith("-e .")
or requirement.startswith("-r ")
):
continue
# -e git+https://github.com/Nerogar/mgds.git@2c67a5a#egg=mgds -> mgds
# git+https://github.com/WASasquatch/img2texture.git -> img2texture
# git+https://github.com/deepghs/waifuc -> waifuc
# -e git+https://github.com/Nerogar/mgds.git@2c67a5a -> mgds
# git+ssh://git@github.com:licyk/sd-webui-all-in-one@dev -> sd-webui-all-in-one
# git+https://gitlab.com/user/my-project.git@main -> my-project
# git+ssh://git@bitbucket.org:team/repo-name.git@develop -> repo-name
# https://github.com/another/repo.git -> repo
# git@github.com:user/repository.git -> repository
if requirement.startswith("-e git+http") or requirement.startswith("git+http") or requirement.startswith("-e git+ssh://") or requirement.startswith("git+ssh://"):
egg_match = re.search(r"egg=([^#&]+)", requirement)
if egg_match:
package_list.append(egg_match.group(1).split("-")[0])
continue
repo_name_match = _extract_repo_name(requirement)
if repo_name_match is not None:
package_list.append(repo_name_match)
continue
package_name = os.path.basename(requirement)
package_name = package_name.split(".git")[0] if package_name.endswith(".git") else package_name
package_list.append(package_name)
continue
# https://github.com/Panchovix/pydantic-fixreforge/releases/download/main_v1/pydantic-1.10.15-py3-none-any.whl -> pydantic==1.10.15
if requirement.startswith("https://") or requirement.startswith("http://"):
package_name = parse_wheel_to_package_name(os.path.basename(requirement))
package_list.append(package_name)
continue
# 常规 Python 软件包声明
# 解析版本列表
possble_requirement = parse_requirement_to_list(requirement)
if len(possble_requirement) == 0:
continue
elif len(possble_requirement) == 1:
requirement = possble_requirement[0]
else:
requirements_list = parse_requirement_list(possble_requirement)
package_list += requirements_list
continue
multi_requirements = requirement.split(",")
if len(multi_requirements) > 1:
package_name = get_package_name(multi_requirements[0].strip())
for package_name_with_version_marked in multi_requirements:
version_symbol = str.replace(package_name_with_version_marked, package_name, "", 1)
format_package_name = remove_optional_dependence_from_package(f"{package_name}{version_symbol}".strip())
package_list.append(format_package_name)
else:
format_package_name = remove_optional_dependence_from_package(multi_requirements[0].strip())
package_list.append(format_package_name)
# 处理包名大小写并统一成小写
for p in package_list:
p = p.lower().strip()
logger.debug("预处理后的 Python 软件包名: %s", p)
if not is_package_has_version(p):
logger.debug("%s 无版本声明", p)
new_p = get_correct_package_name(p)
logger.debug("包名处理: %s -> %s", p, new_p)
canonical_package_list.append(new_p)
continue
if version_string_is_canonical(get_package_version(p)):
canonical_package_list.append(p)
else:
logger.debug("%s 软件包名的版本不符合标准", p)
return canonical_package_list
def read_packages_from_requirements_file(file_path: str | Path) -> list[str]:
"""从 requirements.txt 文件中读取 Python 软件包版本声明列表
Args:
file_path (str | Path): requirements.txt 文件路径
Returns:
list[str]: 从 requirements.txt 文件中读取的 Python 软件包声明列表
"""
try:
with open(file_path, "r", encoding="utf-8") as f:
return f.readlines()
except Exception as e:
logger.debug("打开 %s 时出现错误: %s\n请检查文件是否出现损坏", file_path, e)
return []
def get_package_version_from_library(package_name: str) -> str | None:
"""获取已安装的 Python 软件包版本号
Args:
package_name (str): Python 软件包名
Returns:
(str | None): 如果获取到 Python 软件包版本号则返回版本号字符串, 否则返回`None`
"""
try:
ver = importlib.metadata.version(package_name)
except Exception as _:
ver = None
if ver is None:
try:
ver = importlib.metadata.version(package_name.lower())
except Exception as _:
ver = None
if ver is None:
try:
ver = importlib.metadata.version(package_name.replace("_", "-"))
except Exception as _:
ver = None
return ver
def is_package_installed(package: str) -> bool:
"""判断 Python 软件包是否已安装在环境中
Args:
package (str): Python 软件包名
Returns:
bool: 如果 Python 软件包未安装或者未安装正确的版本, 则返回`False`
"""
# 分割 Python 软件包名和版本号
if "===" in package:
pkg_name, pkg_version = [x.strip() for x in package.split("===")]
elif "~=" in package:
pkg_name, pkg_version = [x.strip() for x in package.split("~=")]
elif "!=" in package:
pkg_name, pkg_version = [x.strip() for x in package.split("!=")]
elif "<=" in package:
pkg_name, pkg_version = [x.strip() for x in package.split("<=")]
elif ">=" in package:
pkg_name, pkg_version = [x.strip() for x in package.split(">=")]
elif "<" in package:
pkg_name, pkg_version = [x.strip() for x in package.split("<")]
elif ">" in package:
pkg_name, pkg_version = [x.strip() for x in package.split(">")]
elif "==" in package:
pkg_name, pkg_version = [x.strip() for x in package.split("==")]
else:
pkg_name, pkg_version = package.strip(), None
env_pkg_version = get_package_version_from_library(pkg_name)
logger.debug(
"已安装 Python 软件包检测: pkg_name: %s, env_pkg_version: %s, pkg_version: %s",
pkg_name,
env_pkg_version,
pkg_version,
)
if env_pkg_version is None:
return False
if pkg_version is not None:
# ok = env_pkg_version === / == pkg_version
if "===" in package or "==" in package:
logger.debug("包含条件: === / ==")
logger.debug("%s == %s ?", env_pkg_version, pkg_version)
if PyWhlVersionComparison(env_pkg_version) == PyWhlVersionComparison(pkg_version):
logger.debug("%s == %s 条件成立", env_pkg_version, pkg_version)
return True
# ok = env_pkg_version ~= pkg_version
if "~=" in package:
logger.debug("包含条件: ~=")
logger.debug("%s ~= %s ?", env_pkg_version, pkg_version)
if PyWhlVersionComparison(env_pkg_version) == ~PyWhlVersionComparison(pkg_version):
logger.debug("%s == %s 条件成立", env_pkg_version, pkg_version)
return True
# ok = env_pkg_version != pkg_version
if "!=" in package:
logger.debug("包含条件: !=")
logger.debug("%s != %s ?", env_pkg_version, pkg_version)
if PyWhlVersionComparison(env_pkg_version) != PyWhlVersionComparison(pkg_version):
logger.debug("%s != %s 条件成立", env_pkg_version, pkg_version)
return True
# ok = env_pkg_version <= pkg_version
if "<=" in package:
logger.debug("包含条件: <=")
logger.debug("%s <= %s ?", env_pkg_version, pkg_version)
if PyWhlVersionComparison(env_pkg_version) <= PyWhlVersionComparison(pkg_version):
logger.debug("%s <= %s 条件成立", env_pkg_version, pkg_version)
return True
# ok = env_pkg_version >= pkg_version
if ">=" in package:
logger.debug("包含条件: >=")
logger.debug("%s >= %s ?", env_pkg_version, pkg_version)
if PyWhlVersionComparison(env_pkg_version) >= PyWhlVersionComparison(pkg_version):
logger.debug("%s >= %s 条件成立", env_pkg_version, pkg_version)
return True
# ok = env_pkg_version < pkg_version
if "<" in package:
logger.debug("包含条件: <")
logger.debug("%s < %s ?", env_pkg_version, pkg_version)
if PyWhlVersionComparison(env_pkg_version) < PyWhlVersionComparison(pkg_version):
logger.debug("%s < %s 条件成立", env_pkg_version, pkg_version)
return True
# ok = env_pkg_version > pkg_version
if ">" in package:
logger.debug("包含条件: >")
logger.debug("%s > %s ?", env_pkg_version, pkg_version)
if PyWhlVersionComparison(env_pkg_version) > PyWhlVersionComparison(pkg_version):
logger.debug("%s > %s 条件成立", env_pkg_version, pkg_version)
return True
logger.debug("%s 需要安装", package)
return False
return True
def validate_requirements(requirement_path: str | Path) -> bool:
"""检测环境依赖是否完整
Args:
requirement_path (str | Path): 依赖文件路径
Returns:
bool: 如果有缺失依赖则返回`False`
"""
origin_requires = read_packages_from_requirements_file(requirement_path)
requires = parse_requirement_list(origin_requires)
for package in requires:
if not is_package_installed(package):
return False
return True
|
2301_81996401/sd-webui-all-in-one
|
sd_webui_all_in_one/package_analyzer/pkg_check.py
|
Python
|
agpl-3.0
| 23,493
|
"""Python 软件包版本比较器"""
from __future__ import annotations
import re
from typing import Callable, NamedTuple
from sd_webui_all_in_one.logger import get_logger
from sd_webui_all_in_one.config import LOGGER_LEVEL, LOGGER_COLOR
logger = get_logger(
name="PyWhlCmp",
level=LOGGER_LEVEL,
color=LOGGER_COLOR,
)
class PyWhlVersionComponent(NamedTuple):
"""Python 版本号组件
参考: https://peps.python.org/pep-0440
Attributes:
epoch (int): 版本纪元号, 用于处理不兼容的重大更改, 默认为 0
release (list[int]): 发布版本号段, 主版本号的数字部分, 如 [1, 2, 3]
pre_l (str | None): 预发布标签, 包括 'a', 'b', 'rc', 'alpha' 等
pre_n (int | None): 预发布版本编号, 与预发布标签配合使用
post_n1 (int | None): 后发布版本编号, 格式如 1.0-1 中的数字
post_l (str | None): 后发布标签, 如 'post', 'rev', 'r' 等
post_n2 (int | None): 后发布版本编号, 格式如 1.0-post1 中的数字
dev_l (str | None): 开发版本标签, 通常为 'dev'
dev_n (int | None): 开发版本编号, 如 dev1 中的数字
local (str | None): 本地版本标识符, 加号后面的部分
is_wildcard (bool): 标记是否包含通配符, 用于版本范围匹配
"""
epoch: int
"""版本纪元号, 用于处理不兼容的重大更改, 默认为 0"""
release: list[int]
"""发布版本号段, 主版本号的数字部分, 如 [1, 2, 3]"""
pre_l: str | None
"""预发布标签, 包括 'a', 'b', 'rc', 'alpha' 等"""
pre_n: int | None
"""预发布版本编号, 与预发布标签配合使用"""
post_n1: int | None
"""后发布版本编号, 格式如 1.0-1 中的数字"""
post_l: str | None
"""后发布标签, 如 'post', 'rev', 'r' 等"""
post_n2: int | None
"""post_n2 (int | None): 后发布版本编号, 格式如 1.0-post1 中的数字"""
dev_l: str | None
"""开发版本标签, 通常为 'dev'"""
dev_n: int | None
"""开发版本编号, 如 dev1 中的数字"""
local: str | None
"""本地版本标识符, 加号后面的部分"""
is_wildcard: bool
"""标记是否包含通配符, 用于版本范围匹配"""
class PyWhlVersionComparison:
"""Python 版本号比较工具
使用:
```python
# 常规版本匹配
PyWhlVersionComparison("2.0.0") < PyWhlVersionComparison("2.3.0+cu118") # True
PyWhlVersionComparison("2.0") > PyWhlVersionComparison("0.9") # True
PyWhlVersionComparison("1.3") <= PyWhlVersionComparison("1.2.2") # False
# 通配符版本匹配, 需要在不包含通配符的版本对象中使用 ~ 符号
PyWhlVersionComparison("1.0*") == ~PyWhlVersionComparison("1.0a1") # True
PyWhlVersionComparison("0.9*") == ~PyWhlVersionComparison("1.0") # False
```
Attributes:
VERSION_PATTERN (str): 提去 Wheel 版本号的正则表达式
WHL_VERSION_PARSE_REGEX (re.Pattern): 编译后的用于解析 Wheel 版本号的工具
version (str): 版本号字符串
"""
def __init__(self, version: str) -> None:
"""初始化 Python 版本号比较工具
Args:
version (str): 版本号字符串
"""
self.version = version
def __lt__(self, other: object) -> bool:
"""实现 < 符号的版本比较
Args:
other (object): 用于比较的对象
Returns:
bool: 如果此版本小于另一个版本
"""
if not isinstance(other, PyWhlVersionComparison):
return NotImplemented
return self.is_v1_lt_v2(self.version, other.version)
def __gt__(self, other: object) -> bool:
"""实现 > 符号的版本比较
Args:
other (object): 用于比较的对象
Returns:
bool: 如果此版本大于另一个版本
"""
if not isinstance(other, PyWhlVersionComparison):
return NotImplemented
return self.is_v1_gt_v2(self.version, other.version)
def __le__(self, other: object) -> bool:
"""实现 <= 符号的版本比较
Args:
other (object): 用于比较的对象
Returns:
bool: 如果此版本小于等于另一个版本
"""
if not isinstance(other, PyWhlVersionComparison):
return NotImplemented
return self.is_v1_le_v2(self.version, other.version)
def __ge__(self, other: object) -> bool:
"""实现 >= 符号的版本比较
Args:
other (object): 用于比较的对象
Returns:
bool: 如果此版本大于等于另一个版本
"""
if not isinstance(other, PyWhlVersionComparison):
return NotImplemented
return self.is_v1_ge_v2(self.version, other.version)
def __eq__(self, other: object) -> bool:
"""实现 == 符号的版本比较
Args:
other (object): 用于比较的对象
Returns:
bool: 如果此版本等于另一个版本
"""
if not isinstance(other, PyWhlVersionComparison):
return NotImplemented
return self.is_v1_eq_v2(self.version, other.version)
def __ne__(self, other: object) -> bool:
"""实现 != 符号的版本比较
Args:
other (object): 用于比较的对象
Returns:
bool: 如果此版本不等于另一个版本
"""
if not isinstance(other, PyWhlVersionComparison):
return NotImplemented
return not self.is_v1_eq_v2(self.version, other.version)
def __invert__(self) -> "PyWhlVersionMatcher":
"""使用 ~ 操作符实现兼容性版本匹配 (~= 的语义)
Returns:
PyWhlVersionMatcher: 兼容性版本匹配器
"""
return PyWhlVersionMatcher(self.version)
# 提取版本标识符组件的正则表达式
# ref:
# https://peps.python.org/pep-0440
# https://packaging.python.org/en/latest/specifications/version-specifiers
VERSION_PATTERN = r"""
v?
(?:
(?:(?P<epoch>[0-9]+)!)? # epoch
(?P<release>[0-9]+(?:\.[0-9]+)*) # release segment
(?P<pre> # pre-release
[-_\.]?
(?P<pre_l>(a|b|c|rc|alpha|beta|pre|preview))
[-_\.]?
(?P<pre_n>[0-9]+)?
)?
(?P<post> # post release
(?:-(?P<post_n1>[0-9]+))
|
(?:
[-_\.]?
(?P<post_l>post|rev|r)
[-_\.]?
(?P<post_n2>[0-9]+)?
)
)?
(?P<dev> # dev release
[-_\.]?
(?P<dev_l>dev)
[-_\.]?
(?P<dev_n>[0-9]+)?
)?
)
(?:\+(?P<local>[a-z0-9]+(?:[-_\.][a-z0-9]+)*))? # local version
"""
# 编译正则表达式
WHL_VERSION_PARSE_REGEX = re.compile(
r"^\s*" + VERSION_PATTERN + r"\s*$",
re.VERBOSE | re.IGNORECASE,
)
def parse_version(self, version_str: str) -> PyWhlVersionComponent:
"""解释 Python 软件包版本号
Args:
version_str (str): Python 软件包版本号
Returns:
PyWhlVersionComponent: 版本组件的命名元组
Raises:
ValueError: 如果 Python 版本号不符合 PEP440 规范
"""
# 检测并剥离通配符
wildcard = version_str.endswith(".*") or version_str.endswith("*")
clean_str = version_str.rstrip("*").rstrip(".") if wildcard else version_str
match = self.WHL_VERSION_PARSE_REGEX.match(clean_str)
if not match:
logger.debug("未知的版本号字符串: %s", version_str)
raise ValueError(f"未知的版本号字符串: {version_str}")
components = match.groupdict()
# 处理 release 段 (允许空字符串)
release_str = components["release"] or "0"
release_segments = [int(seg) for seg in release_str.split(".")]
# 构建命名元组
return PyWhlVersionComponent(
epoch=int(components["epoch"] or 0),
release=release_segments,
pre_l=components["pre_l"],
pre_n=int(components["pre_n"]) if components["pre_n"] else None,
post_n1=int(components["post_n1"]) if components["post_n1"] else None,
post_l=components["post_l"],
post_n2=int(components["post_n2"]) if components["post_n2"] else None,
dev_l=components["dev_l"],
dev_n=int(components["dev_n"]) if components["dev_n"] else None,
local=components["local"],
is_wildcard=wildcard,
)
def compare_version_objects(self, v1: PyWhlVersionComponent, v2: PyWhlVersionComponent) -> int:
"""比较两个版本字符串 Python 软件包版本号
Args:
v1 (PyWhlVersionComponent): 第 1 个 Python 版本号标识符组件
v2 (PyWhlVersionComponent): 第 2 个 Python 版本号标识符组件
Returns:
int: 如果版本号 1 大于 版本号 2, 则返回`1`, 小于则返回`-1`, 如果相等则返回`0`
"""
# 比较 epoch
if v1.epoch != v2.epoch:
return v1.epoch - v2.epoch
# 对其 release 长度, 缺失部分补 0
if len(v1.release) != len(v2.release):
for _ in range(abs(len(v1.release) - len(v2.release))):
if len(v1.release) < len(v2.release):
v1.release.append(0)
else:
v2.release.append(0)
# 比较 release
for n1, n2 in zip(v1.release, v2.release):
if n1 != n2:
return n1 - n2
# 如果 release 长度不同, 较短的版本号视为较小 ?
# 但是这样是行不通的! 比如 0.15.0 和 0.15, 处理后就会变成 [0, 15, 0] 和 [0, 15]
# 计算结果就会变成 len([0, 15, 0]) > len([0, 15])
# 但 0.15.0 和 0.15 实际上是一样的版本
# if len(v1.release) != len(v2.release):
# return len(v1.release) - len(v2.release)
# 比较 pre-release
if v1.pre_l and not v2.pre_l:
return -1 # pre-release 小于正常版本
elif not v1.pre_l and v2.pre_l:
return 1
elif v1.pre_l and v2.pre_l:
pre_order = {
"a": 0,
"b": 1,
"c": 2,
"rc": 3,
"alpha": 0,
"beta": 1,
"pre": 0,
"preview": 0,
}
if pre_order[v1.pre_l] != pre_order[v2.pre_l]:
return pre_order[v1.pre_l] - pre_order[v2.pre_l]
elif v1.pre_n is not None and v2.pre_n is not None:
return v1.pre_n - v2.pre_n
elif v1.pre_n is None and v2.pre_n is not None:
return -1
elif v1.pre_n is not None and v2.pre_n is None:
return 1
# 比较 post-release
if v1.post_n1 is not None:
post_n1 = v1.post_n1
elif v1.post_l:
post_n1 = int(v1.post_n2) if v1.post_n2 else 0
else:
post_n1 = 0
if v2.post_n1 is not None:
post_n2 = v2.post_n1
elif v2.post_l:
post_n2 = int(v2.post_n2) if v2.post_n2 else 0
else:
post_n2 = 0
if post_n1 != post_n2:
return post_n1 - post_n2
# 比较 dev-release
if v1.dev_l and not v2.dev_l:
return -1 # dev-release 小于 post-release 或正常版本
elif not v1.dev_l and v2.dev_l:
return 1
elif v1.dev_l and v2.dev_l:
if v1.dev_n is not None and v2.dev_n is not None:
return v1.dev_n - v2.dev_n
elif v1.dev_n is None and v2.dev_n is not None:
return -1
elif v1.dev_n is not None and v2.dev_n is None:
return 1
# 比较 local version
if v1.local and not v2.local:
return -1 # local version 小于 dev-release 或正常版本
elif not v1.local and v2.local:
return 1
elif v1.local and v2.local:
local1 = v1.local.split(".")
local2 = v2.local.split(".")
# 和 release 的处理方式一致, 对其 local version 长度, 缺失部分补 0
if len(local1) != len(local2):
for _ in range(abs(len(local1) - len(local2))):
if len(local1) < len(local2):
local1.append(0)
else:
local2.append(0)
for l1, l2 in zip(local1, local2):
if l1.isdigit() and l2.isdigit():
l1, l2 = int(l1), int(l2)
if l1 != l2:
return (l1 > l2) - (l1 < l2)
return len(local1) - len(local2)
return 0 # 版本相同
def compare_versions(self, version1: str, version2: str) -> int:
"""比较两个版本字符串 Python 软件包版本号
Args:
version1 (str): 版本号 1
version2 (str): 版本号 2
Returns:
int: 如果版本号 1 大于 版本号 2, 则返回`1`, 小于则返回`-1`, 如果相等则返回`0`
"""
v1 = self.parse_version(version1)
v2 = self.parse_version(version2)
return self.compare_version_objects(v1, v2)
def compatible_version_matcher(self, spec_version: str) -> Callable[[str], bool]:
"""PEP 440 兼容性版本匹配 (~= 操作符)
Returns:
(Callable[[str], bool]): 一个接受 version_str (`str`) 参数的判断函数
"""
# 解析规范版本
spec = self.parse_version(spec_version)
# 获取有效 release 段 (去除末尾的零)
clean_release = []
for num in spec.release:
if num != 0 or (clean_release and clean_release[-1] != 0):
clean_release.append(num)
# 确定最低版本和前缀匹配规则
if len(clean_release) == 0:
logger.debug("解析到错误的兼容性发行版本号")
raise ValueError("解析到错误的兼容性发行版本号")
# 生成前缀匹配模板 (忽略后缀)
prefix_length = len(clean_release) - 1
if prefix_length == 0:
# 处理类似 ~= 2 的情况 (实际 PEP 禁止, 但这里做容错)
prefix_pattern = [spec.release[0]]
min_version = self.parse_version(f"{spec.release[0]}")
else:
prefix_pattern = list(spec.release[:prefix_length])
min_version = spec
def _is_compatible(version_str: str) -> bool:
target = self.parse_version(version_str)
# 主版本前缀检查
target_prefix = target.release[: len(prefix_pattern)]
if target_prefix != prefix_pattern:
return False
# 最低版本检查 (自动忽略 pre/post/dev 后缀)
return self.compare_version_objects(target, min_version) >= 0
return _is_compatible
def version_match(self, spec: str, version: str) -> bool:
"""PEP 440 版本前缀匹配
Args:
spec (str): 版本匹配表达式 (e.g. '1.1.*')
version (str): 需要检测的实际版本号 (e.g. '1.1a1')
Returns:
bool: 是否匹配
"""
# 分离通配符和本地版本
spec_parts = spec.split("+", 1)
spec_main = spec_parts[0].rstrip(".*") # 移除通配符
has_wildcard = spec.endswith(".*") and "+" not in spec
# 解析规范版本 (不带通配符)
try:
spec_ver = self.parse_version(spec_main)
except ValueError:
return False
# 解析目标版本 (忽略本地版本)
target_ver = self.parse_version(version.split("+", 1)[0])
# 前缀匹配规则
if has_wildcard:
# 生成补零后的 release 段
spec_release = spec_ver.release.copy()
while len(spec_release) < len(target_ver.release):
spec_release.append(0)
# 比较前 N 个 release 段 (N 为规范版本长度)
return target_ver.release[: len(spec_ver.release)] == spec_ver.release and target_ver.epoch == spec_ver.epoch
else:
# 严格匹配时使用原比较函数
return self.compare_versions(spec_main, version) == 0
def is_v1_ge_v2(self, v1: str, v2: str) -> bool:
"""查看 Python 版本号 v1 是否大于或等于 v2
例如:
```
1.1, 1.0 -> True
1.0, 1.0 -> True
0.9, 1.0 -> False
```
Args:
v1 (str): 第 1 个 Python 软件包版本号
v2 (str): 第 2 个 Python 软件包版本号
Returns:
bool: 如果 v1 版本号大于或等于 v2 版本号则返回`True`
"""
return self.compare_versions(v1, v2) >= 0
def is_v1_gt_v2(self, v1: str, v2: str) -> bool:
"""查看 Python 版本号 v1 是否大于 v2
例如:
```
1.1, 1.0 -> True
1.0, 1.0 -> False
```
Args:
v1 (str): 第 1 个 Python 软件包版本号
v2 (str): 第 2 个 Python 软件包版本号
Returns:
bool: 如果 v1 版本号大于 v2 版本号则返回`True`
"""
return self.compare_versions(v1, v2) > 0
def is_v1_eq_v2(self, v1: str, v2: str) -> bool:
"""查看 Python 版本号 v1 是否等于 v2
例如:
```
1.0, 1.0 -> True
0.9, 1.0 -> False
1.1, 1.0 -> False
```
Args:
v1 (str): 第 1 个 Python 软件包版本号
v2 (str): 第 2 个 Python 软件包版本号
Returns:
`bool`: 如果 v1 版本号等于 v2 版本号则返回`True`
"""
return self.compare_versions(v1, v2) == 0
def is_v1_lt_v2(self, v1: str, v2: str) -> bool:
"""查看 Python 版本号 v1 是否小于 v2
例如:
```
0.9, 1.0 -> True
1.0, 1.0 -> False
```
Args:
v1 (str): 第 1 个 Python 软件包版本号
v2 (str): 第 2 个 Python 软件包版本号
Returns:
bool: 如果 v1 版本号小于 v2 版本号则返回`True`
"""
return self.compare_versions(v1, v2) < 0
def is_v1_le_v2(self, v1: str, v2: str) -> bool:
"""查看 Python 版本号 v1 是否小于或等于 v2
例如:
```
0.9, 1.0 -> True
1.0, 1.0 -> True
1.1, 1.0 -> False
```
Args:
v1 (str): 第 1 个 Python 软件包版本号
v2 (str): 第 2 个 Python 软件包版本号
Returns:
bool: 如果 v1 版本号小于或等于 v2 版本号则返回`True`
"""
return self.compare_versions(v1, v2) <= 0
def is_v1_c_eq_v2(self, v1: str, v2: str) -> bool:
"""查看 Python 版本号 v1 是否大于等于 v2, (兼容性版本匹配)
例如:
```
1.0*, 1.0a1 -> True
0.9*, 1.0 -> False
```
Args:
v1 (str): 第 1 个 Python 软件包版本号, 该版本由 ~= 符号指定
v2 (str): 第 2 个 Python 软件包版本号
Returns:
bool: 如果 v1 版本号等于 v2 版本号则返回`True`
"""
func = self.compatible_version_matcher(v1)
return func(v2)
class PyWhlVersionMatcher:
"""Python 兼容性版本匹配器, 用于实现 ~= 操作符的语义
Attributes:
spec_version (str): 版本号
comparison (PyWhlVersionComparison): Python 版本号比较工具
_matcher_func (Callable[[str], bool]): 兼容性版本匹配函数
"""
def __init__(self, spec_version: str) -> None:
"""初始化 Python 兼容性版本匹配器
Args:
spec_version (str): 版本号
"""
self.spec_version = spec_version
self.comparison = PyWhlVersionComparison(spec_version)
self._matcher_func = self.comparison.compatible_version_matcher(spec_version)
def __eq__(self, other: object) -> bool:
"""实现 ~version == other_version 的语义
Args:
other (object): 用于比较的对象
Returns:
bool: 如果此版本不等于另一个版本
"""
if isinstance(other, str):
return self._matcher_func(other)
elif isinstance(other, PyWhlVersionComparison):
return self._matcher_func(other.version)
elif isinstance(other, PyWhlVersionMatcher):
# 允许 ~v1 == ~v2 的比较 (比较规范版本)
return self.spec_version == other.spec_version
return NotImplemented
def __repr__(self) -> str:
return f"~{self.spec_version}"
|
2301_81996401/sd-webui-all-in-one
|
sd_webui_all_in_one/package_analyzer/py_ver_cmp.py
|
Python
|
agpl-3.0
| 21,453
|
"""Python 软件包名称解析器"""
import os
import sys
import platform
from typing import Any, NamedTuple
class ParsedPyWhlRequirement(NamedTuple):
"""解析后的依赖声明信息
参考: https://peps.python.org/pep-0508
"""
name: str
"""软件包名称"""
extras: list[str]
"""extras 列表，例如 ['fred', 'bar']"""
specifier: list[tuple[str, str]] | str
"""版本约束列表或 URL 地址
如果是版本依赖，则为版本约束列表，例如 [('>=', '1.0'), ('<', '2.0')]
如果是 URL 依赖，则为 URL 字符串，例如 'http://example.com/package.tar.gz'
"""
marker: Any
"""环境标记表达式，用于条件依赖"""
class Parser:
"""语法解析器
Attributes:
text (str): 待解析的字符串
pos (int): 字符起始位置
len (int): 字符串长度
"""
def __init__(self, text: str) -> None:
"""初始化解析器
Args:
text (str): 要解析的文本
"""
self.text = text
self.pos = 0
self.len = len(text)
def peek(self) -> str:
"""查看当前位置的字符但不移动指针
Returns:
str: 当前位置的字符，如果到达末尾则返回空字符串
"""
if self.pos < self.len:
return self.text[self.pos]
return ""
def consume(self, expected: str | None = None) -> str:
"""消耗当前字符并移动指针
Args:
expected (str | None): 期望的字符，如果提供但不匹配会抛出异常
Returns:
str: 实际消耗的字符
Raises:
ValueError: 当字符不匹配或到达文本末尾时
"""
if self.pos >= self.len:
raise ValueError(f"不期望的输入内容结尾, 期望: {expected}")
char = self.text[self.pos]
if expected and char != expected:
raise ValueError(f"期望 '{expected}', 得到 '{char}' 在位置 {self.pos}")
self.pos += 1
return char
def skip_whitespace(self):
"""跳过空白字符（空格和制表符）"""
while self.pos < self.len and self.text[self.pos] in " \t":
self.pos += 1
def match(self, pattern: str) -> str | None:
"""尝试匹配指定模式, 成功则移动指针
Args:
pattern (str): 要匹配的模式字符串
Returns:
(str | None): 匹配成功的字符串, 否则为 None
"""
# 跳过空格再匹配
original_pos = self.pos
self.skip_whitespace()
if self.text.startswith(pattern, self.pos):
result = self.text[self.pos : self.pos + len(pattern)]
self.pos += len(pattern)
return result
# 如果没有匹配，恢复位置
self.pos = original_pos
return None
def read_while(self, condition) -> str:
"""读取满足条件的字符序列
Args:
condition: 判断字符是否满足条件的函数
Returns:
str: 满足条件的字符序列
"""
start = self.pos
while self.pos < self.len and condition(self.text[self.pos]):
self.pos += 1
return self.text[start : self.pos]
def eof(self) -> bool:
"""检查是否到达文本末尾
Returns:
bool: 如果到达末尾返回 True, 否则返回 False
"""
return self.pos >= self.len
class RequirementParser(Parser):
"""Python 软件包解析工具
Attributes:
bindings (dict[str, str] | None): 解析语法
"""
def __init__(self, text: str, bindings: dict[str, str] | None = None):
"""初始化依赖声明解析器
Args:
text (str): 覫解析的依赖声明文本
bindings (dict[str, str] | None): 环境变量绑定字典
"""
super().__init__(text)
self.bindings = bindings or {}
def parse(self) -> ParsedPyWhlRequirement:
"""解析依赖声明，返回 (name, extras, version_specs / url, marker)
Returns:
ParsedPyWhlRequirement: 解析结果元组
"""
self.skip_whitespace()
# 首先解析名称
name = self.parse_identifier()
self.skip_whitespace()
# 解析 extras
extras = []
if self.peek() == "[":
extras = self.parse_extras()
self.skip_whitespace()
# 检查是 URL 依赖还是版本依赖
if self.peek() == "@":
# URL依赖
self.consume("@")
self.skip_whitespace()
url = self.parse_url()
self.skip_whitespace()
# 解析可选的 marker
marker = None
if self.match(";"):
marker = self.parse_marker()
return ParsedPyWhlRequirement(name, extras, url, marker)
else:
# 版本依赖
versions = []
# 检查是否有版本约束 (不是以分号开头)
if not self.eof() and self.peek() not in (";", ","):
versions = self.parse_versionspec()
self.skip_whitespace()
# 解析可选的 marker
marker = None
if self.match(";"):
marker = self.parse_marker()
return ParsedPyWhlRequirement(name, extras, versions, marker)
def parse_identifier(self) -> str:
"""解析标识符
Returns:
str: 解析得到的标识符
"""
def is_identifier_char(c):
return c.isalnum() or c in "-_."
result = self.read_while(is_identifier_char)
if not result:
raise ValueError("应为预期标识符")
return result
def parse_extras(self) -> list[str]:
"""解析 extras 列表
Returns:
list[str]: extras 列表
"""
self.consume("[")
self.skip_whitespace()
extras = []
if self.peek() != "]":
extras.append(self.parse_identifier())
self.skip_whitespace()
while self.match(","):
self.skip_whitespace()
extras.append(self.parse_identifier())
self.skip_whitespace()
self.consume("]")
return extras
def parse_versionspec(self) -> list[tuple[str, str]]:
"""解析版本约束
Returns:
list[tuple[str, str]]: 版本约束列表
"""
if self.match("("):
versions = self.parse_version_many()
self.consume(")")
return versions
else:
return self.parse_version_many()
def parse_version_many(self) -> list[tuple[str, str]]:
"""解析多个版本约束
Returns:
list[tuple[str, str]]: 多个版本约束组成的列表
"""
versions = [self.parse_version_one()]
self.skip_whitespace()
while self.match(","):
self.skip_whitespace()
versions.append(self.parse_version_one())
self.skip_whitespace()
return versions
def parse_version_one(self) -> tuple[str, str]:
"""解析单个版本约束
Returns:
tuple[str, str]: (操作符, 版本号) 元组
"""
op = self.parse_version_cmp()
self.skip_whitespace()
version = self.parse_version()
return (op, version)
def parse_version_cmp(self) -> str:
"""解析版本比较操作符
Returns:
str: 版本比较操作符
Raises:
ValueError: 当找不到有效的版本比较操作符时
"""
operators = ["<=", ">=", "==", "!=", "~=", "===", "<", ">"]
for op in operators:
if self.match(op):
return op
raise ValueError(f"预期在位置 {self.pos} 处出现版本比较符")
def parse_version(self) -> str:
"""解析版本号
Returns:
str: 版本号字符串
Raises:
ValueError: 当找不到有效版本号时
"""
def is_version_char(c):
return c.isalnum() or c in "-_.*+!"
version = self.read_while(is_version_char)
if not version:
raise ValueError("期望为版本字符串")
return version
def parse_url(self) -> str:
"""解析 URL (简化版本)
Returns:
str: URL 字符串
Raises:
ValueError: 当找不到有效 URL 时
"""
# 读取直到遇到空白或分号
start = self.pos
while self.pos < self.len and self.text[self.pos] not in " \t;":
self.pos += 1
url = self.text[start : self.pos]
if not url:
raise ValueError("@ 后的预期 URL")
return url
def parse_marker(self) -> Any:
"""解析 marker 表达式
Returns:
Any: 解析后的 marker 表达式
"""
self.skip_whitespace()
return self.parse_marker_or()
def parse_marker_or(self) -> Any:
"""解析 OR 表达式
Returns:
Any: 解析后的 OR 表达式
"""
left = self.parse_marker_and()
self.skip_whitespace()
if self.match("or"):
self.skip_whitespace()
right = self.parse_marker_or()
return ("or", left, right)
return left
def parse_marker_and(self) -> Any:
"""解析 AND 表达式
Returns:
Any: 解析后的 AND 表达式
"""
left = self.parse_marker_expr()
self.skip_whitespace()
if self.match("and"):
self.skip_whitespace()
right = self.parse_marker_and()
return ("and", left, right)
return left
def parse_marker_expr(self) -> Any:
"""解析基础 marker 表达式
Returns:
Any: 解析后的基础表达式
"""
self.skip_whitespace()
if self.peek() == "(":
self.consume("(")
expr = self.parse_marker()
self.consume(")")
return expr
left = self.parse_marker_var()
self.skip_whitespace()
op = self.parse_marker_op()
self.skip_whitespace()
right = self.parse_marker_var()
return (op, left, right)
def parse_marker_var(self) -> str:
"""解析 marker 变量
Returns:
str: 解析得到的变量值
"""
self.skip_whitespace()
# 检查是否是环境变量
env_vars = [
"python_version",
"python_full_version",
"os_name",
"sys_platform",
"platform_release",
"platform_system",
"platform_version",
"platform_machine",
"platform_python_implementation",
"implementation_name",
"implementation_version",
"extra",
]
for var in env_vars:
if self.match(var):
# 返回绑定的值，如果不存在则返回变量名
return self.bindings.get(var, var)
# 否则解析为字符串
return self.parse_python_str()
def parse_marker_op(self) -> str:
"""解析 marker 操作符
Returns:
str: marker 操作符
Raises:
ValueError: 当找不到有效操作符时
"""
# 版本比较操作符
version_ops = ["<=", ">=", "==", "!=", "~=", "===", "<", ">"]
for op in version_ops:
if self.match(op):
return op
# in 操作符
if self.match("in"):
return "in"
# not in 操作符
if self.match("not"):
self.skip_whitespace()
if self.match("in"):
return "not in"
raise ValueError("预期在 'not' 之后出现 'in'")
raise ValueError(f"在位置 {self.pos} 处应出现标记运算符")
def parse_python_str(self) -> str:
"""解析 Python 字符串
Returns:
str: 解析得到的字符串
"""
self.skip_whitespace()
if self.peek() == '"':
return self.parse_quoted_string('"')
elif self.peek() == "'":
return self.parse_quoted_string("'")
else:
# 如果没有引号，读取标识符
return self.parse_identifier()
def parse_quoted_string(self, quote: str) -> str:
"""解析引号字符串
Args:
quote (str): 引号字符
Returns:
str: 解析得到的字符串
Raises:
ValueError: 当字符串未正确闭合时
"""
self.consume(quote)
result = []
while self.pos < self.len and self.text[self.pos] != quote:
if self.text[self.pos] == "\\": # 处理转义
self.pos += 1
if self.pos < self.len:
result.append(self.text[self.pos])
self.pos += 1
else:
result.append(self.text[self.pos])
self.pos += 1
if self.pos >= self.len:
raise ValueError(f"未闭合的字符串字面量，预期为 '{quote}'")
self.consume(quote)
return "".join(result)
def format_full_version(info: str) -> str:
"""格式化完整的版本信息
Args:
info (str): 版本信息
Returns:
str: 格式化后的版本字符串
"""
version = f"{info.major}.{info.minor}.{info.micro}"
kind = info.releaselevel
if kind != "final":
version += kind[0] + str(info.serial)
return version
def get_parse_bindings() -> dict[str, str]:
"""获取用于解析 Python 软件包名的语法
Returns:
(dict[str, str]): 解析 Python 软件包名的语法字典
"""
# 创建环境变量绑定
if hasattr(sys, "implementation"):
implementation_version = format_full_version(sys.implementation.version)
implementation_name = sys.implementation.name
else:
implementation_version = "0"
implementation_name = ""
bindings = {
"implementation_name": implementation_name,
"implementation_version": implementation_version,
"os_name": os.name,
"platform_machine": platform.machine(),
"platform_python_implementation": platform.python_implementation(),
"platform_release": platform.release(),
"platform_system": platform.system(),
"platform_version": platform.version(),
"python_full_version": platform.python_version(),
"python_version": ".".join(platform.python_version_tuple()[:2]),
"sys_platform": sys.platform,
}
return bindings
|
2301_81996401/sd-webui-all-in-one
|
sd_webui_all_in_one/package_analyzer/py_whl_parse.py
|
Python
|
agpl-3.0
| 14,974
|
"""版本大小比较器"""
import re
class CommonVersionComparison:
"""常规版本号比较工具
使用:
```python
CommonVersionComparison("1.0") != CommonVersionComparison("1.0") # False
CommonVersionComparison("1.0.1") > CommonVersionComparison("1.0") # True
CommonVersionComparison("1.0a") < CommonVersionComparison("1.0") # True
```
Attributes:
version (str | int | float): 版本号字符串
"""
def __init__(self, version: str | int | float) -> None:
"""常规版本号比较工具初始化
Args:
version (str | int | float): 版本号字符串
"""
self.version = version
def __lt__(self, other: object) -> bool:
"""实现 < 符号的版本比较
Returns:
bool: 如果此版本小于另一个版本
"""
if not isinstance(other, CommonVersionComparison):
return NotImplemented
return self.compare_versions(self.version, other.version) < 0
def __gt__(self, other: object) -> bool:
"""实现 > 符号的版本比较
Returns:
bool: 如果此版本大于另一个版本
"""
if not isinstance(other, CommonVersionComparison):
return NotImplemented
return self.compare_versions(self.version, other.version) > 0
def __le__(self, other: object) -> bool:
"""实现 <= 符号的版本比较
Returns:
bool: 如果此版本小于等于另一个版本
"""
if not isinstance(other, CommonVersionComparison):
return NotImplemented
return self.compare_versions(self.version, other.version) <= 0
def __ge__(self, other: object) -> bool:
"""实现 >= 符号的版本比较
Returns:
bool: 如果此版本大于等于另一个版本
"""
if not isinstance(other, CommonVersionComparison):
return NotImplemented
return self.compare_versions(self.version, other.version) >= 0
def __eq__(self, other: object) -> bool:
"""实现 == 符号的版本比较
Returns:
bool: 如果此版本等于另一个版本
"""
if not isinstance(other, CommonVersionComparison):
return NotImplemented
return self.compare_versions(self.version, other.version) == 0
def __ne__(self, other: object) -> bool:
"""实现 != 符号的版本比较
Returns:
bool: 如果此版本不等于另一个版本
"""
if not isinstance(other, CommonVersionComparison):
return NotImplemented
return self.compare_versions(self.version, other.version) != 0
def compare_versions(self, version1: str | int | float, version2: str | int | float) -> int:
"""对比两个版本号大小
Args:
version1 (str | int | float): 第一个版本号
version2 (str | int | float): 第二个版本号
Returns:
int: 版本对比结果, 1 为第一个版本号大, -1 为第二个版本号大, 0 为两个版本号一样
"""
version1 = str(version1)
version2 = str(version2)
# 移除构建元数据（+之后的部分）
v1_main = version1.split("+", maxsplit=1)[0]
v2_main = version2.split("+", maxsplit=1)[0]
# 分离主版本号和预发布版本（支持多种分隔符）
def _split_version(v):
# 先尝试用 -, _, . 分割预发布版本
# 匹配主版本号部分和预发布部分
match = re.match(r"^([0-9]+(?:\.[0-9]+)*)([-_.].*)?$", v)
if match:
release = match.group(1)
pre = match.group(2)[1:] if match.group(2) else "" # 去掉分隔符
return release, pre
return v, ""
v1_release, v1_pre = _split_version(v1_main)
v2_release, v2_pre = _split_version(v2_main)
# 将版本号拆分成数字列表
try:
nums1 = [int(x) for x in v1_release.split(".") if x]
nums2 = [int(x) for x in v2_release.split(".") if x]
except Exception as _:
return 0
# 补齐版本号长度
max_len = max(len(nums1), len(nums2))
nums1 += [0] * (max_len - len(nums1))
nums2 += [0] * (max_len - len(nums2))
# 比较版本号
for i in range(max_len):
if nums1[i] > nums2[i]:
return 1
elif nums1[i] < nums2[i]:
return -1
# 如果主版本号相同, 比较预发布版本
if v1_pre and not v2_pre:
return -1 # 预发布版本 < 正式版本
elif not v1_pre and v2_pre:
return 1 # 正式版本 > 预发布版本
elif v1_pre and v2_pre:
if v1_pre > v2_pre:
return 1
elif v1_pre < v2_pre:
return -1
else:
return 0
else:
return 0 # 版本号相同
def version_increment(version: str) -> str:
"""增加版本号大小
Args:
version (str): 初始版本号
Returns:
str: 增加后的版本号
"""
version = "".join(re.findall(r"\d|\.", version))
ver_parts = list(map(int, version.split(".")))
ver_parts[-1] += 1
for i in range(len(ver_parts) - 1, 0, -1):
if ver_parts[i] == 10:
ver_parts[i] = 0
ver_parts[i - 1] += 1
return ".".join(map(str, ver_parts))
def version_decrement(version: str) -> str:
"""减小版本号大小
Args:
version (str): 初始版本号
Returns:
str: 减小后的版本号
"""
version = "".join(re.findall(r"\d|\.", version))
ver_parts = list(map(int, version.split(".")))
ver_parts[-1] -= 1
for i in range(len(ver_parts) - 1, 0, -1):
if ver_parts[i] == -1:
ver_parts[i] = 9
ver_parts[i - 1] -= 1
while len(ver_parts) > 1 and ver_parts[0] == 0:
ver_parts.pop(0)
return ".".join(map(str, ver_parts))
|
2301_81996401/sd-webui-all-in-one
|
sd_webui_all_in_one/package_analyzer/ver_cmp.py
|
Python
|
agpl-3.0
| 6,121
|
"""PyTorch 镜像管理工具"""
import re
import subprocess
from typing import Literal
from sd_webui_all_in_one.config import PYTORCH_MIRROR_DICT
from sd_webui_all_in_one.package_analyzer.ver_cmp import CommonVersionComparison
def get_pytorch_mirror_dict() -> dict[str, str]:
"""获取 PyTorch 镜像源字典
Returns:
(dict[str, str]): PyTorch 镜像源字典的副本, 键为设备类型 (如 "cu118", "rocm61" 等), 值为对应的 PyTorch wheel 下载地址
"""
return PYTORCH_MIRROR_DICT.copy()
def get_cuda_comp_cap() -> float:
"""获取 CUDA 的计算能力
当获取值失败时则返回 0.0
Blackwell 消费级 GPU 应得到 12.0
数据中心级 GPU 应得到 10.0
参考:
```
https://developer.nvidia.com/cuda-gpus
https://en.wikipedia.org/wiki/CUDA
```
Returns:
float: CUDA 计算能力值
"""
try:
return max(
map(
float,
subprocess.check_output(
[
"nvidia-smi",
"--query-gpu=compute_cap",
"--format=noheader,csv",
],
text=True,
).splitlines(),
)
)
except Exception as _:
return 0.0
def get_cuda_version() -> float:
"""获取驱动支持的 CUDA 版本
Returns:
float: CUDA 支持的版本
"""
try:
# 获取 nvidia-smi 输出
output = subprocess.check_output(["nvidia-smi", "-q"], text=True)
match = re.search(r"CUDA Version\s+:\s+(\d+\.\d+)", output)
if match:
return float(match.group(1))
return 0.0
except Exception as _:
return 0.0
def get_pytorch_mirror_type_cuda(torch_ver: str) -> str:
"""获取 CUDA 类型的 PyTorch 镜像源类型
Args:
torch_ver (str): PyTorch 版本
Returns:
str: CUDA 类型的 PyTorch 镜像源类型
"""
# cu118: 2.0.0 ~ 2.4.0
# cu121: 2.1.1 ~ 2.4.0
# cu124: 2.4.0 ~ 2.6.0
# cu126: 2.6.0 ~ 2.7.1
# cu128: 2.7.0 ~ 2.7.1
# cu129: 2.8.0
# cu130: 2.9.0 ~
cuda_comp_cap = get_cuda_comp_cap()
cuda_support_ver = get_cuda_version()
torch_version = CommonVersionComparison(torch_ver)
cuda_support_version = CommonVersionComparison(str(int(cuda_support_ver * 10)))
if torch_version < CommonVersionComparison("2.0.0"):
# torch < 2.0.0: default cu11x
return "other"
if CommonVersionComparison("2.0.0") <= torch_version < CommonVersionComparison("2.3.1"):
# 2.0.0 <= torch < 2.3.1: default cu118
return "cu118"
if CommonVersionComparison("2.3.0") <= torch_version < CommonVersionComparison("2.4.1"):
# 2.3.0 <= torch < 2.4.1: default cu121
if CommonVersionComparison(cuda_support_version) < CommonVersionComparison("121"):
if CommonVersionComparison(cuda_support_version) >= CommonVersionComparison("118"):
return "cu118"
return "cu121"
if CommonVersionComparison("2.4.0") <= torch_version < CommonVersionComparison("2.6.0"):
# 2.4.0 <= torch < 2.6.0: default cu124
if CommonVersionComparison(cuda_support_version) < CommonVersionComparison("124"):
if CommonVersionComparison(cuda_support_version) >= CommonVersionComparison("121"):
return "cu121"
if CommonVersionComparison(cuda_support_version) >= CommonVersionComparison("118"):
return "cu118"
return "cu124"
if CommonVersionComparison("2.6.0") <= torch_version < CommonVersionComparison("2.7.0"):
# 2.6.0 <= torch < 2.7.0: default cu126
if CommonVersionComparison(cuda_support_version) < CommonVersionComparison("126"):
if CommonVersionComparison(cuda_support_version) >= CommonVersionComparison("124"):
return "cu124"
if CommonVersionComparison(cuda_comp_cap) > CommonVersionComparison("10.0"):
if CommonVersionComparison(cuda_support_version) >= CommonVersionComparison("128"):
return "cu128"
return "cu126"
if CommonVersionComparison("2.7.0") <= torch_version < CommonVersionComparison("2.8.0"):
# 2.7.0 <= torch < 2.8.0: default cu128
if CommonVersionComparison(cuda_support_version) < CommonVersionComparison("128"):
if CommonVersionComparison(cuda_support_version) > CommonVersionComparison("126"):
return "cu126"
return "cu128"
if CommonVersionComparison("2.8.0") <= torch_version < CommonVersionComparison("2.9.0"):
# 2.8.0 <= torch < 2.9.0: default cu129
if CommonVersionComparison(cuda_support_version) < CommonVersionComparison("129"):
if CommonVersionComparison(cuda_support_version) >= CommonVersionComparison("128"):
return "cu128"
if CommonVersionComparison(cuda_support_version) >= CommonVersionComparison("126"):
return "cu126"
return "cu129"
if torch_version >= CommonVersionComparison("2.9.0"):
# torch >= 2.9.0: default cu130
if CommonVersionComparison(cuda_support_version) < CommonVersionComparison("130"):
if CommonVersionComparison(cuda_support_version) >= CommonVersionComparison("128"):
return "cu128"
if CommonVersionComparison(cuda_support_version) >= CommonVersionComparison("126"):
return "cu126"
return "cu130"
return "cu129"
def get_pytorch_mirror_type_rocm(torch_ver: str) -> str:
"""获取 ROCm 类型的 PyTorch 镜像源类型
Args:
torch_ver (str): PyTorch 版本
Returns:
str: ROCm 类型的 PyTorch 镜像源类型
"""
torch_version = CommonVersionComparison(torch_ver)
if torch_version < CommonVersionComparison("2.4.0"):
# torch < 2.4.0
return "other"
if CommonVersionComparison("2.4.0") <= torch_version < CommonVersionComparison("2.5.0"):
# 2.4.0 <= torch < 2.5.0
return "rocm61"
if CommonVersionComparison("2.5.0") <= torch_version < CommonVersionComparison("2.6.0"):
# 2.5.0 <= torch < 2.6.0
return "rocm62"
if CommonVersionComparison("2.6.0") <= torch_version < CommonVersionComparison("2.7.0"):
# 2.6.0 <= torch < 2.7.0
return "rocm624"
if CommonVersionComparison("2.7.0") <= torch_version < CommonVersionComparison("2.8.0"):
# 2.7.0 <= torch < 2.8.0
return "rocm63"
if torch_version >= CommonVersionComparison("2.8.0"):
# torch >= 2.8.0
return "rocm64"
return "rocm64"
def get_pytorch_mirror_type_ipex(torch_ver: str) -> str:
"""获取 IPEX 类型的 PyTorch 镜像源类型
Args:
torch_ver (str): PyTorch 版本
Returns:
str: IPEX 类型的 PyTorch 镜像源类型
"""
torch_version = CommonVersionComparison(torch_ver)
if torch_version < CommonVersionComparison("2.0.0"):
# torch < 2.0.0
return "other"
if torch_version == CommonVersionComparison("2.0.0"):
# torch == 2.0.0
return "ipex_legacy_arc"
if CommonVersionComparison("2.0.0") < torch_version < CommonVersionComparison("2.1.0"):
# 2.0.0 < torch < 2.1.0
return "other"
if torch_version == CommonVersionComparison("2.1.0"):
# torch == 2.1.0
return "ipex_legacy_arc"
if torch_version >= CommonVersionComparison("2.6.0"):
# torch >= 2.6.0
return "xpu"
return "xpu"
def get_pytorch_mirror_type_cpu(torch_ver: str) -> str:
"""获取 CPU 类型的 PyTorch 镜像源类型
Args:
torch_ver (str): PyTorch 版本
Returns:
str: CPU 类型的 PyTorch 镜像源类型
"""
_ = torch_ver
return "cpu"
def get_pytorch_mirror_type(torch_ver: str, device_type: Literal["cuda", "rocm", "xpu", "cpu"]) -> str:
"""获取 PyTorch 镜像源类型
Args:
torch_ver (str): PyTorch 版本号
device_type (Literal["cuda", "rocm", "xpu", "cpu"]): 显卡类型
Returns:
str: PyTorch 镜像源类型
"""
if device_type == "cuda":
return get_pytorch_mirror_type_cuda(torch_ver)
if device_type == "rocm":
return get_pytorch_mirror_type_rocm(torch_ver)
if device_type == "xpu":
return get_pytorch_mirror_type_ipex(torch_ver)
if device_type == "cpu":
return get_pytorch_mirror_type_cpu(torch_ver)
return "other"
def get_env_pytorch_type() -> str:
"""获取当前环境中 PyTorch 版本号对应的类型
Returns:
str: PyTorch 类型 (cuda, rocm, xpu, cpu)
"""
torch_ipex_legacy_ver_list = [
"2.0.0a0+gite9ebda2",
"2.1.0a0+git7bcf7da",
"2.1.0a0+cxx11.abi",
"2.0.1a0",
"2.1.0.post0",
]
try:
import torch
torch_ver = torch.__version__
except Exception as _:
return "cuda"
torch_type = torch_ver.split("+").pop()
if torch_ver in torch_ipex_legacy_ver_list:
return "xpu"
if "cu" in torch_type:
return "cuda"
if "rocm" in torch_type:
return "rocm"
if "xpu" in torch_type:
return "xpu"
if "cpu" in torch_type:
return "cpu"
return "cuda"
|
2301_81996401/sd-webui-all-in-one
|
sd_webui_all_in_one/pytorch_mirror.py
|
Python
|
agpl-3.0
| 9,318
|
"""HuggingFace / Modelscope 仓库管理工具"""
import os
import traceback
from pathlib import Path
from typing import Any, Literal
from sd_webui_all_in_one.logger import get_logger
from sd_webui_all_in_one.file_manager import get_file_list
from sd_webui_all_in_one.config import LOGGER_LEVEL, LOGGER_COLOR
from sd_webui_all_in_one.downloader import MultiThreadDownloader
logger = get_logger(
name="Repo Manager",
level=LOGGER_LEVEL,
color=LOGGER_COLOR,
)
class RepoManager:
"""HuggingFace / ModelScope 仓库管理器
Attributes:
hf_api (HfApi | None): HuggingFace API 客户端实例, 用于与 HuggingFace 仓库进行交互
ms_api (HubApi | None): ModelScope API 客户端实例, 用于与 ModelScope 仓库进行交互
hf_token (str | None): HuggingFace认 证令牌, 用于访问私有仓库
ms_token (str | None): ModelScope 认证令牌, 用于访问私有仓库
"""
def __init__(
self,
hf_token: str | None = None,
ms_token: str | None = None,
) -> None:
"""HuggingFace / ModelScope 仓库管理器初始化
Args:
hf_token (str | None): HugggingFace Token, 不为`None`时配置`HF_TOKEN`环境变量
ms_token (str | None): ModelScope Token, 不为`None`时配置`MODELSCOPE_API_TOKEN`环境变量
"""
try:
from huggingface_hub import HfApi
self.hf_api = HfApi(token=hf_token)
if hf_token is not None:
os.environ["HF_TOKEN"] = hf_token
self.hf_token = hf_token
except Exception as e:
logger.warning("HuggingFace 库未安装, 部分功能将不可用: %s", e)
try:
from modelscope import HubApi
self.ms_api = HubApi()
if ms_token is not None:
os.environ["MODELSCOPE_API_TOKEN"] = ms_token
self.ms_api.login(access_token=ms_token)
self.ms_token = ms_token
except Exception as e:
logger.warning("ModelScope 库未安装, 部分功能将不可用: %s", e)
def get_repo_file(
self,
api_type: Literal["huggingface", "modelscope"],
repo_id: str,
repo_type: Literal["model", "dataset", "space"] = "model",
retry: int | None = 3,
) -> list[str]:
"""获取 HuggingFace / ModelScope 仓库文件列表
Args:
api_type (Literal["huggingface", "modelscope"]): Api 类型
repo_id (str): HuggingFace / ModelScope 仓库 ID
repo_type (str): HuggingFace / ModelScope 仓库类型
retry (int | None): 重试次数
Returns:
list[str]: 仓库文件列表
"""
if api_type == "huggingface":
logger.info("获取 HuggingFace 仓库 %s (类型: %s) 的文件列表", repo_id, repo_type)
return self.get_hf_repo_files(repo_id, repo_type, retry)
if api_type == "modelscope":
logger.info("获取 ModelScope 仓库 %s (类型: %s) 的文件列表", repo_id, repo_type)
return self.get_ms_repo_files(repo_id, repo_type, retry)
logger.error("未知 Api 类型: %s", api_type)
return []
def get_hf_repo_files(
self,
repo_id: str,
repo_type: Literal["model", "dataset", "space"] = "model",
retry: int | None = 3,
) -> list[str]:
"""获取 HuggingFace 仓库文件列表
Args:
repo_id (str): HuggingFace 仓库 ID
repo_type (str): HuggingFace 仓库类型
retry (int | None): 重试次数
Returns:
list[str]: 仓库文件列表
"""
count = 0
while count < retry:
count += 1
try:
return self.hf_api.list_repo_files(
repo_id=repo_id,
repo_type=repo_type,
)
except Exception as e:
logger.error(
"[%s/%s] 获取 %s (类型: %s) 仓库的文件列表出现错误: %s",
count,
retry,
repo_id,
repo_type,
e,
)
traceback.print_exc()
if count < retry:
logger.warning("[%s/%s] 重试获取文件列表中", count, retry)
return []
def get_ms_repo_files(
self,
repo_id: str,
repo_type: Literal["model", "dataset", "space"] = "model",
retry: int | None = 3,
) -> list[str]:
"""获取 ModelScope 仓库文件列表
Args:
repo_id (str): ModelScope 仓库 ID
repo_type (str): ModelScope 仓库类型
retry (int | None): 重试次数
Returns:
list[str]: 仓库文件列表
"""
file_list = []
count = 0
def _get_file_path(repo_files: list) -> list[str]:
"""获取 ModelScope Api 返回的仓库列表中的模型路径"""
return [file["Path"] for file in repo_files if file["Type"] != "tree"]
if repo_type == "model":
while count < retry:
count += 1
try:
repo_files = self.ms_api.get_model_files(model_id=repo_id, recursive=True)
file_list = _get_file_path(repo_files)
break
except Exception as e:
traceback.print_exc()
logger.error(
"[%s/%s] 获取 %s (类型: %s) 仓库的文件列表出现错误: %s",
count,
retry,
repo_id,
repo_type,
e,
)
if count < retry:
logger.warning("[%s/%s] 重试获取文件列表中", count, retry)
elif repo_type == "dataset":
while count < retry:
count += 1
try:
repo_files = self.ms_api.get_dataset_files(repo_id=repo_id, recursive=True)
file_list = _get_file_path(repo_files)
break
except Exception as e:
traceback.print_exc()
logger.error(
"[%s/%s] 获取 %s (类型: %s) 仓库的文件列表出现错误: %s",
count,
retry,
repo_id,
repo_type,
e,
)
if count < retry:
logger.warning("[%s/%s] 重试获取文件列表中", count, retry)
elif repo_type == "space":
# TODO: 支持创空间
logger.error("%s 仓库类型为创空间, 不支持获取文件列表", repo_id)
else:
logger.error("未知的 %s 仓库类型", repo_type)
return file_list
def check_repo(
self,
api_type: Literal["huggingface", "modelscope"],
repo_id: str,
repo_type: Literal["model", "dataset", "space"] = "model",
visibility: bool | None = False,
) -> bool:
"""检查 HuggingFace / ModelScope 仓库是否存在, 当不存在时则自动创建
Args:
api_type (Literal["huggingface", "modelscope"]): Api 类型
repo_id (str): 仓库 ID
repo_type (Literal["model", "dataset", "space"]): 仓库类型
Returns:
bool: 检查成功时 / 创建仓库成功时返回`True`
"""
if api_type == "huggingface":
return self.check_hf_repo(repo_id, repo_type, visibility)
if api_type == "modelscope":
return self.check_ms_repo(repo_id, repo_type, visibility)
logger.error("未知 Api 类型: %s", api_type)
return False
def check_hf_repo(
self,
repo_id: str,
repo_type: Literal["model", "dataset", "space"] = "model",
visibility: bool | None = False,
) -> bool:
"""检查 HuggingFace 仓库是否存在, 当不存在时则自动创建
Args:
repo_id (str): HuggingFace 仓库 ID
repo_type (str): HuggingFace 仓库类型
visibility (bool | None): HuggingFace 仓库可见性
Returns:
bool: 检查成功时 / 创建仓库成功时返回`True`
"""
if repo_type in ["model", "dataset", "space"]:
try:
if not self.hf_api.repo_exists(repo_id=repo_id, repo_type=repo_type):
self.hf_api.create_repo(repo_id=repo_id, repo_type=repo_type, private=not visibility)
return True
except Exception as e:
traceback.print_exc()
logger.error("检查 HuggingFace 仓库时发生错误: %s", e)
return False
logger.error("未知 HuggingFace 仓库类型: %s", repo_type)
return False
def check_ms_repo(
self,
repo_id: str,
repo_type: Literal["model", "dataset", "space"] = "model",
visibility: bool | None = False,
) -> bool:
"""检查 ModelScope 仓库是否存在, 当不存在时则自动创建
Args:
repo_id (str): ModelScope 仓库 ID
repo_type (str): ModelScope 仓库类型
visibility (bool | None): HuggingFace 仓库可见性
Returns:
bool: 检查成功时 / 创建仓库成功时返回`True`
"""
from modelscope.hub.constants import Visibility
if repo_type in ["model", "dataset"]:
try:
if not self.ms_api.repo_exists(
repo_id=repo_id,
repo_type=repo_type,
token=self.ms_token,
):
self.ms_api.create_repo(
repo_id=repo_id,
repo_type=repo_type,
visibility=Visibility.PUBLIC if visibility else Visibility.PRIVATE,
token=self.ms_token,
)
return True
except Exception as e:
traceback.print_exc()
logger.error("检查 ModelScope 仓库时发生错误: %s", e)
return False
if repo_type == "space":
logger.error("未支持 ModelScope 创空间")
return False
logger.error("未知 ModelScope 仓库类型: %s", repo_type)
return False
def upload_files_to_repo(
self,
api_type: Literal["huggingface", "modelscope"],
repo_id: str,
upload_path: Path | str,
repo_type: Literal["model", "dataset", "space"] = "model",
visibility: bool | None = False,
retry: int | None = 3,
) -> None:
"""上传文件夹中的内容到 HuggingFace / ModelScope 仓库中
Args:
api_type (Literal["huggingface", "modelscope"]): Api 类型
repo_id (str): 仓库 ID
repo_type (str): 仓库类型
upload_path (Path | str): 要上传的文件夹
visibility (bool | None): 当仓库不存在时自动创建的仓库的可见性
retry (int | None): 上传重试次数
"""
if api_type in ["huggingface", "modelscope"]:
if not self.check_repo(
api_type=api_type,
repo_id=repo_id,
repo_type=repo_type,
visibility=visibility,
):
logger.error("检查 %s (类型: %s) 仓库失败, 无法上传文件")
return
upload_path = Path(upload_path) if not isinstance(upload_path, Path) and upload_path is not None else upload_path
if api_type == "huggingface":
self.upload_files_to_huggingface(
repo_id=repo_id,
repo_type=repo_type,
upload_path=upload_path,
retry=retry,
)
elif api_type == "modelscope":
self.upload_files_to_modelscope(
repo_id=repo_id,
repo_type=repo_type,
upload_path=upload_path,
retry=retry,
)
else:
logger.error("未知 Api 类型: %s", api_type)
def upload_files_to_huggingface(
self,
repo_id: str,
upload_path: Path | str,
repo_type: Literal["model", "dataset", "space"] = "model",
retry: int | None = 3,
) -> None:
"""上传文件夹中的内容到 HuggingFace 仓库中
Args:
repo_id (str): HuggingFace 仓库 ID
repo_type (str): HuggingFace 仓库类型
upload_path (Path | str): 要上传到 HuggingFace 仓库的文件夹
retry (int | None): 上传重试次数
"""
upload_files = get_file_list(upload_path)
repo_files = set(
self.get_repo_file(
api_type="huggingface",
repo_id=repo_id,
repo_type=repo_type,
retry=retry,
)
)
logger.info("上传到 HuggingFace 仓库: %s -> HuggingFace/%s", upload_path, repo_id)
files_count = len(upload_files)
count = 0
for upload_file in upload_files:
count += 1
upload_file_rel_path = upload_file.relative_to(upload_path).as_posix()
if upload_file_rel_path in repo_files:
logger.info(
"[%s/%s] %s 已存在于 HuggingFace 仓库中, 跳过上传",
count,
files_count,
upload_file,
)
continue
logger.info(
"[%s/%s] 上传 %s 到 %s (类型: %s) 仓库中",
count,
files_count,
upload_file,
repo_id,
repo_type,
)
retry_num = 0
while retry_num < retry:
retry_num += 1
try:
self.hf_api.upload_file(
repo_id=repo_id,
repo_type=repo_type,
path_in_repo=upload_file_rel_path,
path_or_fileobj=upload_file,
commit_message=f"Upload {upload_file.name}",
)
break
except Exception as e:
logger.error(
"[%s/%s] 上传 %s 时发生错误: %s",
count,
files_count,
upload_file.name,
e,
)
traceback.print_exc()
if retry_num < retry:
logger.warning("[%s/%s] 重试上传 %s", count, files_count, upload_file.name)
logger.info(
"[%s/%s] 上传 %s 到 %s (类型: %s) 完成",
count,
files_count,
upload_path,
repo_id,
repo_type,
)
def upload_files_to_modelscope(
self,
repo_id: str,
upload_path: Path | str,
repo_type: Literal["model", "dataset", "space"] = "model",
retry: int | None = 3,
) -> None:
"""上传文件夹中的内容到 ModelScope 仓库中
Args:
repo_id (str): ModelScope 仓库 ID
repo_type (str): ModelScope 仓库类型
upload_path (Path | str): 要上传到 ModelScope 仓库的文件夹
retry (int | None): 上传重试次数
"""
upload_files = get_file_list(upload_path)
repo_files = set(
self.get_repo_file(
api_type="modelscope",
repo_id=repo_id,
repo_type=repo_type,
retry=retry,
)
)
logger.info("上传到 ModelScope 仓库: %s -> ModelScope/%s", upload_path, repo_id)
files_count = len(upload_files)
count = 0
for upload_file in upload_files:
count += 1
upload_file_rel_path = upload_file.relative_to(upload_path).as_posix()
if upload_file_rel_path in repo_files:
logger.info(
"[%s/%s] %s 已存在于 ModelScope 仓库中, 跳过上传",
count,
files_count,
upload_file,
)
continue
logger.info(
"[%s/%s] 上传 %s 到 %s (类型: %s) 仓库中",
count,
files_count,
upload_file,
repo_id,
repo_type,
)
retry_num = 0
while retry_num < retry:
retry_num += 1
try:
self.ms_api.upload_file(
repo_id=repo_id,
repo_type=repo_type,
path_in_repo=upload_file_rel_path,
path_or_fileobj=upload_file,
commit_message=f"Upload {upload_file.name}",
token=self.ms_token,
)
break
except Exception as e:
logger.error(
"[%s/%s] 上传 %s 时发生错误: %s",
count,
files_count,
upload_file.name,
e,
)
traceback.print_exc()
if retry_num < retry:
logger.warning("[%s/%s] 重试上传 %s", count, files_count, upload_file.name)
logger.info(
"[%s/%s] 上传 %s 到 %s (类型: %s) 完成",
count,
files_count,
upload_path,
repo_id,
repo_type,
)
def download_files_from_repo(
self,
api_type: Literal["huggingface", "modelscope"],
repo_id: str,
local_dir: Path | str,
repo_type: Literal["model", "dataset", "space"] = "model",
folder: str | None = None,
retry: int | None = 3,
num_threads: int | None = 16,
) -> Path:
"""从 HuggingFace / ModelScope 仓库下载文文件
`folder`参数未指定时, 则下载 HuggingFace / ModelScope 仓库中的所有文件, 如果`folder`参数指定了, 例如指定的是`aaaki`
而仓库的文件结构如下:
```markdown
HuggingFace / ModelScope Repositories
├── Nachoneko
│ ├── 1_nachoneko
│ │ ├── [メロンブックス (よろず)]Melonbooks Girls Collection 2019 winter 麗.png
│ │ ├── [メロンブックス (よろず)]Melonbooks Girls Collection 2019 winter 麗.txt
│ │ ├── [メロンブックス (よろず)]Melonbooks Girls Collection 2020 spring 彩 (オリジナル).png
│ │ └── [メロンブックス (よろず)]Melonbooks Girls Collection 2020 spring 彩 (オリジナル).txt
│ ├── 2_nachoneko
│ │ ├── 0(8).txt
│ │ ├── 0(8).webp
│ │ ├── 001_2.png
│ │ └── 001_2.txt
│ └── 4_nachoneko
│ ├── 0b1c8893-c9aa-49e5-8769-f90c4b6866f5.png
│ ├── 0b1c8893-c9aa-49e5-8769-f90c4b6866f5.txt
│ ├── 0d5149dd-3bc1-484f-8c1e-a1b94bab3be5.png
│ └── 0d5149dd-3bc1-484f-8c1e-a1b94bab3be5.txt
└ aaaki
├── 1_aaaki
│ ├── 1.png
│ ├── 1.txt
│ ├── 11.png
│ ├── 11.txt
│ ├── 12.png
│ └── 12.txt
└── 3_aaaki
├── 14.png
├── 14.txt
├── 16.png
└── 16.txt
```
则使用该函数下载 HuggingFace / ModelScope 仓库的文件时将下载`aaaki`文件夹中的所有文件, 而`Nachoneko`文件夹中的文件不会被下载
`folder`参数使用的是前缀匹配方式, 从路径的开头的字符串进行匹配, 匹配成功则进行下载
如果要指定下载某个文件, 则`folder`参数需要指定该文件在仓库中的完整路径, 比如`aaaki/1_aaaki/1.png`, 此时只会下载该文件, 其他文件不会被下载
文件下载下来后, 保存路径为`local_dir/<文件在仓库中的路径>`, 比如`local_dir`为`/kaggle/dataset`, 上面下载单个文件的例子下载下载下来的文件就会保存在`/kaggle/dataset/aaaki/1_aaaki/1.png`
Args:
api_type (Literal["huggingface", "modelscope"]): Api 类型
repo_id (str): 仓库 ID
repo_type (Literal["model", "dataset", "space"]): 仓库类型
local_dir (Path | str): 下载路径
folder (str | None): 指定下载某个文件夹, 未指定时则下载整个文件夹
retry (int | None): 重试下载的次数
num_threads (int | None): 下载线程
Returns:
Path: 下载路径
"""
local_dir = Path(local_dir) if not isinstance(local_dir, Path) and local_dir is not None else local_dir
logger.info("从 %s (类型: %s) 下载文件中", repo_id, repo_type)
if api_type == "huggingface":
self.download_files_from_huggingface(
repo_id=repo_id,
repo_type=repo_type,
local_dir=local_dir,
folder=folder,
retry=retry,
num_threads=num_threads,
)
return local_dir
if api_type == "modelscope":
self.download_files_from_modelscope(
repo_id=repo_id,
repo_type=repo_type,
local_dir=local_dir,
folder=folder,
retry=retry,
num_threads=num_threads,
)
return local_dir
logger.error("未知 Api 类型: %s", api_type)
return None
def download_files_from_huggingface(
self,
repo_id: str,
local_dir: Path | str,
repo_type: Literal["model", "dataset", "space"] = "model",
folder: str | None = None,
retry: int | None = 3,
num_threads: int | None = 16,
) -> None:
"""从 HuggingFace 仓库下载文文件
Args:
repo_id (str): HuggingFace 仓库 ID
repo_type (Literal["model", "dataset", "space"]): HuggingFace 仓库类型
local_dir (Path | str): 下载路径
folder (str | None): 指定下载某个文件夹, 未指定时则下载整个文件夹
retry (int | None): 重试下载的次数
num_threads (int | None): 下载线程
"""
from huggingface_hub import hf_hub_download
repo_files = self.get_repo_file(
api_type="huggingface",
repo_id=repo_id,
repo_type=repo_type,
retry=retry,
)
download_task: list[dict[str, Any]] = []
for repo_file in repo_files:
if folder is not None and not repo_file.startswith(folder):
continue
download_task.append(
{
"repo_id": repo_id,
"repo_type": repo_type,
"local_dir": local_dir,
"filename": repo_file,
}
)
if folder is not None:
logger.info("指定下载文件: %s", folder)
logger.info("下载文件数量: %s", len(download_task))
files_downloader = MultiThreadDownloader(download_func=hf_hub_download, download_kwargs_list=download_task)
files_downloader.start(
num_threads=num_threads,
retry=retry,
)
def download_files_from_modelscope(
self,
repo_id: str,
local_dir: Path | str,
repo_type: Literal["model", "dataset", "space"] = "model",
folder: str | None = None,
retry: int | None = 3,
num_threads: int | None = 16,
) -> None:
"""从 ModelScope 仓库下载文文件
Args:
repo_id (str): ModelScope 仓库 ID
repo_type (Literal["model", "dataset", "space"]): ModelScope 仓库类型
local_dir (Path | str): 下载路径
folder (str | None): 指定下载某个文件夹, 未指定时则下载整个文件夹
retry (int | None): 重试下载的次数
num_threads (int | None): 下载线程
"""
from modelscope import snapshot_download
repo_files = self.get_repo_file(
api_type="modelscope",
repo_id=repo_id,
repo_type=repo_type,
retry=retry,
)
download_task: list[dict[str, Any]] = []
for repo_file in repo_files:
if folder is not None and not repo_file.startswith(folder):
continue
download_task.append(
{
"repo_id": repo_id,
"repo_type": repo_type,
"local_dir": local_dir,
"allow_patterns": repo_file,
}
)
if folder is not None:
logger.info("指定下载文件: %s", folder)
logger.info("下载文件数量: %s", len(download_task))
files_downloader = MultiThreadDownloader(download_func=snapshot_download, download_kwargs_list=download_task)
files_downloader.start(
num_threads=num_threads,
retry=retry,
)
|
2301_81996401/sd-webui-all-in-one
|
sd_webui_all_in_one/repo_manager.py
|
Python
|
agpl-3.0
| 26,152
|
"""SD WebUI All In One 补丁模块初始化"""
from sdaio_patches.uv_patch import patch_uv_to_subprocess
# patch_uv_to_subprocess()
|
2301_81996401/sd-webui-all-in-one
|
sd_webui_all_in_one/sdaio_patcher/sdaio_initializer.py
|
Python
|
agpl-3.0
| 136
|
"""uv 补丁, 将调用 subprocess.run() 时执行的 Pip 命令替换成 uv"""
import shlex
import sys
import subprocess
from functools import wraps
from sdaio_utils.logger import get_logger
from sdaio_utils.config import LOGGER_LEVEL, LOGGER_COLOR
logger = get_logger(
name="uv Patcher",
level=LOGGER_LEVEL,
color=LOGGER_COLOR,
)
def preprocess_command(command: list[str] | str, shell: bool) -> list[str] | str:
"""针对不同平台对命令进行预处理
Args:
command (list[str] | str): 原始命令
shell (bool): 是否调用 Shell
Returns:
(list[str] | str): 处理后的命令
"""
if sys.platform == "win32":
# Windows
# 字符串命令和列表命令都可行
return command
else:
# Linux / MacOS
if shell:
# 使用字符串命令
if isinstance(command, list):
return shlex.join(command)
return command
# 使用列表命令
if isinstance(command, str):
return shlex.split(command)
return command
def patch_uv_to_subprocess(symlink: bool | None = False) -> None:
"""使用 subprocess 执行 Pip 时替换成 uv"""
if hasattr(subprocess, "__original_run"):
return
logger.debug("启用 uv patch")
subprocess.__original_run = subprocess.run # pylint: disable=protected-access
@wraps(subprocess.__original_run) # pylint: disable=protected-access
def patched_run(*args, **kwargs):
if args:
command, *_args = args
else:
command, _args = kwargs.pop("args", ""), ()
if isinstance(command, str):
command = shlex.split(command)
else:
command = [arg.strip() for arg in command]
assert isinstance(command, list)
if "pip" not in command:
return subprocess.__original_run(preprocess_command([*command, *_args], shell=kwargs.get("shell", False)), **kwargs) # pylint: disable=protected-access
cmd = command[command.index("pip") + 1 :]
bad_flags = ("--prefer-binary", "--ignore-installed", "-I")
cmd = [arg for arg in cmd if arg not in bad_flags]
modified_command: list[str] = ["uv", "pip", *cmd]
if symlink:
modified_command.extend(["--link-mode", "symlink"])
command = preprocess_command(
command=[*modified_command, *_args],
shell=kwargs.get("shell", False),
)
return subprocess.__original_run(command, **kwargs) # pylint: disable=protected-access
subprocess.run = patched_run
|
2301_81996401/sd-webui-all-in-one
|
sd_webui_all_in_one/sdaio_patcher/sdaio_patches/uv_patch.py
|
Python
|
agpl-3.0
| 2,629
|
from sdaio_utils.logger import get_logger
from sdaio_utils.config import LOGGER_COLOR, LOGGER_LEVEL
logger = get_logger(
name="SD WebUI ALL In One Patcher Utils",
level=LOGGER_LEVEL,
color=LOGGER_COLOR,
)
|
2301_81996401/sd-webui-all-in-one
|
sd_webui_all_in_one/sdaio_patcher/sdaio_utils/__init__.py
|
Python
|
agpl-3.0
| 218
|
"""配置管理"""
import os
import logging
LOGGER_NAME = os.getenv("SD_WEBUI_ALL_IN_ONE_LOGGER_NAME", "SD WebUI All In One")
"""日志器名字"""
LOGGER_LEVEL = int(os.getenv("SD_WEBUI_ALL_IN_ONE_LOGGER_LEVEL", str(logging.INFO)))
"""日志等级"""
LOGGER_COLOR = os.getenv("SD_WEBUI_ALL_IN_ONE_LOGGER_COLOR") not in ["0", "False", "false", "None", "none", "null"]
"""日志颜色"""
|
2301_81996401/sd-webui-all-in-one
|
sd_webui_all_in_one/sdaio_patcher/sdaio_utils/config.py
|
Python
|
agpl-3.0
| 391
|
"""日志工具"""
import os
import sys
import copy
import inspect
import logging
class LoggingColoredFormatter(logging.Formatter):
"""Logging 格式化类
Attributes:
color (bool): 是否启用日志颜色
COLORS (dict[str, str]): 颜色类型字典
"""
COLORS = {
"DEBUG": "\033[0;36m", # CYAN
"INFO": "\033[0;32m", # GREEN
"WARNING": "\033[0;33m", # YELLOW
"ERROR": "\033[0;31m", # RED
"CRITICAL": "\033[0;37;41m", # WHITE ON RED
"RESET": "\033[0m", # RESET COLOR
}
def __init__(
self,
fmt: str | None = None,
datefmt: str | None = None,
color: bool | None = True,
) -> None:
"""Logging 初始化
Args:
fmt (str | None): 日志消息的格式字符串
datefmt (str | None): 日期 / 时间的显示格式
color (bool | None): 是否启用彩色日志输出. 默认为 True
"""
super().__init__(fmt, datefmt)
self.color = color
def format(self, record: logging.LogRecord) -> str:
colored_record = copy.copy(record)
levelname = colored_record.levelname
if self.color:
seq = self.COLORS.get(levelname, self.COLORS["RESET"])
colored_record.levelname = f"{seq}{levelname}{self.COLORS['RESET']}"
return super().format(colored_record)
def get_logger(name: str | None = None, level: int | None = logging.INFO, color: bool | None = True) -> logging.Logger:
"""获取 Loging 对象
Args:
name (str | None): Logging 名称
level (int | None): 日志级别
color (bool | None): 是否启用彩色日志
Returns:
logging.Logger: Logging 对象
"""
stack = inspect.stack()
calling_filename = os.path.basename(stack[1].filename)
if name is None:
name = calling_filename
_logger = logging.getLogger(name)
_logger.propagate = False
if not _logger.handlers:
handler = logging.StreamHandler(sys.stdout)
handler.setFormatter(
LoggingColoredFormatter(
r"[%(name)s]-|%(asctime)s|-%(levelname)s: %(message)s",
r"%Y-%m-%d %H:%M:%S",
color=color,
)
)
_logger.addHandler(handler)
_logger.setLevel(level)
_logger.debug("Logger 初始化完成")
return _logger
|
2301_81996401/sd-webui-all-in-one
|
sd_webui_all_in_one/sdaio_patcher/sdaio_utils/logger.py
|
Python
|
agpl-3.0
| 2,415
|
"""SD WebUI All In One 补丁模块导入口
需设置 PYTHONPATH 变量指定模块的路径
"""
# pylint: disable=unused-wildcard-import
# pylint: disable=wildcard-import
# pylint: disable=wrong-import-position
# pylint: disable=unused-import
import sdaio_initializer # noqa: F401
|
2301_81996401/sd-webui-all-in-one
|
sd_webui_all_in_one/sdaio_patcher/sitecustomize.py
|
Python
|
agpl-3.0
| 285
|
"""内网穿透工具"""
import re
import sys
import uuid
import time
import shlex
import queue
import shutil
import tarfile
import secrets
import platform
import threading
import traceback
import subprocess
from pathlib import Path
from tempfile import TemporaryDirectory
from sd_webui_all_in_one.cmd import run_cmd
from sd_webui_all_in_one.logger import get_logger
from sd_webui_all_in_one.env_manager import pip_install
from sd_webui_all_in_one.downloader import download_file
from sd_webui_all_in_one.config import LOGGER_LEVEL, LOGGER_COLOR
logger = get_logger(
name="Tunnel",
level=LOGGER_LEVEL,
color=LOGGER_COLOR,
)
class TunnelManager:
"""内网穿透工具
Attributes:
workspace (Path | str): 工作区路径
port (int): 要进行端口映射的端口
"""
def __init__(self, workspace: Path | str, port: int) -> None:
"""内网穿透工具初始化
Args:
workspace (Path | str): 工作区路径
port (int): 要进行端口映射的端口
"""
self.workspace = Path(workspace)
self.port = port
def ngrok(self, ngrok_token: str | None = None) -> str | None:
"""使用 Ngrok 内网穿透
Args:
ngrok_token (str | None): Ngrok 账号 Token
Returns:
(str | None): Ngrok 内网穿透生成的访问地址
"""
if ngrok_token is None:
logger.warning("缺少 Ngrok Token, 取消启动 Ngrok 内网穿透")
return None
logger.info("启动 Ngrok 内网穿透")
try:
from pyngrok import conf, ngrok
except Exception as _:
try:
pip_install("pyngrok")
from pyngrok import conf, ngrok
except Exception as e:
logger.error("安装 Ngrok 内网穿透模块失败: %s", e)
return None
try:
conf.get_default().auth_token = ngrok_token
conf.get_default().monitor_thread = False
ssh_tunnels = ngrok.get_tunnels(conf.get_default())
if len(ssh_tunnels) == 0:
ssh_tunnel = ngrok.connect(self.port, bind_tls=True)
logger.info("Ngrok 内网穿透启动完成")
return ssh_tunnel.public_url
else:
logger.info("Ngrok 内网穿透启动完成")
return ssh_tunnels[0].public_url
except Exception as e:
logger.error("启动 Ngrok 内网穿透时出现了错误: %s", e)
return None
def cloudflare(self) -> str | None:
"""使用 CloudFlare 内网穿透
Returns:
(str | None): CloudFlare 内网穿透生成的访问地址
"""
logger.info("启动 CloudFlare 内网穿透")
try:
from pycloudflared import try_cloudflare
except Exception as _:
try:
pip_install("pycloudflared")
from pycloudflared import try_cloudflare
except Exception as e:
logger.error("安装 CloudFlare 内网穿透失败: %s", e)
return None
try:
tunnel_url = try_cloudflare(self.port).tunnel
logger.info("CloudFlare 内网穿透启动完成")
return tunnel_url
except Exception as e:
logger.error("启动 CloudFlare 内网穿透时出现了错误: %s", e)
return None
def gradio(self) -> str | None:
"""使用 Gradio 进行内网穿透
Returns:
(str | None): 使用内网穿透得到的访问地址, 如果启动内网穿透失败则不返回地址
"""
logger.info("启动 Gradio 内网穿透")
try:
from gradio_tunneling.main import setup_tunnel
except Exception as _:
try:
pip_install("gradio-tunneling")
from gradio_tunneling.main import setup_tunnel
except Exception as e:
logger.error("安装 Gradio Tunneling 内网穿透时出现了错误: %s", e)
return None
try:
tunnel_url = setup_tunnel(
local_host="127.0.0.1",
local_port=self.port,
share_token=secrets.token_urlsafe(32),
share_server_address=None,
)
logger.info("Gradio 内网穿透启动完成")
return tunnel_url
except Exception as e:
logger.error("启动 Gradio 内网穿透时出现错误: %s", e)
return None
def gen_key(self, path: Path | str) -> bool:
"""生成 SSH 密钥
Args:
path (str | Path): 生成 SSH 密钥的路径
Returns:
bool: 生成成功时返回`True`
"""
path = Path(path) if not isinstance(path, Path) and path is not None else path
try:
arg_string = f'ssh-keygen -t rsa -b 4096 -N "" -q -f {path.as_posix()}'
args = shlex.split(arg_string)
subprocess.run(args, check=True)
path.chmod(0o600)
return True
except Exception as e:
logger.error("生成 SSH 密钥失败: %s", e)
return False
def ssh_tunnel(
self,
launch_args: list,
host_pattern: re.Pattern[str],
line_limit: int,
) -> str | None:
"""使用 SSH 进行内网穿透
基础 SSH 命令为: `ssh -o StrictHostKeyChecking=no -i <ssh_path>`
Args:
launch_args (list): 启动 SSH 内网穿透的参数
host_pattern (re.Pattern[str]): 用于匹配内网穿透地址的正则表达式
line_limit (int): 内网穿透地址所在的输出行数
Returns:
(str | None): 内网穿透地址
"""
ssh_name = "id_rsa"
ssh_path = self.workspace / ssh_name
if not ssh_path.exists():
if not self.gen_key(ssh_path):
tmp = TemporaryDirectory()
ssh_path = Path(tmp.name) / ssh_name
self.gen_key(ssh_path)
command = [
"ssh",
"-o",
"StrictHostKeyChecking=no",
"-i",
ssh_path.as_posix(),
] + launch_args
if sys.platform == "win32":
# 在 Windows 平台上不使用 shlex 处理成字符串
command_to_exec = command
else:
# 把列表转换为字符串, 避免 subprocss 只把使用列表第一个元素作为命令
command_to_exec = shlex.join(command) if isinstance(command, list) else command
tunnel = subprocess.Popen(
command_to_exec,
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
universal_newlines=True,
bufsize=1,
encoding="utf-8",
)
output_queue = queue.Queue()
lines = []
def _read_output():
for line in iter(tunnel.stdout.readline, ""):
output_queue.put(line)
tunnel.stdout.close()
thread = threading.Thread(target=_read_output)
thread.daemon = True
thread.start()
for _ in range(line_limit):
try:
line = output_queue.get(timeout=10)
lines.append(line)
if line.startswith("Warning"):
print(line, end="")
url_match = host_pattern.search(line)
if url_match:
return url_match.group("url")
except queue.Empty:
logger.error("未捕获到指定输出, 输出内容列表: %s", lines)
break
except Exception as e:
logger.error("运行 SSH 进程时发生错误: %s", e)
break
return None
def localhost_run(self) -> str | None:
"""使用 localhost.run 进行内网穿透
Returns:
return (str|None): 使用内网穿透得到的访问地址, 如果启动内网穿透失败则不返回地址
"""
logger.info("启动 localhost.run 内网穿透")
urls = self.ssh_tunnel(
launch_args=["-R", f"80:127.0.0.1:{self.port}", "localhost.run"],
host_pattern=re.compile(r"(?P<url>https?://\S+\.lhr\.life)"),
line_limit=27,
)
if urls is not None:
logger.info("localhost.run 内网穿透启动完成")
return urls
logger.error("启动 localhost.run 内网穿透失败")
return None
def remote_moe(self) -> str | None:
"""使用 remote.moe 进行内网穿透
Returns:
return (str|None): 使用内网穿透得到的访问地址, 如果启动内网穿透失败则不返回地址
"""
logger.info("启动 remote.moe 内网穿透")
urls = self.ssh_tunnel(
launch_args=["-R", f"80:127.0.0.1:{self.port}", "remote.moe"],
host_pattern=re.compile(r"(?P<url>https?://\S+\.remote\.moe)"),
line_limit=10,
)
if urls is not None:
logger.info("remote.moe 内网穿透启动完成")
return urls
logger.error("启动 remote.moe 内网穿透失败")
return None
def pinggy_io(self) -> str | None:
"""使用 pinggy.io 进行内网穿透
Returns:
return (str|None): 使用内网穿透得到的访问地址, 如果启动内网穿透失败则不返回地址
"""
logger.info("启动 pinggy.io 内网穿透")
urls = self.ssh_tunnel(
launch_args=["-p", "443", f"-R0:127.0.0.1:{self.port}", "free.pinggy.io"],
host_pattern=re.compile(r"(?P<url>https?://\S+\.pinggy\.link)"),
line_limit=10,
)
if urls is not None:
logger.info("pinggy.io 内网穿透启动完成")
return urls
logger.error("启动 pinggy.io 内网穿透失败")
return None
def get_latest_zrok_release(self) -> list[str] | None:
"""获取最新的 Zrok 发行内容下载列表
Returns:
(list[str] | None): 获取到的发行版下载列表 (`[<文件名>, <下载链接>]`)
"""
import requests
url = "https://api.github.com/repos/openziti/zrok/releases/latest"
data = {
"Accept": "application/vnd.github+json",
}
logger.info("获取 Zrok 发行版本列表")
response = requests.get(url=url, data=data)
res = response.json()
if response.status_code < 200 or response.status_code > 300:
logger.info("获取 Zrok 发行版本列表失败")
return None
file_list = []
for i in res.get("assets"):
file_list.append([i.get("name"), i.get("browser_download_url")])
return file_list
def get_appropriate_zrok_package(self, packages: list[str]) -> tuple[str, str] | None:
"""获取适合当前平台的 Zrok 版本
Args:
packages (list[str]): 发行版下载列表
Returns:
(tuple[str, str] | None): 文件名和下载链接
"""
def _get_current_platform_and_arch() -> tuple[str, str]:
_arch = platform.machine()
_platform = sys.platform
_platform = _platform.replace("win32", "windows").replace("cygwin", "windows").replace("linux2", "linux")
_arch = _arch.replace("x86_64", "amd64").replace("AMD64", "amd64").replace("aarch64", "arm64").replace("armv7l", "armv7")
return _platform, _arch
zrok_package_name_pattern = r"""
^
(?P<software>[\w]+?) # 软件名
_
(?P<version>[\d.]+) # 版本号 (数字和点)
_
(?P<platform>[\w]+?) # 系统类型
_
(?P<arch>[\w]+?) # 架构
\.
(?P<extension>[a-z0-9]+(?:\.[a-z0-9]+)?) # 扩展名 (支持多级扩展)
$
"""
# 编译正则表达式 (忽略大小写, 详细模式)
zrok_name_parse_regex = re.compile(zrok_package_name_pattern, re.VERBOSE | re.IGNORECASE)
current_platform, current_arch = _get_current_platform_and_arch()
for p, url in packages:
match = zrok_name_parse_regex.match(p)
if match:
groups = match.groupdict()
support_arch = groups.get("arch")
support_platform = groups.get("platform")
if current_platform == support_platform and support_arch == current_arch:
logger.info("找到合适 Zrok 版本: %s", p)
return p, url
logger.error("未找到适合当前平台的 Zrok")
return None, None
def install_zrok(self) -> Path | None:
"""安装 Zrok
Returns:
(Path | None): Zrok 可执行文件路径, 安装失败时则返回`None`
"""
if sys.platform == "win32":
bin_extension_name = ".exe"
else:
bin_extension_name = ""
zrok_bin = self.workspace / f"zrok{bin_extension_name}"
if zrok_bin.is_file():
try:
run_cmd([zrok_bin.as_posix(), "version"], live=False)
logger.info("Zrok 已安装")
return zrok_bin
except Exception as _:
pass
logger.info("安装 Zrok 中")
if zrok_bin.exists():
shutil.move(zrok_bin, zrok_bin.parent / f"zrok_{uuid.uuid4()}")
release = self.get_latest_zrok_release()
if release is None:
logger.error("获取 Zrok 发行版信息失败, 无法安装 Zrok")
return None
package_name, download_url = self.get_appropriate_zrok_package(release)
if package_name is None:
return None
with TemporaryDirectory() as tmp_dir:
tmp_dir = Path(tmp_dir)
zrok_archive_file = download_file(
url=download_url,
path=tmp_dir,
save_name=package_name,
)
if zrok_archive_file is None:
logger.error("Zrok 安装包下载失败")
return None
try:
with tarfile.open(zrok_archive_file, "r:gz") as tar:
tar.extractall(path=tmp_dir)
zrok_bin_in_tmp_dir = tmp_dir / f"zrok{bin_extension_name}"
shutil.move(zrok_bin_in_tmp_dir, zrok_bin)
logger.info("Zrok 安装成功")
return zrok_bin
except Exception as e:
traceback.print_exc()
logger.error("Zrok 安装失败: %s", e)
return None
def zrok(self, zrok_token: str | None = None) -> str | None:
"""启动 Zrok 内网穿透
Args:
zrok_token (str | None): Zrok Token
Returns:
(str | None): Zrok 内网穿透地址
"""
if zrok_token is None:
logger.warning("缺少 Zrok Token, 取消启动 Zrok 内网穿透")
return None
logger.info("启动 Zrok 内网穿透中")
zrok_bin = self.install_zrok()
if zrok_bin is None:
logger.error("启动 Zrok 内网穿透失败")
return None
logger.info("初始化 Zrok 配置")
try:
run_cmd([zrok_bin.as_posix(), "disable"], live=False)
except Exception as _:
pass
try:
run_cmd([zrok_bin.as_posix(), "enable", zrok_token])
logger.info("Zrok 配置初始化完成")
except Exception as e:
logger.error("初始化 Zrok 配置失败, 无法使用 Zrok 内网穿透: %s", e)
return None
host_pattern = re.compile(r"(?P<url>https?://\S+\.share\.zrok\.io)")
command = [zrok_bin.as_posix(), "share", "public", str(self.port), "--headless"]
if sys.platform == "win32":
# 在 Windows 平台上不使用 shlex 处理成字符串
command_to_exec = command
else:
# 把列表转换为字符串, 避免 subprocss 只把使用列表第一个元素作为命令
command_to_exec = shlex.join(command) if isinstance(command, list) else command
tunnel = subprocess.Popen(
command_to_exec,
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
text=True,
bufsize=1,
encoding="utf-8",
)
output_queue = queue.Queue()
buffer = "" # 缓冲不完整的行
def _read_output():
nonlocal buffer
for char in iter(lambda: tunnel.stdout.read(1), ""):
buffer += char
# 遇到换行符时处理一行
if char in ("\n", "\r"):
output_queue.put(buffer)
url_match = host_pattern.search(buffer)
if url_match:
output_queue.put(("URL", url_match.group("url")))
buffer = ""
tunnel.stdout.close()
thread = threading.Thread(target=_read_output)
thread.daemon = True
thread.start()
start_ts = time.time()
while time.time() - start_ts < 60:
try:
item = output_queue.get(timeout=1)
if isinstance(item, tuple) and item[0] == "URL":
logger.info("Zrok 内网穿透启动完成")
return item[1]
except queue.Empty:
if tunnel.poll() is not None:
break
logger.error("启动 Zrok 内网穿透失败")
return None
def start_tunnel(
self,
use_ngrok: bool | None = False,
ngrok_token: str | None = None,
use_cloudflare: bool | None = False,
use_remote_moe: bool | None = False,
use_localhost_run: bool | None = False,
use_gradio: bool | None = False,
use_pinggy_io: bool | None = False,
use_zrok: bool | None = False,
zrok_token: str | None = None,
message: str | None = None,
) -> dict[str, str]:
"""启动内网穿透
Args:
use_ngrok (bool | None): 启用 Ngrok 内网穿透
ngrok_token (str | None): Ngrok 账号 Token
use_cloudflare (bool | None): 启用 CloudFlare 内网穿透
use_remote_moe (bool | None): 启用 remote.moe 内网穿透
use_localhost_run (bool | None): 使用 localhost.run 内网穿透
use_gradio (bool | None): 使用 Gradio 内网穿透
use_pinggy_io (bool | None): 使用 pinggy.io 内网穿透
use_zrok (bool | None): 使用 Zrok 内网穿透
zrok_token (str | None): Zrok 账号 Token
message (str | None): 描述信息
Returns:
(dict[str, str]): 内网穿透地址
"""
if any(
[
use_cloudflare,
use_ngrok and ngrok_token,
use_remote_moe,
use_localhost_run,
use_gradio,
use_pinggy_io,
use_zrok,
]
):
logger.info("启动内网穿透")
else:
return
cloudflare_url = self.cloudflare() if use_cloudflare else None
ngrok_url = self.ngrok(ngrok_token) if use_ngrok and ngrok_token else None
remote_moe_url = self.remote_moe() if use_remote_moe else None
localhost_run_url = self.localhost_run() if use_localhost_run else None
gradio_url = self.gradio() if use_gradio else None
pinggy_io_url = self.pinggy_io() if use_pinggy_io else None
zrok_url = self.zrok(zrok_token) if use_zrok and zrok_token else None
logger.info("http://127.0.0.1:%s 的内网穿透地址", self.port)
print("==================================================================================")
if message is not None:
print(f"{message}")
print(f":: CloudFlare: {cloudflare_url}")
print(f":: Ngrok: {ngrok_url}")
print(f":: remote.moe: {remote_moe_url}")
print(f":: localhost_run: {localhost_run_url}")
print(f":: Gradio: {gradio_url}")
print(f":: pinggy.io: {pinggy_io_url}")
print(f":: Zrok: {zrok_url}")
print("==================================================================================")
return {
"cloudflare": cloudflare_url,
"ngrok": ngrok_url,
"remote_moe": remote_moe_url,
"localhost_run": localhost_run_url,
"gradio": gradio_url,
"pinggy_io": pinggy_io_url,
"zrok": zrok_url,
}
|
2301_81996401/sd-webui-all-in-one
|
sd_webui_all_in_one/tunnel.py
|
Python
|
agpl-3.0
| 21,044
|
"""其他工具合集"""
from typing import Any
from pathlib import Path
from sd_webui_all_in_one.logger import get_logger
from sd_webui_all_in_one.config import LOGGER_COLOR, LOGGER_LEVEL, SD_WEBUI_ALL_IN_ONE_PATCHER_PATH
logger = get_logger(
name="Utils",
level=LOGGER_LEVEL,
color=LOGGER_COLOR,
)
def in_jupyter() -> bool:
"""检测当前环境是否在 Jupyter 中
Returns:
bool: 是否在 Jupyter 中
"""
try:
shell = get_ipython() # type: ignore
if shell is None:
return False
# Jupyter Notebook 或 JupyterLab
if shell.__class__.__name__ == "ZMQInteractiveShell":
return True
# IPython 终端
if shell.__class__.__name__ == "TerminalInteractiveShell":
return False
return True
except NameError:
# 没有 get_ipython, 不是 Jupyter
return False
def clear_up() -> bool:
"""清理 Jupyter Notebook 输出内容
Returns:
bool: 清理输出结果
"""
try:
from IPython.display import clear_output
clear_output(wait=False)
return True
except Exception as e:
logger.error("清理 Jupyter Notebook 输出内容失败: %s", e)
return False
def check_gpu() -> bool:
"""检查环境中是否有可用的 GPU
Returns:
bool: 当有可用 GPU 时返回`True`
"""
logger.info("检查当前环境是否有 GPU 可用")
import tensorflow as tf
if tf.test.gpu_device_name():
logger.info("有可用的 GPU")
return True
else:
logger.error("无可用 GPU")
return False
def warning_unexpected_params(
message: str,
args: tuple[Any, ...],
kwargs: dict[str, Any],
) -> None:
"""显示多余参数警告
Args:
message (str): 提示信息
args (tuple[Any, ...]): 额外的位置参数
kwargs (dict[str, Any]): 额外的关键字参数
"""
if args or kwargs:
logger.warning(message)
if args:
logger.warning("多余的位置参数: %s", args)
if kwargs:
logger.warning("多余的关键字参数: %s", kwargs)
logger.warning("请移除这些多余参数以避免引发错误")
def remove_duplicate_object_from_list(origin: list[Any]) -> list[Any]:
"""对`list`进行去重
例如: [1, 2, 3, 2] -> [1, 2, 3]
Args:
origin (list[Any]): 原始的`list`
Returns:
list[Any]: 去重后的`list`
"""
return list(set(origin))
def get_sdaio_patcher_path() -> Path:
"""获取 SD WebUI All In One 补丁路径"""
return SD_WEBUI_ALL_IN_ONE_PATCHER_PATH
|
2301_81996401/sd-webui-all-in-one
|
sd_webui_all_in_one/utils.py
|
Python
|
agpl-3.0
| 2,689
|
"""SD WebUI All In One 版本"""
VERSION = "1.2.13"
|
2301_81996401/sd-webui-all-in-one
|
sd_webui_all_in_one/version.py
|
Python
|
agpl-3.0
| 53
|
<!DOCTYPE html>
<html lang="">
<head>
<meta charset="utf-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width,initial-scale=1.0">
<title>vue-manage-system</title>
<link rel="stylesheet" href="https://at.alicdn.com/t/font_830376_qzecyukz0s.css">
</head>
<body>
<noscript>
<strong>We're sorry but <%= htmlWebpackPlugin.options.title %> doesn't work properly without JavaScript enabled.
Please enable it to continue.</strong>
</noscript>
<div id="app"></div>
<script type="module" src="/src/main.ts"></script>
<!-- built files will be auto injected -->
</body>
</html>
|
2301_82000044/my-api-gateway
|
my-api-gateway-admin/index.html
|
HTML
|
mit
| 653
|
<template>
<el-config-provider :locale="zhCn">
<router-view />
</el-config-provider>
</template>
<script setup lang="ts">
import { ElConfigProvider } from 'element-plus';
import zhCn from 'element-plus/es/locale/lang/zh-cn';
</script>
<style>
@import '/src/assets/css/main.css';
@import '/src/assets/css/color-dark.css';
</style>
|
2301_82000044/my-api-gateway
|
my-api-gateway-admin/src/App.vue
|
Vue
|
mit
| 347
|
import request from '../utils/request';
import {config} from "md-editor-v3/lib/MdEditor/config";
export const fetchData = () => {
return request({
url: './table.json',
method: 'get'
});
};
// export const gatewayServerData = () => {
// return request({
// url: './gateway_server.json',
// method: 'get'
// });
// };
// function 方式定义函数
// @ts-ignore
export function gatewayServerData(query) {
return request({
url: 'http://localhost:8901/wg/admin/data/queryGatewayServer?groupId=' + query.groupId + '&page=' + query.pageIndex + '&limit=' + query.pageSize,
method: 'get'
});
}
// const 方式定义函数
// @ts-ignore
export const gatewayServerDetailData = (query) => {
return request({
// url: './gateway_server_detail.json',
url: 'http://localhost:8901/wg/admin/data/queryGatewayServerDetail?groupId=' + query.groupId + '&gatewayId=' + query.gatewayId + '&page=' + query.pageIndex + '&limit=' + query.pageSize,
method: 'get'
});
};
// @ts-ignore
export const gatewayDistributionData = (query) => {
return request({
// url: './gateway_distribution.json',
url: 'http://localhost:8901/wg/admin/data/queryGatewayDistribution?groupId=' + query.groupId + '&gatewayId=' + query.gatewayId + '&page=' + query.pageIndex + '&limit=' + query.pageSize,
method: 'get'
});
};
// @ts-ignore
export const applicationSystemData = (query) => {
return request({
// url: './application_system.json',
url: 'http://localhost:8901/wg/admin/data/queryApplicationSystem?systemId=' + query.systemId + '&systemName=' + query.systemName + '&page=' + query.pageIndex + '&limit=' + query.pageSize,
method: 'get'
});
};
// @ts-ignore
export const applicationInterfaceData = (query) => {
return request({
// url: './application_interface.json',
url: 'http://localhost:8901/wg/admin/data/queryApplicationInterface?systemId=' + query.systemId + '&interfaceId=' + query.interfaceId + '&page=' + query.pageIndex + '&limit=' + query.pageSize,
method: 'get'
});
};
// @ts-ignore
export const applicationInterfaceMethodData = (query) => {
return request({
// url: './application_interface_method.json',
url: 'http://localhost:8901/wg/admin/data/queryApplicationInterfaceMethodList?systemId=' + query.systemId + '&interfaceId=' + query.interfaceId + '&page=' + query.pageIndex + '&limit=' + query.pageSize,
method: 'get'
});
};
|
2301_82000044/my-api-gateway
|
my-api-gateway-admin/src/api/index.ts
|
TypeScript
|
mit
| 2,536
|
.header{
background-color: #242f42;
}
.login-wrap{
background: #324157;
}
.plugins-tips{
background: #eef1f6;
}
.plugins-tips a{
color: #20a0ff;
}
.tags-li.active {
border: 1px solid #409EFF;
background-color: #409EFF;
}
.message-title{
color: #20a0ff;
}
.collapse-btn:hover{
background: rgb(40,52,70);
}
|
2301_82000044/my-api-gateway
|
my-api-gateway-admin/src/assets/css/color-dark.css
|
CSS
|
mit
| 337
|
[class*=" el-icon-lx"],
[class^=el-icon-lx] {
font-family: lx-iconfont !important;
}
|
2301_82000044/my-api-gateway
|
my-api-gateway-admin/src/assets/css/icon.css
|
CSS
|
mit
| 88
|
* {
margin: 0;
padding: 0;
}
html,
body,
#app,
.wrapper {
width: 100%;
height: 100%;
overflow: hidden;
}
body {
font-family: 'PingFang SC', "Helvetica Neue", Helvetica, "microsoft yahei", arial, STHeiTi, sans-serif;
}
a {
text-decoration: none
}
.content-box {
position: absolute;
left: 250px;
right: 0;
top: 70px;
bottom: 0;
padding-bottom: 30px;
-webkit-transition: left .3s ease-in-out;
transition: left .3s ease-in-out;
background: #f0f0f0;
}
.content {
width: auto;
height: 100%;
padding: 10px;
overflow-y: scroll;
box-sizing: border-box;
}
.content-collapse {
left: 65px;
}
.container {
padding: 30px;
background: #fff;
border: 1px solid #ddd;
border-radius: 5px;
}
.crumbs {
margin: 10px 0;
}
.el-table th {
background-color: #f5f7fa !important;
}
.pagination {
margin: 20px 0;
text-align: right;
}
.plugins-tips {
padding: 20px 10px;
margin-bottom: 20px;
}
.el-button+.el-tooltip {
margin-left: 10px;
}
.el-table tr:hover {
background: #f6faff;
}
.mgb20 {
margin-bottom: 20px;
}
.move-enter-active,
.move-leave-active {
transition: opacity .1s ease;
}
.move-enter-from,
.move-leave-to {
opacity: 0;
}
/*BaseForm*/
.form-box {
width: 600px;
}
.form-box .line {
text-align: center;
}
.el-time-panel__content::after,
.el-time-panel__content::before {
margin-top: -7px;
}
.el-time-spinner__wrapper .el-scrollbar__wrap:not(.el-scrollbar__wrap--hidden-default) {
padding-bottom: 0;
}
[class*=" el-icon-"], [class^=el-icon-] {
speak: none;
font-style: normal;
font-weight: 400;
font-variant: normal;
text-transform: none;
line-height: 1;
vertical-align: baseline;
display: inline-block;
-webkit-font-smoothing: antialiased;
-moz-osx-font-smoothing: grayscale;
}
.el-sub-menu [class^=el-icon-] {
vertical-align: middle;
margin-right: 5px;
width: 24px;
text-align: center;
font-size: 18px;
}
[hidden]{
display: none !important;
}
|
2301_82000044/my-api-gateway
|
my-api-gateway-admin/src/assets/css/main.css
|
CSS
|
mit
| 2,081
|
<template>
<div class="header">
<!-- 折叠按钮 -->
<div class="collapse-btn" @click="collapseChage">
<el-icon v-if="sidebar.collapse"><Expand /></el-icon>
<el-icon v-else><Fold /></el-icon>
</div>
<div class="logo">网关管理系统</div>
<div class="header-right">
<div class="header-user-con">
<!-- 消息中心 -->
<div class="btn-bell" @click="router.push('/tabs')">
<el-tooltip
effect="dark"
:content="message ? `有${message}条未读消息` : `消息中心`"
placement="bottom"
>
<i class="el-icon-lx-notice"></i>
</el-tooltip>
<span class="btn-bell-badge" v-if="message"></span>
</div>
<!-- 用户头像 -->
<el-avatar class="user-avator" :size="30" :src="imgurl" />
<!-- 用户名下拉菜单 -->
<el-dropdown class="user-name" trigger="click" @command="handleCommand">
<span class="el-dropdown-link">
{{ username }}
<el-icon class="el-icon--right">
<arrow-down />
</el-icon>
</span>
<template #dropdown>
<el-dropdown-menu>
<el-dropdown-item command="user">个人中心</el-dropdown-item>
<el-dropdown-item divided command="loginout">退出登录</el-dropdown-item>
</el-dropdown-menu>
</template>
</el-dropdown>
</div>
</div>
</div>
</template>
<script setup lang="ts">
import { onMounted } from 'vue';
import { useSidebarStore } from '../store/sidebar';
import { useRouter } from 'vue-router';
import imgurl from '../assets/img/img.jpg';
const username: string | null = localStorage.getItem('ms_username');
const message: number = 2;
const sidebar = useSidebarStore();
// 侧边栏折叠
const collapseChage = () => {
sidebar.handleCollapse();
};
onMounted(() => {
if (document.body.clientWidth < 1500) {
collapseChage();
}
});
// 用户名下拉菜单选择事件
const router = useRouter();
const handleCommand = (command: string) => {
if (command == 'loginout') {
localStorage.removeItem('ms_username');
router.push('/login');
} else if (command == 'user') {
router.push('/user');
}
};
</script>
<style scoped>
.header {
position: relative;
box-sizing: border-box;
width: 100%;
height: 70px;
font-size: 22px;
color: #fff;
}
.collapse-btn {
display: flex;
justify-content: center;
align-items: center;
height: 100%;
float: left;
padding: 0 21px;
cursor: pointer;
}
.header .logo {
float: left;
width: 250px;
line-height: 70px;
}
.header-right {
float: right;
padding-right: 50px;
}
.header-user-con {
display: flex;
height: 70px;
align-items: center;
}
.btn-fullscreen {
transform: rotate(45deg);
margin-right: 5px;
font-size: 24px;
}
.btn-bell,
.btn-fullscreen {
position: relative;
width: 30px;
height: 30px;
text-align: center;
border-radius: 15px;
cursor: pointer;
display: flex;
align-items: center;
}
.btn-bell-badge {
position: absolute;
right: 4px;
top: 0px;
width: 8px;
height: 8px;
border-radius: 4px;
background: #f56c6c;
color: #fff;
}
.btn-bell .el-icon-lx-notice {
color: #fff;
}
.user-name {
margin-left: 10px;
}
.user-avator {
margin-left: 20px;
}
.el-dropdown-link {
color: #fff;
cursor: pointer;
display: flex;
align-items: center;
}
.el-dropdown-menu__item {
text-align: center;
}
</style>
|
2301_82000044/my-api-gateway
|
my-api-gateway-admin/src/components/header.vue
|
Vue
|
mit
| 3,265
|
<template>
<div class="sidebar">
<el-menu
class="sidebar-el-menu"
:default-active="onRoutes"
:collapse="sidebar.collapse"
background-color="#324157"
text-color="#bfcbd9"
active-text-color="#20a0ff"
unique-opened
router
>
<template v-for="item in items">
<template v-if="item.subs">
<el-sub-menu :index="item.index" :key="item.index" v-permiss="item.permiss">
<template #title>
<el-icon>
<component :is="item.icon"></component>
</el-icon>
<span>{{ item.title }}</span>
</template>
<template v-for="subItem in item.subs">
<el-sub-menu
v-if="subItem.subs"
:index="subItem.index"
:key="subItem.index"
v-permiss="item.permiss"
>
<template #title>{{ subItem.title }}</template>
<el-menu-item v-for="(threeItem, i) in subItem.subs" :key="i" :index="threeItem.index">
{{ threeItem.title }}
</el-menu-item>
</el-sub-menu>
<el-menu-item v-else :index="subItem.index" v-permiss="item.permiss">
{{ subItem.title }}
</el-menu-item>
</template>
</el-sub-menu>
</template>
<template v-else>
<el-menu-item :index="item.index" :key="item.index" v-permiss="item.permiss">
<el-icon>
<component :is="item.icon"></component>
</el-icon>
<template #title>{{ item.title }}</template>
</el-menu-item>
</template>
</template>
</el-menu>
</div>
</template>
<script setup lang="ts">
import { computed } from 'vue';
import { useSidebarStore } from '../store/sidebar';
import { useRoute } from 'vue-router';
const items = [
{
icon: 'Odometer',
index: '/dashboard',
title: '系统首页',
permiss: '1',
},
{
icon: 'Calendar',
index: '1',
title: '网关配置',
permiss: '2',
subs: [
{
index: '/gateway_server',
title: '网关分组',
permiss: '2',
},
{
index: '/gateway_server_detail',
title: '算力节点',
permiss: '2',
},
{
index: '/gateway_distribution',
title: '网关映射',
permiss: '2',
},
],
},
{
icon: 'Calendar',
index: '1',
title: '应用信息',
permiss: '2',
subs: [
{
index: '/application_system',
title: '应用服务',
permiss: '2',
},
{
index: '/application_interface',
title: '应用接口',
permiss: '2',
},
{
index: '/application_interface_method',
title: '接口方法',
permiss: '2',
},
],
},
// {
// icon: 'Calendar',
// index: '1',
// title: '表格相关',
// permiss: '2',
// subs: [
// {
// index: '/table',
// title: '常用表格',
// permiss: '2',
// },
// {
// index: '/import',
// title: '导入Excel',
// permiss: '2',
// },
// {
// index: '/export',
// title: '导出Excel',
// permiss: '2',
// },
// ],
// },
// {
// icon: 'DocumentCopy',
// index: '/tabs',
// title: 'tab选项卡',
// permiss: '3',
// },
// {
// icon: 'Edit',
// index: '3',
// title: '表单相关',
// permiss: '4',
// subs: [
// {
// index: '/form',
// title: '基本表单',
// permiss: '5',
// },
// {
// index: '/upload',
// title: '文件上传',
// permiss: '6',
// },
// {
// index: '4',
// title: '三级菜单',
// permiss: '7',
// subs: [
// {
// index: '/editor',
// title: '富文本编辑器',
// permiss: '8',
// },
// {
// index: '/markdown',
// title: 'markdown编辑器',
// permiss: '9',
// },
// ],
// },
// ],
// },
// {
// icon: 'Setting',
// index: '/icon',
// title: '自定义图标',
// permiss: '10',
// },
// {
// icon: 'PieChart',
// index: '/charts',
// title: 'schart图表',
// permiss: '11',
// },
// {
// icon: 'Warning',
// index: '/permission',
// title: '权限管理',
// permiss: '13',
// },
// {
// icon: 'CoffeeCup',
// index: '/donate',
// title: '支持作者',
// permiss: '14',
// },
];
const route = useRoute();
const onRoutes = computed(() => {
return route.path;
});
const sidebar = useSidebarStore();
</script>
<style scoped>
.sidebar {
display: block;
position: absolute;
left: 0;
top: 70px;
bottom: 0;
overflow-y: scroll;
}
.sidebar::-webkit-scrollbar {
width: 0;
}
.sidebar-el-menu:not(.el-menu--collapse) {
width: 250px;
}
.sidebar > ul {
height: 100%;
}
</style>
|
2301_82000044/my-api-gateway
|
my-api-gateway-admin/src/components/sidebar.vue
|
Vue
|
mit
| 6,463
|
<template>
<div class="tags" v-if="tags.show">
<ul>
<li
class="tags-li"
v-for="(item, index) in tags.list"
:class="{ active: isActive(item.path) }"
:key="index"
>
<router-link :to="item.path" class="tags-li-title">{{ item.title }}</router-link>
<el-icon @click="closeTags(index)"><Close /></el-icon>
</li>
</ul>
<div class="tags-close-box">
<el-dropdown @command="handleTags">
<el-button size="small" type="primary">
标签选项
<el-icon class="el-icon--right">
<arrow-down />
</el-icon>
</el-button>
<template #dropdown>
<el-dropdown-menu size="small">
<el-dropdown-item command="other">关闭其他</el-dropdown-item>
<el-dropdown-item command="all">关闭所有</el-dropdown-item>
</el-dropdown-menu>
</template>
</el-dropdown>
</div>
</div>
</template>
<script setup lang="ts">
import { useTagsStore } from '../store/tags';
import { onBeforeRouteUpdate, useRoute, useRouter } from 'vue-router';
const route = useRoute();
const router = useRouter();
const isActive = (path: string) => {
return path === route.fullPath;
};
const tags = useTagsStore();
// 关闭单个标签
const closeTags = (index: number) => {
const delItem = tags.list[index];
tags.delTagsItem(index);
const item = tags.list[index] ? tags.list[index] : tags.list[index - 1];
if (item) {
delItem.path === route.fullPath && router.push(item.path);
} else {
router.push('/');
}
};
// 设置标签
const setTags = (route: any) => {
const isExist = tags.list.some(item => {
return item.path === route.fullPath;
});
if (!isExist) {
if (tags.list.length >= 8) tags.delTagsItem(0);
tags.setTagsItem({
name: route.name,
title: route.meta.title,
path: route.fullPath
});
}
};
setTags(route);
onBeforeRouteUpdate(to => {
setTags(to);
});
// 关闭全部标签
const closeAll = () => {
tags.clearTags();
router.push('/');
};
// 关闭其他标签
const closeOther = () => {
const curItem = tags.list.filter(item => {
return item.path === route.fullPath;
});
tags.closeTagsOther(curItem);
};
const handleTags = (command: string) => {
command === 'other' ? closeOther() : closeAll();
};
// 关闭当前页面的标签页
// tags.closeCurrentTag({
// $router: router,
// $route: route
// });
</script>
<style>
.tags {
position: relative;
height: 30px;
overflow: hidden;
background: #fff;
padding-right: 120px;
box-shadow: 0 5px 10px #ddd;
}
.tags ul {
box-sizing: border-box;
width: 100%;
height: 100%;
}
.tags-li {
display: flex;
align-items: center;
float: left;
margin: 3px 5px 2px 3px;
border-radius: 3px;
font-size: 12px;
overflow: hidden;
cursor: pointer;
height: 23px;
border: 1px solid #e9eaec;
background: #fff;
padding: 0 5px 0 12px;
color: #666;
-webkit-transition: all 0.3s ease-in;
-moz-transition: all 0.3s ease-in;
transition: all 0.3s ease-in;
}
.tags-li:not(.active):hover {
background: #f8f8f8;
}
.tags-li.active {
color: #fff;
}
.tags-li-title {
float: left;
max-width: 80px;
overflow: hidden;
white-space: nowrap;
text-overflow: ellipsis;
margin-right: 5px;
color: #666;
}
.tags-li.active .tags-li-title {
color: #fff;
}
.tags-close-box {
position: absolute;
right: 0;
top: 0;
box-sizing: border-box;
padding-top: 1px;
text-align: center;
width: 110px;
height: 30px;
background: #fff;
box-shadow: -3px 0 15px 3px rgba(0, 0, 0, 0.1);
z-index: 10;
}
</style>
|
2301_82000044/my-api-gateway
|
my-api-gateway-admin/src/components/tags.vue
|
Vue
|
mit
| 3,452
|
import { createApp } from 'vue';
import { createPinia } from 'pinia';
import * as ElementPlusIconsVue from '@element-plus/icons-vue';
import App from './App.vue';
import router from './router/index';
import { usePermissStore } from './store/permiss';
import 'element-plus/dist/index.css';
import './assets/css/icon.css';
const app = createApp(App);
app.use(createPinia());
app.use(router);
// 注册elementplus图标
for (const [key, component] of Object.entries(ElementPlusIconsVue)) {
app.component(key, component);
}
// 自定义权限指令
const permiss = usePermissStore();
app.directive('permiss', {
mounted(el: { [x: string]: boolean; }, binding: { value: any; }) {
if (!permiss.key.includes(String(binding.value))) {
el['hidden'] = true;
}
},
});
app.mount('#app');
|
2301_82000044/my-api-gateway
|
my-api-gateway-admin/src/main.ts
|
TypeScript
|
mit
| 817
|
import { createRouter, createWebHashHistory, RouteRecordRaw } from 'vue-router';
import { usePermissStore } from '../store/permiss';
import Home from '../views/home.vue';
const routes: RouteRecordRaw[] = [
{
path: '/',
redirect: '/dashboard',
},
{
path: '/',
name: 'Home',
component: Home,
children: [
{
path: '/dashboard',
name: 'dashboard',
meta: {
title: '系统首页',
permiss: '1',
},
component: () => import(/* webpackChunkName: "dashboard" */ '../views/dashboard.vue'),
},
{
path: '/gateway_server',
name: 'gateway_server',
meta: {
title: '网关分组',
permiss: '2',
},
component: () => import(/* webpackChunkName: "table" */ '../views/gateway_server.vue'),
},
{
path: '/gateway_server_detail',
name: 'gateway_server_detail',
meta: {
title: '网关节点',
permiss: '2',
},
component: () => import(/* webpackChunkName: "table" */ '../views/gateway_server_detail.vue'),
},
{
path: '/gateway_distribution',
name: 'gateway_distribution',
meta: {
title: '网关映射',
permiss: '2',
},
component: () => import(/* webpackChunkName: "table" */ '../views/gateway_distribution.vue'),
},
{
path: '/application_system',
name: 'application_system',
meta: {
title: '应用系统',
permiss: '2',
},
component: () => import(/* webpackChunkName: "table" */ '../views/application_system.vue'),
},
{
path: '/application_interface',
name: 'application_interface',
meta: {
title: '应用接口',
permiss: '2',
},
component: () => import(/* webpackChunkName: "table" */ '../views/application_interface.vue'),
},
{
path: '/application_interface_method',
name: 'application_interface_method',
meta: {
title: '接口方法',
permiss: '2',
},
component: () => import(/* webpackChunkName: "table" */ '../views/application_interface_method.vue'),
},
{
path: '/table',
name: 'basetable',
meta: {
title: '表格',
permiss: '2',
},
component: () => import(/* webpackChunkName: "table" */ '../views/table.vue'),
},
{
path: '/charts',
name: 'basecharts',
meta: {
title: '图表',
permiss: '11',
},
component: () => import(/* webpackChunkName: "charts" */ '../views/charts.vue'),
},
{
path: '/form',
name: 'baseform',
meta: {
title: '表单',
permiss: '5',
},
component: () => import(/* webpackChunkName: "form" */ '../views/form.vue'),
},
{
path: '/tabs',
name: 'tabs',
meta: {
title: 'tab标签',
permiss: '3',
},
component: () => import(/* webpackChunkName: "tabs" */ '../views/tabs.vue'),
},
{
path: '/donate',
name: 'donate',
meta: {
title: '鼓励作者',
permiss: '14',
},
component: () => import(/* webpackChunkName: "donate" */ '../views/donate.vue'),
},
{
path: '/permission',
name: 'permission',
meta: {
title: '权限管理',
permiss: '13',
},
component: () => import(/* webpackChunkName: "permission" */ '../views/permission.vue'),
},
{
path: '/upload',
name: 'upload',
meta: {
title: '上传插件',
permiss: '6',
},
component: () => import(/* webpackChunkName: "upload" */ '../views/upload.vue'),
},
{
path: '/icon',
name: 'icon',
meta: {
title: '自定义图标',
permiss: '10',
},
component: () => import(/* webpackChunkName: "icon" */ '../views/icon.vue'),
},
{
path: '/user',
name: 'user',
meta: {
title: '个人中心',
},
component: () => import(/* webpackChunkName: "user" */ '../views/user.vue'),
},
{
path: '/editor',
name: 'editor',
meta: {
title: '富文本编辑器',
permiss: '8',
},
component: () => import(/* webpackChunkName: "editor" */ '../views/editor.vue'),
},
{
path: '/markdown',
name: 'markdown',
meta: {
title: 'markdown编辑器',
permiss: '9',
},
component: () => import(/* webpackChunkName: "markdown" */ '../views/markdown.vue'),
},
{
path: '/export',
name: 'export',
meta: {
title: '导出Excel',
permiss: '2',
},
component: () => import(/* webpackChunkName: "export" */ '../views/export.vue'),
},
{
path: '/import',
name: 'import',
meta: {
title: '导入Excel',
permiss: '2',
},
component: () => import(/* webpackChunkName: "import" */ '../views/import.vue'),
},
],
},
{
path: '/login',
name: 'Login',
meta: {
title: '登录',
},
component: () => import(/* webpackChunkName: "login" */ '../views/login.vue'),
},
{
path: '/403',
name: '403',
meta: {
title: '没有权限',
},
component: () => import(/* webpackChunkName: "403" */ '../views/403.vue'),
},
];
const router = createRouter({
history: createWebHashHistory(),
routes,
});
router.beforeEach((to, from, next) => {
document.title = `${to.meta.title} | vue-manage-system`;
const role = localStorage.getItem('ms_username');
const permiss = usePermissStore();
if (!role && to.path !== '/login') {
next('/login');
} else if (to.meta.permiss && !permiss.key.includes(to.meta.permiss)) {
// 如果没有权限，则进入403
next('/403');
} else {
next();
}
});
export default router;
|
2301_82000044/my-api-gateway
|
my-api-gateway-admin/src/router/index.ts
|
TypeScript
|
mit
| 7,783
|
import { defineStore } from 'pinia';
interface ObjectList {
[key: string]: string[];
}
export const usePermissStore = defineStore('permiss', {
state: () => {
const keys = localStorage.getItem('ms_keys');
return {
key: keys ? JSON.parse(keys) : <string[]>[],
defaultList: <ObjectList>{
admin: ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11', '12', '13', '14', '15', '16'],
user: ['1', '2', '3', '11', '13', '14', '15']
}
};
},
actions: {
handleSet(val: string[]) {
this.key = val;
}
}
});
|
2301_82000044/my-api-gateway
|
my-api-gateway-admin/src/store/permiss.ts
|
TypeScript
|
mit
| 534
|
import { defineStore } from 'pinia';
export const useSidebarStore = defineStore('sidebar', {
state: () => {
return {
collapse: false
};
},
getters: {},
actions: {
handleCollapse() {
this.collapse = !this.collapse;
}
}
});
|
2301_82000044/my-api-gateway
|
my-api-gateway-admin/src/store/sidebar.ts
|
TypeScript
|
mit
| 242
|
import { defineStore } from 'pinia';
interface ListItem {
name: string;
path: string;
title: string;
}
export const useTagsStore = defineStore('tags', {
state: () => {
return {
list: <ListItem[]>[]
};
},
getters: {
show: state => {
return state.list.length > 0;
},
nameList: state => {
return state.list.map(item => item.name);
}
},
actions: {
delTagsItem(index: number) {
this.list.splice(index, 1);
},
setTagsItem(data: ListItem) {
this.list.push(data);
},
clearTags() {
this.list = [];
},
closeTagsOther(data: ListItem[]) {
this.list = data;
},
closeCurrentTag(data: any) {
for (let i = 0, len = this.list.length; i < len; i++) {
const item = this.list[i];
if (item.path === data.$route.fullPath) {
if (i < len - 1) {
data.$router.push(this.list[i + 1].path);
} else if (i > 0) {
data.$router.push(this.list[i - 1].path);
} else {
data.$router.push('/');
}
this.list.splice(i, 1);
break;
}
}
}
}
});
|
2301_82000044/my-api-gateway
|
my-api-gateway-admin/src/store/tags.ts
|
TypeScript
|
mit
| 1,033
|
import axios, {AxiosInstance, AxiosError, AxiosResponse, AxiosRequestConfig} from 'axios';
const service:AxiosInstance = axios.create({
timeout: 5000
});
service.interceptors.request.use(
(config: AxiosRequestConfig) => {
return config;
},
(error: AxiosError) => {
console.log(error);
return Promise.reject();
}
);
service.interceptors.response.use(
(response: AxiosResponse) => {
if (response.status === 200) {
return response;
} else {
Promise.reject();
}
},
(error: AxiosError) => {
console.log(error);
return Promise.reject();
}
);
export default service;
|
2301_82000044/my-api-gateway
|
my-api-gateway-admin/src/utils/request.ts
|
TypeScript
|
mit
| 688
|
<template>
<div class="error-page">
<div class="error-code">4<span>0</span>3</div>
<div class="error-desc">啊哦~ 你没有权限访问该页面哦</div>
<div class="error-handle">
<router-link to="/">
<el-button type="primary" size="large">返回首页</el-button>
</router-link>
<el-button class="error-btn" type="primary" size="large" @click="goBack">返回上一页</el-button>
</div>
</div>
</template>
<script setup lang="ts" name="403">
import { useRouter } from 'vue-router';
const router = useRouter();
const goBack = () => {
router.go(-2);
};
</script>
<style scoped>
.error-page {
display: flex;
justify-content: center;
align-items: center;
flex-direction: column;
width: 100%;
height: 100%;
background: #f3f3f3;
box-sizing: border-box;
}
.error-code {
line-height: 1;
font-size: 250px;
font-weight: bolder;
color: #f02d2d;
}
.error-code span {
color: #00a854;
}
.error-desc {
font-size: 30px;
color: #777;
}
.error-handle {
margin-top: 30px;
padding-bottom: 200px;
}
.error-btn {
margin-left: 100px;
}
</style>
|
2301_82000044/my-api-gateway
|
my-api-gateway-admin/src/views/403.vue
|
Vue
|
mit
| 1,070
|
<template>
<div class="error-page">
<div class="error-code">4<span>0</span>4</div>
<div class="error-desc">啊哦~ 你所访问的页面不存在</div>
<div class="error-handle">
<router-link to="/">
<el-button type="primary" size="large">返回首页</el-button>
</router-link>
<el-button class="error-btn" type="primary" size="large" @click="goBack">返回上一页</el-button>
</div>
</div>
</template>
<script setup lang="ts" name="404">
import { useRouter } from 'vue-router';
const router = useRouter();
const goBack = () => {
router.go(-1);
};
</script>
<style scoped>
.error-page {
display: flex;
justify-content: center;
align-items: center;
flex-direction: column;
width: 100%;
height: 100%;
background: #f3f3f3;
box-sizing: border-box;
}
.error-code {
line-height: 1;
font-size: 250px;
font-weight: bolder;
color: #2d8cf0;
}
.error-code span {
color: #00a854;
}
.error-desc {
font-size: 30px;
color: #777;
}
.error-handle {
margin-top: 30px;
padding-bottom: 200px;
}
.error-btn {
margin-left: 100px;
}
</style>
|
2301_82000044/my-api-gateway
|
my-api-gateway-admin/src/views/404.vue
|
Vue
|
mit
| 1,067
|
<template>
<div>
<div class="container">
<div class="handle-box">
<el-input v-model="query.systemId" placeholder="应用标识" class="handle-input mr10"></el-input>
<el-input v-model="query.interfaceId" placeholder="接口标识" class="handle-input mr10"></el-input>
<el-button type="primary" :icon="Search" @click="handleSearch">搜索</el-button>
<el-button type="primary" :icon="Plus">新增</el-button>
</div>
<el-table :data="tableData" border class="table" ref="multipleTable" header-cell-class-name="table-header">
<!-- <el-table-column prop="id" label="ID" width="128" align="center"></el-table-column>-->
<el-table-column prop="systemId" label="系统标识"></el-table-column>
<el-table-column prop="interfaceId" label="接口标识"></el-table-column>
<el-table-column prop="interfaceName" label="接口名称"></el-table-column>
<el-table-column prop="interfaceVersion" label="接口版本"></el-table-column>
<el-table-column label="操作" width="220" align="center">
<template #default="scope">
<el-button text :icon="Edit" @click="handleEdit(scope.$index, scope.row)" v-permiss="15">
编辑
</el-button>
<el-button text :icon="Delete" class="red" @click="handleDelete(scope.$index)" v-permiss="16">
删除
</el-button>
</template>
</el-table-column>
</el-table>
<div class="pagination">
<el-pagination
background
layout="total, prev, pager, next"
:current-page="query.pageIndex"
:page-size="query.pageSize"
:total="pageTotal"
@current-change="handlePageChange"
></el-pagination>
</div>
</div>
<!-- 编辑弹出框 -->
<el-dialog title="编辑" v-model="editVisible" width="30%">
<el-form label-width="70px">
<el-form-item label="用户名">
<el-input v-model="form.name"></el-input>
</el-form-item>
<el-form-item label="地址">
<el-input v-model="form.address"></el-input>
</el-form-item>
</el-form>
<template #footer>
<span class="dialog-footer">
<el-button @click="editVisible = false">取 消</el-button>
<el-button type="primary" @click="saveEdit">确 定</el-button>
</span>
</template>
</el-dialog>
</div>
</template>
<script setup lang="ts" name="basetable">
import { ref, reactive } from 'vue';
import { ElMessage, ElMessageBox } from 'element-plus';
import { Delete, Edit, Search, Plus } from '@element-plus/icons-vue';
import { applicationInterfaceData } from '../api/index';
interface TableItem {
id: number;
name: string;
money: string;
state: string;
date: string;
address: string;
}
const query = reactive({
systemId: '',
interfaceId: '',
pageIndex: 1,
pageSize: 10
});
const tableData = ref<TableItem[]>([]);
const pageTotal = ref(0);
// 获取表格数据
const getData = () => {
applicationInterfaceData(query).then(res => {
tableData.value = res.data.list;
pageTotal.value = res.data.pageTotal || 50;
});
};
getData();
// 查询操作
const handleSearch = () => {
query.pageIndex = 1;
getData();
};
// 分页导航
const handlePageChange = (val: number) => {
query.pageIndex = val;
getData();
};
// 删除操作
const handleDelete = (index: number) => {
// 二次确认删除
ElMessageBox.confirm('确定要删除吗？', '提示', {
type: 'warning'
})
.then(() => {
ElMessage.success('删除成功');
tableData.value.splice(index, 1);
})
.catch(() => {});
};
// 表格编辑时弹窗和保存
const editVisible = ref(false);
let form = reactive({
name: '',
address: ''
});
let idx: number = -1;
const handleEdit = (index: number, row: any) => {
idx = index;
form.name = row.name;
form.address = row.address;
editVisible.value = true;
};
const saveEdit = () => {
editVisible.value = false;
ElMessage.success(`修改第 ${idx + 1} 行成功`);
tableData.value[idx].name = form.name;
tableData.value[idx].address = form.address;
};
</script>
<style scoped>
.handle-box {
margin-bottom: 20px;
}
.handle-select {
width: 120px;
}
.handle-input {
width: 300px;
}
.table {
width: 100%;
font-size: 14px;
}
.red {
color: #F56C6C;
}
.mr10 {
margin-right: 10px;
}
.table-td-thumb {
display: block;
margin: auto;
width: 40px;
height: 40px;
}
</style>
|
2301_82000044/my-api-gateway
|
my-api-gateway-admin/src/views/application_interface.vue
|
Vue
|
mit
| 4,259
|
<template>
<div>
<div class="container">
<div class="handle-box">
<el-input v-model="query.systemId" placeholder="应用标识" class="handle-input mr10"></el-input>
<el-input v-model="query.interfaceId" placeholder="接口标识" class="handle-input mr10"></el-input>
<el-button type="primary" :icon="Search" @click="handleSearch">搜索</el-button>
<el-button type="primary" :icon="Plus">新增</el-button>
</div>
<el-table :data="tableData" border class="table" ref="multipleTable" header-cell-class-name="table-header">
<!-- <el-table-column prop="id" label="ID" width="128" align="center"></el-table-column>-->
<el-table-column prop="systemId" label="系统标识" width="210"></el-table-column>
<el-table-column prop="interfaceId" label="接口标识" width="300"></el-table-column>
<el-table-column prop="methodId" label="方法标识"></el-table-column>
<el-table-column prop="methodName" label="方法名称"></el-table-column>
<el-table-column prop="parameterType" label="参数类型" width="280"></el-table-column>
<el-table-column prop="uri" label="网关接口" width="180"></el-table-column>
<el-table-column prop="httpCommandType" label="接口类型" width="100" align="center"></el-table-column>
<el-table-column label="鉴权" align="center" width="100">
<template #default="scope">
<div v-if="scope.row.auth === 1">
<el-tag :type="'success'">
{{"需鉴权"}}
</el-tag>
</div>
<div v-else>
<el-tag :type="'danger'">
{{"不鉴权"}}
</el-tag>
</div>
</template>
</el-table-column>
<el-table-column label="操作" width="220" align="center">
<template #default="scope">
<el-button text :icon="Edit" @click="handleEdit(scope.$index, scope.row)" v-permiss="15">
编辑
</el-button>
<el-button text :icon="Delete" class="red" @click="handleDelete(scope.$index)" v-permiss="16">
删除
</el-button>
</template>
</el-table-column>
</el-table>
<div class="pagination">
<el-pagination
background
layout="total, prev, pager, next"
:current-page="query.pageIndex"
:page-size="query.pageSize"
:total="pageTotal"
@current-change="handlePageChange"
></el-pagination>
</div>
</div>
<!-- 编辑弹出框 -->
<el-dialog title="编辑" v-model="editVisible" width="30%">
<el-form label-width="70px">
<el-form-item label="用户名">
<el-input v-model="form.name"></el-input>
</el-form-item>
<el-form-item label="地址">
<el-input v-model="form.address"></el-input>
</el-form-item>
</el-form>
<template #footer>
<span class="dialog-footer">
<el-button @click="editVisible = false">取 消</el-button>
<el-button type="primary" @click="saveEdit">确 定</el-button>
</span>
</template>
</el-dialog>
</div>
</template>
<script setup lang="ts" name="basetable">
import { ref, reactive } from 'vue';
import { ElMessage, ElMessageBox } from 'element-plus';
import { Delete, Edit, Search, Plus } from '@element-plus/icons-vue';
import { applicationInterfaceMethodData } from '../api/index';
interface TableItem {
id: number;
name: string;
money: string;
state: string;
date: string;
address: string;
}
const query = reactive({
systemId: '',
interfaceId: '',
pageIndex: 1,
pageSize: 10
});
const tableData = ref<TableItem[]>([]);
const pageTotal = ref(0);
// 获取表格数据
const getData = () => {
applicationInterfaceMethodData(query).then(res => {
tableData.value = res.data.list;
pageTotal.value = res.data.pageTotal || 50;
});
};
getData();
// 查询操作
const handleSearch = () => {
query.pageIndex = 1;
getData();
};
// 分页导航
const handlePageChange = (val: number) => {
query.pageIndex = val;
getData();
};
// 删除操作
const handleDelete = (index: number) => {
// 二次确认删除
ElMessageBox.confirm('确定要删除吗？', '提示', {
type: 'warning'
})
.then(() => {
ElMessage.success('删除成功');
tableData.value.splice(index, 1);
})
.catch(() => {});
};
// 表格编辑时弹窗和保存
const editVisible = ref(false);
let form = reactive({
name: '',
address: ''
});
let idx: number = -1;
const handleEdit = (index: number, row: any) => {
idx = index;
form.name = row.name;
form.address = row.address;
editVisible.value = true;
};
const saveEdit = () => {
editVisible.value = false;
ElMessage.success(`修改第 ${idx + 1} 行成功`);
tableData.value[idx].name = form.name;
tableData.value[idx].address = form.address;
};
</script>
<style scoped>
.handle-box {
margin-bottom: 20px;
}
.handle-select {
width: 120px;
}
.handle-input {
width: 300px;
}
.table {
width: 100%;
font-size: 14px;
}
.red {
color: #F56C6C;
}
.mr10 {
margin-right: 10px;
}
.table-td-thumb {
display: block;
margin: auto;
width: 40px;
height: 40px;
}
</style>
|
2301_82000044/my-api-gateway
|
my-api-gateway-admin/src/views/application_interface_method.vue
|
Vue
|
mit
| 4,944
|
<template>
<div>
<div class="container">
<div class="handle-box">
<el-input v-model="query.systemId" placeholder="应用标识" class="handle-input mr10"></el-input>
<el-input v-model="query.systemName" placeholder="应用名称" class="handle-input mr10"></el-input>
<el-button type="primary" :icon="Search" @click="handleSearch">搜索</el-button>
<el-button type="primary" :icon="Plus">新增</el-button>
</div>
<el-table :data="tableData" border class="table" ref="multipleTable" header-cell-class-name="table-header">
<!-- <el-table-column prop="id" label="ID" width="128" align="center"></el-table-column>-->
<el-table-column prop="systemId" label="系统标识"></el-table-column>
<el-table-column prop="systemName" label="系统名称"></el-table-column>
<el-table-column prop="systemType" label="系统类型"></el-table-column>
<el-table-column prop="systemRegistry" label="注册中心"></el-table-column>
<el-table-column label="操作" width="220" align="center">
<template #default="scope">
<el-button text :icon="Edit" @click="handleEdit(scope.$index, scope.row)" v-permiss="15">
编辑
</el-button>
<el-button text :icon="Delete" class="red" @click="handleDelete(scope.$index)" v-permiss="16">
删除
</el-button>
</template>
</el-table-column>
</el-table>
<div class="pagination">
<el-pagination
background
layout="total, prev, pager, next"
:current-page="query.pageIndex"
:page-size="query.pageSize"
:total="pageTotal"
@current-change="handlePageChange"
></el-pagination>
</div>
</div>
<!-- 编辑弹出框 -->
<el-dialog title="编辑" v-model="editVisible" width="30%">
<el-form label-width="70px">
<el-form-item label="用户名">
<el-input v-model="form.name"></el-input>
</el-form-item>
<el-form-item label="地址">
<el-input v-model="form.address"></el-input>
</el-form-item>
</el-form>
<template #footer>
<span class="dialog-footer">
<el-button @click="editVisible = false">取 消</el-button>
<el-button type="primary" @click="saveEdit">确 定</el-button>
</span>
</template>
</el-dialog>
</div>
</template>
<script setup lang="ts" name="basetable">
import { ref, reactive } from 'vue';
import { ElMessage, ElMessageBox } from 'element-plus';
import { Delete, Edit, Search, Plus } from '@element-plus/icons-vue';
import { applicationSystemData } from '../api/index';
interface TableItem {
id: number;
name: string;
money: string;
state: string;
date: string;
address: string;
}
const query = reactive({
systemId: '',
systemName: '',
pageIndex: 1,
pageSize: 10
});
const tableData = ref<TableItem[]>([]);
const pageTotal = ref(0);
// 获取表格数据
const getData = () => {
applicationSystemData(query).then(res => {
tableData.value = res.data.list;
pageTotal.value = res.data.pageTotal || 50;
});
};
getData();
// 查询操作
const handleSearch = () => {
query.pageIndex = 1;
getData();
};
// 分页导航
const handlePageChange = (val: number) => {
query.pageIndex = val;
getData();
};
// 删除操作
const handleDelete = (index: number) => {
// 二次确认删除
ElMessageBox.confirm('确定要删除吗？', '提示', {
type: 'warning'
})
.then(() => {
ElMessage.success('删除成功');
tableData.value.splice(index, 1);
})
.catch(() => {});
};
// 表格编辑时弹窗和保存
const editVisible = ref(false);
let form = reactive({
name: '',
address: ''
});
let idx: number = -1;
const handleEdit = (index: number, row: any) => {
idx = index;
form.name = row.name;
form.address = row.address;
editVisible.value = true;
};
const saveEdit = () => {
editVisible.value = false;
ElMessage.success(`修改第 ${idx + 1} 行成功`);
tableData.value[idx].name = form.name;
tableData.value[idx].address = form.address;
};
</script>
<style scoped>
.handle-box {
margin-bottom: 20px;
}
.handle-select {
width: 120px;
}
.handle-input {
width: 300px;
}
.table {
width: 100%;
font-size: 14px;
}
.red {
color: #F56C6C;
}
.mr10 {
margin-right: 10px;
}
.table-td-thumb {
display: block;
margin: auto;
width: 40px;
height: 40px;
}
</style>
|
2301_82000044/my-api-gateway
|
my-api-gateway-admin/src/views/application_system.vue
|
Vue
|
mit
| 4,247
|
<template>
<div class="container">
<div class="plugins-tips">
vue-schart：vue.js封装sChart.js的图表组件。 访问地址：
<a href="https://github.com/lin-xin/vue-schart" target="_blank">vue-schart</a>
</div>
<div class="schart-box">
<div class="content-title">柱状图</div>
<schart class="schart" canvasId="bar" :options="options1"></schart>
</div>
<div class="schart-box">
<div class="content-title">折线图</div>
<schart class="schart" canvasId="line" :options="options2"></schart>
</div>
<div class="schart-box">
<div class="content-title">饼状图</div>
<schart class="schart" canvasId="pie" :options="options3"></schart>
</div>
<div class="schart-box">
<div class="content-title">环形图</div>
<schart class="schart" canvasId="ring" :options="options4"></schart>
</div>
</div>
</template>
<script setup lang="ts" name="basecharts">
import Schart from 'vue-schart';
const options1 = {
type: 'bar',
title: {
text: '最近一周各品类销售图'
},
bgColor: '#fbfbfb',
labels: ['周一', '周二', '周三', '周四', '周五'],
datasets: [
{
label: '家电',
fillColor: 'rgba(241, 49, 74, 0.5)',
data: [234, 278, 270, 190, 230]
},
{
label: '百货',
data: [164, 178, 190, 135, 160]
},
{
label: '食品',
data: [144, 198, 150, 235, 120]
}
]
};
const options2 = {
type: 'line',
title: {
text: '最近几个月各品类销售趋势图'
},
bgColor: '#fbfbfb',
labels: ['6月', '7月', '8月', '9月', '10月'],
datasets: [
{
label: '家电',
data: [234, 278, 270, 190, 230]
},
{
label: '百货',
data: [164, 178, 150, 135, 160]
},
{
label: '食品',
data: [114, 138, 200, 235, 190]
}
]
};
const options3 = {
type: 'pie',
title: {
text: '服装品类销售饼状图'
},
legend: {
position: 'left'
},
bgColor: '#fbfbfb',
labels: ['T恤', '牛仔裤', '连衣裙', '毛衣', '七分裤', '短裙', '羽绒服'],
datasets: [
{
data: [334, 278, 190, 235, 260, 200, 141]
}
]
};
const options4 = {
type: 'ring',
title: {
text: '环形三等分'
},
showValue: false,
legend: {
position: 'bottom',
bottom: 40
},
bgColor: '#fbfbfb',
labels: ['vue', 'react', 'angular'],
datasets: [
{
data: [500, 500, 500]
}
]
};
</script>
<style scoped>
.schart-box {
display: inline-block;
margin: 20px;
}
.schart {
width: 600px;
height: 400px;
}
.content-title {
clear: both;
font-weight: 400;
line-height: 50px;
margin: 10px 0;
font-size: 22px;
color: #1f2f3d;
}
</style>
|
2301_82000044/my-api-gateway
|
my-api-gateway-admin/src/views/charts.vue
|
Vue
|
mit
| 2,555
|
<template>
<div>
<el-row :gutter="20">
<el-col :span="8">
<el-card shadow="hover" class="mgb20" style="height: 252px">
<div class="user-info">
<el-avatar :size="120" :src="imgurl" />
<div class="user-info-cont">
<div class="user-info-name">{{ name }}</div>
<div>{{ role }}</div>
</div>
</div>
<div class="user-info-list">
上次登录时间：
<span>2023-01-14</span>
</div>
<div class="user-info-list">
上次登录地点：
<span>东丽</span>
</div>
</el-card>
<el-card shadow="hover" style="height: 252px">
<template #header>
<div class="clearfix">
<span>网关负载</span>
</div>
</template>
廊坊网关
<el-progress :percentage="79.4" color="#42b983"></el-progress>
亦庄网关
<el-progress :percentage="14" color="#f1e05a"></el-progress>
东丽网关
<el-progress :percentage="5.6"></el-progress>
吉林网关
<el-progress :percentage="1" color="#f56c6c"></el-progress>
</el-card>
</el-col>
<el-col :span="16">
<el-row :gutter="20" class="mgb20">
<el-col :span="8">
<el-card shadow="hover" :body-style="{ padding: '0px' }">
<div class="grid-content grid-con-1">
<el-icon class="grid-con-icon"><User /></el-icon>
<div class="grid-cont-right">
<div class="grid-num">20</div>
<div>网关算力</div>
</div>
</div>
</el-card>
</el-col>
<el-col :span="8">
<el-card shadow="hover" :body-style="{ padding: '0px' }">
<div class="grid-content grid-con-2">
<el-icon class="grid-con-icon"><ChatDotRound /></el-icon>
<div class="grid-cont-right">
<div class="grid-num">102</div>
<div>应用服务</div>
</div>
</div>
</el-card>
</el-col>
<el-col :span="8">
<el-card shadow="hover" :body-style="{ padding: '0px' }">
<div class="grid-content grid-con-3">
<el-icon class="grid-con-icon"><Goods /></el-icon>
<div class="grid-cont-right">
<div class="grid-num">5000</div>
<div>QPS总计</div>
</div>
</div>
</el-card>
</el-col>
</el-row>
<el-card shadow="hover" style="height: 403px">
<template #header>
<div class="clearfix">
<span>待办事项</span>
<el-button style="float: right; padding: 3px 0" text>添加</el-button>
</div>
</template>
<el-table :show-header="false" :data="todoList" style="width: 100%">
<el-table-column width="40">
<template #default="scope">
<el-checkbox v-model="scope.row.status"></el-checkbox>
</template>
</el-table-column>
<el-table-column>
<template #default="scope">
<div
class="todo-item"
:class="{
'todo-item-del': scope.row.status
}"
>
{{ scope.row.title }}
</div>
</template>
</el-table-column>
</el-table>
</el-card>
</el-col>
</el-row>
<el-row :gutter="20">
<el-col :span="12">
<el-card shadow="hover">
<schart ref="bar" class="schart" canvasId="bar" :options="options"></schart>
</el-card>
</el-col>
<el-col :span="12">
<el-card shadow="hover">
<schart ref="line" class="schart" canvasId="line" :options="options2"></schart>
</el-card>
</el-col>
</el-row>
</div>
</template>
<script setup lang="ts" name="dashboard">
import Schart from 'vue-schart';
import { reactive } from 'vue';
import imgurl from '../assets/img/img.jpg';
const name = localStorage.getItem('ms_username');
const role: string = name === 'admin' ? '超级管理员' : '普通用户';
const options = {
type: 'bar',
title: {
text: '近一周网关调用压力图'
},
xRorate: 25,
labels: ['周一', '周二', '周三', '周四', '周五'],
datasets: [
{
label: '亦庄网关',
data: [234, 278, 270, 190, 230]
},
{
label: '廊坊网关',
data: [164, 178, 190, 135, 160]
},
{
label: '东丽网关',
data: [144, 198, 150, 235, 120]
}
]
};
const options2 = {
type: 'line',
title: {
text: '最近几个月网关使用售趋势图'
},
labels: ['6月', '7月', '8月', '9月', '10月'],
datasets: [
{
label: '亦庄网关',
data: [234, 278, 270, 190, 230]
},
{
label: '廊坊网关',
data: [164, 178, 150, 135, 160]
},
{
label: '东丽网关',
data: [74, 118, 200, 235, 90]
}
]
};
const todoList = reactive([
{
title: '今天要部署新网关算力5个',
status: false
},
{
title: '今天要为618备战启动压测',
status: false
},
{
title: '今天要处理1000个应用的网关分配',
status: false
},
{
title: '今天要优化网关算力泛化调用性能',
status: false
},
{
title: '今天要推动备战部门完成网关部署使用',
status: true
},
{
title: '今天要对测试数据进行流量回放',
status: true
}
]);
</script>
<style scoped>
.el-row {
margin-bottom: 20px;
}
.grid-content {
display: flex;
align-items: center;
height: 100px;
}
.grid-cont-right {
flex: 1;
text-align: center;
font-size: 14px;
color: #999;
}
.grid-num {
font-size: 30px;
font-weight: bold;
}
.grid-con-icon {
font-size: 50px;
width: 100px;
height: 100px;
text-align: center;
line-height: 100px;
color: #fff;
}
.grid-con-1 .grid-con-icon {
background: rgb(45, 140, 240);
}
.grid-con-1 .grid-num {
color: rgb(45, 140, 240);
}
.grid-con-2 .grid-con-icon {
background: rgb(100, 213, 114);
}
.grid-con-2 .grid-num {
color: rgb(100, 213, 114);
}
.grid-con-3 .grid-con-icon {
background: rgb(242, 94, 67);
}
.grid-con-3 .grid-num {
color: rgb(242, 94, 67);
}
.user-info {
display: flex;
align-items: center;
padding-bottom: 20px;
border-bottom: 2px solid #ccc;
margin-bottom: 20px;
}
.user-info-cont {
padding-left: 50px;
flex: 1;
font-size: 14px;
color: #999;
}
.user-info-cont div:first-child {
font-size: 30px;
color: #222;
}
.user-info-list {
font-size: 14px;
color: #999;
line-height: 25px;
}
.user-info-list span {
margin-left: 70px;
}
.mgb20 {
margin-bottom: 20px;
}
.todo-item {
font-size: 14px;
}
.todo-item-del {
text-decoration: line-through;
color: #999;
}
.schart {
width: 100%;
height: 300px;
}
</style>
|
2301_82000044/my-api-gateway
|
my-api-gateway-admin/src/views/dashboard.vue
|
Vue
|
mit
| 6,346
|
<template>
<div class="container">
<div class="plugins-tips">
如果该框架对你有帮助，那就请作者喝杯饮料吧！<el-icon><ColdDrink /></el-icon> 加微信号linxin_20探讨问题。
</div>
<div>
<img src="https://lin-xin.gitee.io/images/weixin.jpg" />
</div>
</div>
</template>
<script setup lang="ts" name="donate"></script>
<style></style>
|
2301_82000044/my-api-gateway
|
my-api-gateway-admin/src/views/donate.vue
|
Vue
|
mit
| 376
|
<template>
<div class="container">
<div class="plugins-tips">
wangEditor：轻量级 web 富文本编辑器，配置方便，使用简单。 访问地址：
<a href="https://www.wangeditor.com/doc/" target="_blank">wangEditor</a>
</div>
<div class="mgb20" ref="editor"></div>
<el-button type="primary" @click="syncHTML">提交</el-button>
</div>
</template>
<script setup lang="ts" name="editor">
import WangEditor from 'wangeditor';
import { ref, reactive, onMounted, onBeforeUnmount } from 'vue';
const editor = ref(null);
const content = reactive({
html: '',
text: ''
});
let instance: any;
onMounted(() => {
instance = new WangEditor(editor.value);
instance.config.zIndex = 1;
instance.create();
});
onBeforeUnmount(() => {
instance.destroy();
instance = null;
});
const syncHTML = () => {
content.html = instance.txt.html();
console.log(content.html);
};
</script>
<style></style>
|
2301_82000044/my-api-gateway
|
my-api-gateway-admin/src/views/editor.vue
|
Vue
|
mit
| 914
|
<template>
<div>
<div class="container">
<div class="handle-box">
<el-button type="primary" @click="exportXlsx">导出Excel</el-button>
</div>
<el-table :data="tableData" border class="table" header-cell-class-name="table-header">
<el-table-column prop="id" label="ID" width="55" align="center"></el-table-column>
<el-table-column prop="name" label="姓名"></el-table-column>
<el-table-column prop="sno" label="学号"></el-table-column>
<el-table-column prop="class" label="班级"></el-table-column>
<el-table-column prop="age" label="年龄"></el-table-column>
<el-table-column prop="sex" label="性别"></el-table-column>
</el-table>
</div>
</div>
</template>
<script setup lang="ts" name="export">
import { ref } from 'vue';
import * as XLSX from 'xlsx';
interface TableItem {
id: number;
name: string;
sno: string;
class: string;
age: string;
sex: string;
}
const tableData = ref<TableItem[]>([]);
// 获取表格数据
const getData = () => {
tableData.value = [
{
id: 1,
name: '小明',
sno: 'S001',
class: '一班',
age: '10',
sex: '男',
},
{
id: 2,
name: '小红',
sno: 'S002',
class: '一班',
age: '9',
sex: '女',
},
];
};
getData();
const list = [['序号', '姓名', '学号', '班级', '年龄', '性别']];
const exportXlsx = () => {
tableData.value.map((item: any, i: number) => {
const arr: any[] = [i + 1];
arr.push(...[item.name, item.sno, item.class, item.age, item.sex]);
list.push(arr);
});
let WorkSheet = XLSX.utils.aoa_to_sheet(list);
let new_workbook = XLSX.utils.book_new();
XLSX.utils.book_append_sheet(new_workbook, WorkSheet, '第一页');
XLSX.writeFile(new_workbook, `表格.xlsx`);
};
</script>
<style scoped>
.handle-box {
margin-bottom: 20px;
}
.handle-select {
width: 120px;
}
.handle-input {
width: 300px;
}
.table {
width: 100%;
font-size: 14px;
}
.red {
color: #f56c6c;
}
.mr10 {
margin-right: 10px;
}
.table-td-thumb {
display: block;
margin: auto;
width: 40px;
height: 40px;
}
</style>
|
2301_82000044/my-api-gateway
|
my-api-gateway-admin/src/views/export.vue
|
Vue
|
mit
| 2,422
|
<template>
<div class="container">
<div class="form-box">
<el-form ref="formRef" :rules="rules" :model="form" label-width="80px">
<el-form-item label="表单名称" prop="name">
<el-input v-model="form.name"></el-input>
</el-form-item>
<el-form-item label="选择器" prop="region">
<el-select v-model="form.region" placeholder="请选择">
<el-option key="小明" label="小明" value="小明"></el-option>
<el-option key="小红" label="小红" value="小红"></el-option>
<el-option key="小白" label="小白" value="小白"></el-option>
</el-select>
</el-form-item>
<el-form-item label="日期时间">
<el-col :span="11">
<el-form-item prop="date1">
<el-date-picker
type="date"
placeholder="选择日期"
v-model="form.date1"
style="width: 100%"
></el-date-picker>
</el-form-item>
</el-col>
<el-col class="line" :span="2">-</el-col>
<el-col :span="11">
<el-form-item prop="date2">
<el-time-picker placeholder="选择时间" v-model="form.date2" style="width: 100%">
</el-time-picker>
</el-form-item>
</el-col>
</el-form-item>
<el-form-item label="城市级联" prop="options">
<el-cascader :options="options" v-model="form.options"></el-cascader>
</el-form-item>
<el-form-item label="选择开关" prop="delivery">
<el-switch v-model="form.delivery"></el-switch>
</el-form-item>
<el-form-item label="多选框" prop="type">
<el-checkbox-group v-model="form.type">
<el-checkbox label="小明" name="type"></el-checkbox>
<el-checkbox label="小红" name="type"></el-checkbox>
<el-checkbox label="小白" name="type"></el-checkbox>
</el-checkbox-group>
</el-form-item>
<el-form-item label="单选框" prop="resource">
<el-radio-group v-model="form.resource">
<el-radio label="小明"></el-radio>
<el-radio label="小红"></el-radio>
<el-radio label="小白"></el-radio>
</el-radio-group>
</el-form-item>
<el-form-item label="文本框" prop="desc">
<el-input type="textarea" rows="5" v-model="form.desc"></el-input>
</el-form-item>
<el-form-item>
<el-button type="primary" @click="onSubmit(formRef)">表单提交</el-button>
<el-button @click="onReset(formRef)">重置表单</el-button>
</el-form-item>
</el-form>
</div>
</div>
</template>
<script setup lang="ts" name="baseform">
import { reactive, ref } from 'vue';
import { ElMessage } from 'element-plus';
import type { FormInstance, FormRules } from 'element-plus';
const options = [
{
value: 'guangdong',
label: '广东省',
children: [
{
value: 'guangzhou',
label: '广州市',
children: [
{
value: 'tianhe',
label: '天河区',
},
{
value: 'haizhu',
label: '海珠区',
},
],
},
{
value: 'dongguan',
label: '东莞市',
children: [
{
value: 'changan',
label: '长安镇',
},
{
value: 'humen',
label: '虎门镇',
},
],
},
],
},
{
value: 'hunan',
label: '湖南省',
children: [
{
value: 'changsha',
label: '长沙市',
children: [
{
value: 'yuelu',
label: '岳麓区',
},
],
},
],
},
];
const rules: FormRules = {
name: [{ required: true, message: '请输入表单名称', trigger: 'blur' }],
};
const formRef = ref<FormInstance>();
const form = reactive({
name: '',
region: '',
date1: '',
date2: '',
delivery: true,
type: ['小明'],
resource: '小红',
desc: '',
options: [],
});
// 提交
const onSubmit = (formEl: FormInstance | undefined) => {
// 表单校验
if (!formEl) return;
formEl.validate((valid) => {
if (valid) {
console.log(form);
ElMessage.success('提交成功！');
} else {
return false;
}
});
};
// 重置
const onReset = (formEl: FormInstance | undefined) => {
if (!formEl) return;
formEl.resetFields();
};
</script>
|
2301_82000044/my-api-gateway
|
my-api-gateway-admin/src/views/form.vue
|
Vue
|
mit
| 5,637
|
<template>
<div>
<div class="container">
<div class="handle-box">
<el-select v-model="query.groupId" placeholder="网关分组" class="handle-select mr10">
<el-option key="10001" label="廊坊网关" value="10001"></el-option>
<el-option key="10002" label="亦庄网关" value="10002"></el-option>
<el-option key="10003" label="东丽网关" value="10003"></el-option>
</el-select>
<el-input v-model="query.gatewayId" placeholder="网关标识" class="handle-input mr10"></el-input>
<el-button type="primary" :icon="Search" @click="handleSearch">搜索</el-button>
<el-button type="primary" :icon="Plus">新增</el-button>
</div>
<el-table :data="tableData" border class="table" ref="multipleTable" header-cell-class-name="table-header">
<el-table-column prop="id" label="ID" width="55" align="center"></el-table-column>
<el-table-column prop="groupId" label="分组标识"></el-table-column>
<el-table-column prop="gatewayId" label="网关标识"></el-table-column>
<el-table-column prop="systemId" label="系统标识"></el-table-column>
<el-table-column prop="systemName" label="系统名称"></el-table-column>
<el-table-column label="操作" width="220" align="center">
<template #default="scope">
<el-button text :icon="Edit" @click="handleEdit(scope.$index, scope.row)" v-permiss="15">
编辑
</el-button>
<el-button text :icon="Delete" class="red" @click="handleDelete(scope.$index)" v-permiss="16">
删除
</el-button>
</template>
</el-table-column>
</el-table>
<div class="pagination">
<el-pagination
background
layout="total, prev, pager, next"
:current-page="query.pageIndex"
:page-size="query.pageSize"
:total="pageTotal"
@current-change="handlePageChange"
></el-pagination>
</div>
</div>
<!-- 编辑弹出框 -->
<el-dialog title="编辑" v-model="editVisible" width="30%">
<el-form label-width="70px">
<el-form-item label="用户名">
<el-input v-model="form.name"></el-input>
</el-form-item>
<el-form-item label="地址">
<el-input v-model="form.address"></el-input>
</el-form-item>
</el-form>
<template #footer>
<span class="dialog-footer">
<el-button @click="editVisible = false">取 消</el-button>
<el-button type="primary" @click="saveEdit">确 定</el-button>
</span>
</template>
</el-dialog>
</div>
</template>
<script setup lang="ts" name="basetable">
import { ref, reactive } from 'vue';
import { ElMessage, ElMessageBox } from 'element-plus';
import { Delete, Edit, Search, Plus } from '@element-plus/icons-vue';
import { gatewayDistributionData } from '../api/index';
interface TableItem {
id: number;
name: string;
money: string;
state: string;
date: string;
address: string;
}
const query = reactive({
groupId: '',
gatewayId: '',
pageIndex: 1,
pageSize: 10
});
const tableData = ref<TableItem[]>([]);
const pageTotal = ref(0);
// 获取表格数据
const getData = () => {
gatewayDistributionData(query).then(res => {
tableData.value = res.data.list;
pageTotal.value = res.data.pageTotal || 50;
});
};
getData();
// 查询操作
const handleSearch = () => {
query.pageIndex = 1;
getData();
};
// 分页导航
const handlePageChange = (val: number) => {
query.pageIndex = val;
getData();
};
// 删除操作
const handleDelete = (index: number) => {
// 二次确认删除
ElMessageBox.confirm('确定要删除吗？', '提示', {
type: 'warning'
})
.then(() => {
ElMessage.success('删除成功');
tableData.value.splice(index, 1);
})
.catch(() => {});
};
// 表格编辑时弹窗和保存
const editVisible = ref(false);
let form = reactive({
name: '',
address: ''
});
let idx: number = -1;
const handleEdit = (index: number, row: any) => {
idx = index;
form.name = row.name;
form.address = row.address;
editVisible.value = true;
};
const saveEdit = () => {
editVisible.value = false;
ElMessage.success(`修改第 ${idx + 1} 行成功`);
tableData.value[idx].name = form.name;
tableData.value[idx].address = form.address;
};
</script>
<style scoped>
.handle-box {
margin-bottom: 20px;
}
.handle-select {
width: 120px;
}
.handle-input {
width: 300px;
}
.table {
width: 100%;
font-size: 14px;
}
.red {
color: #F56C6C;
}
.mr10 {
margin-right: 10px;
}
.table-td-thumb {
display: block;
margin: auto;
width: 40px;
height: 40px;
}
</style>
|
2301_82000044/my-api-gateway
|
my-api-gateway-admin/src/views/gateway_distribution.vue
|
Vue
|
mit
| 4,465
|
<template>
<div>
<div class="container">
<div class="handle-box">
<el-select v-model="query.groupId" placeholder="网关分组" class="handle-select mr10">
<el-option key="10001" label="廊坊网关" value="10001"></el-option>
<el-option key="10002" label="亦庄网关" value="10002"></el-option>
<el-option key="10003" label="东丽网关" value="10003"></el-option>
</el-select>
<el-button type="primary" :icon="Search" @click="handleSearch">搜索</el-button>
</div>
<el-table :data="tableData" border class="table" ref="multipleTable" header-cell-class-name="table-header">
<el-table-column prop="groupId" label="分组编号" width="128" align="center"></el-table-column>
<el-table-column prop="groupName" label="分组名称"></el-table-column>
<el-table-column label="操作" width="220" align="center">
<template #default="scope">
<el-button text :icon="Edit" @click="handleEdit(scope.$index, scope.row)" v-permiss="15">
编辑
</el-button>
<el-button text :icon="Delete" class="red" @click="handleDelete(scope.$index)" v-permiss="16">
删除
</el-button>
</template>
</el-table-column>
</el-table>
<div class="pagination">
<el-pagination
background
layout="total, prev, pager, next"
:current-page="query.pageIndex"
:page-size="query.pageSize"
:total="pageTotal"
@current-change="handlePageChange"
></el-pagination>
</div>
</div>
<!-- 编辑弹出框 -->
<el-dialog title="编辑" v-model="editVisible" width="30%">
<el-form label-width="70px">
<el-form-item label="用户名">
<el-input v-model="form.name"></el-input>
</el-form-item>
<el-form-item label="地址">
<el-input v-model="form.address"></el-input>
</el-form-item>
</el-form>
<template #footer>
<span class="dialog-footer">
<el-button @click="editVisible = false">取 消</el-button>
<el-button type="primary" @click="saveEdit">确 定</el-button>
</span>
</template>
</el-dialog>
</div>
</template>
<script setup lang="ts" name="basetable">
import { ref, reactive } from 'vue';
import { ElMessage, ElMessageBox } from 'element-plus';
import { Delete, Edit, Search, Plus } from '@element-plus/icons-vue';
import { gatewayServerData } from '../api/index';
interface TableItem {
id: number;
name: string;
money: string;
state: string;
date: string;
address: string;
}
const query = reactive({
groupId: '',
pageIndex: 1,
pageSize: 10
});
const tableData = ref<TableItem[]>([]);
const pageTotal = ref(0);
// 获取表格数据
const getData = () => {
gatewayServerData(query).then(res => {
tableData.value = res.data.list;
pageTotal.value = res.data.pageTotal || 50;
});
};
getData();
// 查询操作
const handleSearch = () => {
query.pageIndex = 1;
getData();
};
// 分页导航
const handlePageChange = (val: number) => {
query.pageIndex = val;
getData();
};
// 删除操作
const handleDelete = (index: number) => {
// 二次确认删除
ElMessageBox.confirm('确定要删除吗？', '提示', {
type: 'warning'
})
.then(() => {
ElMessage.success('删除成功');
tableData.value.splice(index, 1);
})
.catch(() => {});
};
// 表格编辑时弹窗和保存
const editVisible = ref(false);
let form = reactive({
name: '',
address: ''
});
let idx: number = -1;
const handleEdit = (index: number, row: any) => {
idx = index;
form.name = row.name;
form.address = row.address;
editVisible.value = true;
};
const saveEdit = () => {
editVisible.value = false;
ElMessage.success(`修改第 ${idx + 1} 行成功`);
tableData.value[idx].name = form.name;
tableData.value[idx].address = form.address;
};
</script>
<style scoped>
.handle-box {
margin-bottom: 20px;
}
.handle-select {
width: 120px;
}
.handle-input {
width: 300px;
}
.table {
width: 100%;
font-size: 14px;
}
.red {
color: #F56C6C;
}
.mr10 {
margin-right: 10px;
}
.table-td-thumb {
display: block;
margin: auto;
width: 40px;
height: 40px;
}
</style>
|
2301_82000044/my-api-gateway
|
my-api-gateway-admin/src/views/gateway_server.vue
|
Vue
|
mit
| 4,054
|
<template>
<div>
<div class="container">
<div class="handle-box">
<el-select v-model="query.groupId" placeholder="网关分组" class="handle-select mr10">
<el-option key="10001" label="廊坊网关" value="10001"></el-option>
<el-option key="10002" label="亦庄网关" value="10002"></el-option>
<el-option key="10003" label="东丽网关" value="10003"></el-option>
</el-select>
<el-input v-model="query.gatewayId" placeholder="网关标识" class="handle-input mr10"></el-input>
<el-button type="primary" :icon="Search" @click="handleSearch">搜索</el-button>
<el-button type="primary" :icon="Plus">新增</el-button>
</div>
<el-table :data="tableData" border class="table" ref="multipleTable" header-cell-class-name="table-header">
<el-table-column prop="id" label="ID" width="55" align="center"></el-table-column>
<el-table-column prop="groupId" label="分组标识"></el-table-column>
<el-table-column prop="gatewayId" label="网关标识"></el-table-column>
<el-table-column prop="gatewayName" label="网关名称"></el-table-column>
<el-table-column prop="gatewayAddress" label="网关地址"></el-table-column>
<el-table-column label="状态" align="center">
<template #default="scope">
<div v-if="scope.row.status === 1">
<el-tag :type="'success'">
{{"可使用"}}
</el-tag>
</div>
<div v-else>
<el-tag :type="'danger'">
{{"不可用"}}
</el-tag>
</div>
</template>
</el-table-column>
<el-table-column prop="createTime" label="注册时间"></el-table-column>
<el-table-column label="操作" width="220" align="center">
<template #default="scope">
<el-button text :icon="Edit" @click="handleEdit(scope.$index, scope.row)" v-permiss="15">
编辑
</el-button>
<el-button text :icon="Delete" class="red" @click="handleDelete(scope.$index)" v-permiss="16">
删除
</el-button>
</template>
</el-table-column>
</el-table>
<div class="pagination">
<el-pagination
background
layout="total, prev, pager, next"
:current-page="query.pageIndex"
:page-size="query.pageSize"
:total="pageTotal"
@current-change="handlePageChange"
></el-pagination>
</div>
</div>
<!-- 编辑弹出框 -->
<el-dialog title="编辑" v-model="editVisible" width="30%">
<el-form label-width="70px">
<el-form-item label="用户名">
<el-input v-model="form.name"></el-input>
</el-form-item>
<el-form-item label="地址">
<el-input v-model="form.address"></el-input>
</el-form-item>
</el-form>
<template #footer>
<span class="dialog-footer">
<el-button @click="editVisible = false">取 消</el-button>
<el-button type="primary" @click="saveEdit">确 定</el-button>
</span>
</template>
</el-dialog>
</div>
</template>
<script setup lang="ts" name="basetable">
import { ref, reactive } from 'vue';
import { ElMessage, ElMessageBox } from 'element-plus';
import { Delete, Edit, Search, Plus } from '@element-plus/icons-vue';
import { gatewayServerDetailData } from '../api/index';
interface TableItem {
id: number;
name: string;
money: string;
state: string;
date: string;
address: string;
}
const query = reactive({
groupId: '',
gatewayId: '',
pageIndex: 1,
pageSize: 10
});
const tableData = ref<TableItem[]>([]);
const pageTotal = ref(0);
// 获取表格数据
const getData = () => {
gatewayServerDetailData(query).then(res => {
tableData.value = res.data.list;
pageTotal.value = res.data.pageTotal || 50;
});
};
getData();
// 查询操作
const handleSearch = () => {
query.pageIndex = 1;
getData();
};
// 分页导航
const handlePageChange = (val: number) => {
query.pageIndex = val;
getData();
};
// 删除操作
const handleDelete = (index: number) => {
// 二次确认删除
ElMessageBox.confirm('确定要删除吗？', '提示', {
type: 'warning'
})
.then(() => {
ElMessage.success('删除成功');
tableData.value.splice(index, 1);
})
.catch(() => {});
};
// 表格编辑时弹窗和保存
const editVisible = ref(false);
let form = reactive({
name: '',
address: ''
});
let idx: number = -1;
const handleEdit = (index: number, row: any) => {
idx = index;
form.name = row.name;
form.address = row.address;
editVisible.value = true;
};
const saveEdit = () => {
editVisible.value = false;
ElMessage.success(`修改第 ${idx + 1} 行成功`);
tableData.value[idx].name = form.name;
tableData.value[idx].address = form.address;
};
</script>
<style scoped>
.handle-box {
margin-bottom: 20px;
}
.handle-select {
width: 120px;
}
.handle-input {
width: 300px;
}
.table {
width: 100%;
font-size: 14px;
}
.red {
color: #F56C6C;
}
.mr10 {
margin-right: 10px;
}
.table-td-thumb {
display: block;
margin: auto;
width: 40px;
height: 40px;
}
</style>
|
2301_82000044/my-api-gateway
|
my-api-gateway-admin/src/views/gateway_server_detail.vue
|
Vue
|
mit
| 4,912
|
<template>
<v-header />
<v-sidebar />
<div class="content-box" :class="{ 'content-collapse': sidebar.collapse }">
<v-tags></v-tags>
<div class="content">
<router-view v-slot="{ Component }">
<transition name="move" mode="out-in">
<keep-alive :include="tags.nameList">
<component :is="Component"></component>
</keep-alive>
</transition>
</router-view>
</div>
</div>
</template>
<script setup lang="ts">
import { useSidebarStore } from '../store/sidebar';
import { useTagsStore } from '../store/tags';
import vHeader from '../components/header.vue';
import vSidebar from '../components/sidebar.vue';
import vTags from '../components/tags.vue';
const sidebar = useSidebarStore();
const tags = useTagsStore();
</script>
|
2301_82000044/my-api-gateway
|
my-api-gateway-admin/src/views/home.vue
|
Vue
|
mit
| 757
|
<template>
<div class="container">
<h2>使用方法</h2>
<p style="line-height: 50px">
直接通过设置类名为 el-icon-lx-iconName 来使用即可。例如：（共{{ iconList.length }}个图标）
</p>
<p class="example-p">
<i class="el-icon-lx-redpacket_fill" style="font-size: 30px; color: #ff5900"></i>
<span><i class="el-icon-lx-redpacket_fill"></i></span>
</p>
<p class="example-p">
<i class="el-icon-lx-weibo" style="font-size: 30px; color: #fd5656"></i>
<span><i class="el-icon-lx-weibo"></i></span>
</p>
<p class="example-p">
<i class="el-icon-lx-emojifill" style="font-size: 30px; color: #ffc300"></i>
<span><i class="el-icon-lx-emojifill"></i></span>
</p>
<br />
<h2>图标</h2>
<div class="search-box">
<el-input class="search" size="large" v-model="keyword" clearable placeholder="请输入图标名称"></el-input>
</div>
<ul>
<li class="icon-li" v-for="(item, index) in list" :key="index">
<div class="icon-li-content">
<i :class="`el-icon-lx-${item}`"></i>
<span>{{ item }}</span>
</div>
</li>
</ul>
</div>
</template>
<script setup lang="ts" name="icon">
import { computed, ref } from 'vue';
const iconList: Array<string> = [
'attentionforbid',
'attentionforbidfill',
'attention',
'attentionfill',
'tag',
'tagfill',
'people',
'peoplefill',
'notice',
'noticefill',
'mobile',
'mobilefill',
'voice',
'voicefill',
'unlock',
'lock',
'home',
'homefill',
'delete',
'deletefill',
'notification',
'notificationfill',
'notificationforbidfill',
'like',
'likefill',
'comment',
'commentfill',
'camera',
'camerafill',
'warn',
'warnfill',
'time',
'timefill',
'location',
'locationfill',
'favor',
'favorfill',
'skin',
'skinfill',
'news',
'newsfill',
'record',
'recordfill',
'emoji',
'emojifill',
'message',
'messagefill',
'goods',
'goodsfill',
'crown',
'crownfill',
'move',
'add',
'hot',
'hotfill',
'service',
'servicefill',
'present',
'presentfill',
'pic',
'picfill',
'rank',
'rankfill',
'male',
'female',
'down',
'top',
'recharge',
'rechargefill',
'forward',
'forwardfill',
'info',
'infofill',
'redpacket',
'redpacket_fill',
'roundadd',
'roundaddfill',
'friendadd',
'friendaddfill',
'cart',
'cartfill',
'more',
'moreandroid',
'back',
'right',
'shop',
'shopfill',
'question',
'questionfill',
'roundclose',
'roundclosefill',
'roundcheck',
'roundcheckfill',
'global',
'mail',
'punch',
'exit',
'upload',
'read',
'file',
'link',
'full',
'group',
'friend',
'profile',
'addressbook',
'calendar',
'text',
'copy',
'share',
'wifi',
'vipcard',
'weibo',
'remind',
'refresh',
'filter',
'settings',
'scan',
'qrcode',
'cascades',
'apps',
'sort',
'searchlist',
'search',
'edit'
];
const keyword = ref('');
const list = computed(() => {
return iconList.filter(item => {
return item.indexOf(keyword.value) !== -1;
});
});
</script>
<style scoped>
.example-p {
height: 45px;
display: flex;
align-items: center;
}
.search-box {
text-align: center;
margin-top: 10px;
}
.search {
width: 300px;
}
ul,
li {
list-style: none;
}
.icon-li {
display: inline-block;
padding: 10px;
width: 120px;
height: 120px;
}
.icon-li-content {
display: flex;
height: 100%;
flex-direction: column;
align-items: center;
justify-content: center;
cursor: pointer;
}
.icon-li-content i {
font-size: 36px;
color: #606266;
}
.icon-li-content span {
margin-top: 10px;
color: #787878;
}
</style>
|
2301_82000044/my-api-gateway
|
my-api-gateway-admin/src/views/icon.vue
|
Vue
|
mit
| 3,551
|
<template>
<div>
<div class="container">
<div class="handle-box">
<el-upload
action="#"
:limit="1"
accept=".xlsx, .xls"
:show-file-list="false"
:before-upload="beforeUpload"
:http-request="handleMany"
>
<el-button class="mr10" type="success">批量导入</el-button>
</el-upload>
<el-link href="/template.xlsx" target="_blank">下载模板</el-link>
</div>
<el-table :data="tableData" border class="table" header-cell-class-name="table-header">
<el-table-column prop="id" label="ID" width="55" align="center"></el-table-column>
<el-table-column prop="name" label="姓名"></el-table-column>
<el-table-column prop="sno" label="学号"></el-table-column>
<el-table-column prop="class" label="班级"></el-table-column>
<el-table-column prop="age" label="年龄"></el-table-column>
<el-table-column prop="sex" label="性别"></el-table-column>
</el-table>
</div>
</div>
</template>
<script setup lang="ts" name="import">
import { UploadProps } from 'element-plus';
import { ref, reactive } from 'vue';
import * as XLSX from 'xlsx';
interface TableItem {
id: number;
name: string;
sno: string;
class: string;
age: string;
sex: string;
}
const tableData = ref<TableItem[]>([]);
// 获取表格数据
const getData = () => {
tableData.value = [
{
id: 1,
name: '小明',
sno: 'S001',
class: '一班',
age: '10',
sex: '男',
},
{
id: 2,
name: '小红',
sno: 'S002',
class: '一班',
age: '9',
sex: '女',
},
];
};
getData();
const importList = ref<any>([]);
const beforeUpload: UploadProps['beforeUpload'] = async (rawFile) => {
importList.value = await analysisExcel(rawFile);
return true;
};
const analysisExcel = (file: any) => {
return new Promise(function (resolve, reject) {
const reader = new FileReader();
reader.onload = function (e: any) {
const data = e.target.result;
let datajson = XLSX.read(data, {
type: 'binary',
});
const sheetName = datajson.SheetNames[0];
const result = XLSX.utils.sheet_to_json(datajson.Sheets[sheetName]);
resolve(result);
};
reader.readAsBinaryString(file);
});
};
const handleMany = async () => {
// 把数据传给服务器后获取最新列表，这里只是示例，不做请求
const list = importList.value.map((item: any, index: number) => {
return {
id: index,
name: item['姓名'],
sno: item['学号'],
class: item['班级'],
age: item['年龄'],
sex: item['性别'],
};
});
tableData.value.push(...list);
};
</script>
<style scoped>
.handle-box {
display: flex;
margin-bottom: 20px;
}
.table {
width: 100%;
font-size: 14px;
}
.mr10 {
margin-right: 10px;
}
</style>
|
2301_82000044/my-api-gateway
|
my-api-gateway-admin/src/views/import.vue
|
Vue
|
mit
| 3,354
|
<template>
<div class="login-wrap">
<div class="ms-login">
<div class="ms-title">后台管理系统</div>
<el-form :model="param" :rules="rules" ref="login" label-width="0px" class="ms-content">
<el-form-item prop="username">
<el-input v-model="param.username" placeholder="username">
<template #prepend>
<el-button :icon="User"></el-button>
</template>
</el-input>
</el-form-item>
<el-form-item prop="password">
<el-input
type="password"
placeholder="password"
v-model="param.password"
@keyup.enter="submitForm(login)"
>
<template #prepend>
<el-button :icon="Lock"></el-button>
</template>
</el-input>
</el-form-item>
<div class="login-btn">
<el-button type="primary" @click="submitForm(login)">登录</el-button>
</div>
<p class="login-tips">Tips : 用户名和密码随便填。</p>
</el-form>
</div>
</div>
</template>
<script setup lang="ts">
import { ref, reactive } from 'vue';
import { useTagsStore } from '../store/tags';
import { usePermissStore } from '../store/permiss';
import { useRouter } from 'vue-router';
import { ElMessage } from 'element-plus';
import type { FormInstance, FormRules } from 'element-plus';
import { Lock, User } from '@element-plus/icons-vue';
interface LoginInfo {
username: string;
password: string;
}
const router = useRouter();
const param = reactive<LoginInfo>({
username: 'admin',
password: '123123'
});
const rules: FormRules = {
username: [
{
required: true,
message: '请输入用户名',
trigger: 'blur'
}
],
password: [{ required: true, message: '请输入密码', trigger: 'blur' }]
};
const permiss = usePermissStore();
const login = ref<FormInstance>();
const submitForm = (formEl: FormInstance | undefined) => {
if (!formEl) return;
formEl.validate((valid: boolean) => {
if (valid) {
ElMessage.success('登录成功');
localStorage.setItem('ms_username', param.username);
const keys = permiss.defaultList[param.username == 'admin' ? 'admin' : 'user'];
permiss.handleSet(keys);
localStorage.setItem('ms_keys', JSON.stringify(keys));
router.push('/');
} else {
ElMessage.error('登录成功');
return false;
}
});
};
const tags = useTagsStore();
tags.clearTags();
</script>
<style scoped>
.login-wrap {
position: relative;
width: 100%;
height: 100%;
background-image: url(src/assets/img/login-bg.jpg);
background-size: 100%;
}
.ms-title {
width: 100%;
line-height: 50px;
text-align: center;
font-size: 20px;
color: #fff;
border-bottom: 1px solid #ddd;
}
.ms-login {
position: absolute;
left: 50%;
top: 50%;
width: 350px;
margin: -190px 0 0 -175px;
border-radius: 5px;
background: rgba(255, 255, 255, 0.3);
overflow: hidden;
}
.ms-content {
padding: 30px 30px;
}
.login-btn {
text-align: center;
}
.login-btn button {
width: 100%;
height: 36px;
margin-bottom: 10px;
}
.login-tips {
font-size: 12px;
line-height: 30px;
color: #fff;
}
</style>
|
2301_82000044/my-api-gateway
|
my-api-gateway-admin/src/views/login.vue
|
Vue
|
mit
| 3,011
|
<template>
<div class="container">
<div class="plugins-tips">
md-editor-v3：vue3版本的 markdown 编辑器，配置丰富，请详看文档。 访问地址：
<a href="https://imzbf.github.io/md-editor-v3/index" target="_blank">md-editor-v3</a>
</div>
<md-editor class="mgb20" v-model="text" @on-upload-img="onUploadImg" />
<el-button type="primary">提交</el-button>
</div>
</template>
<script setup lang="ts" name="md">
import { ref } from 'vue';
import MdEditor from 'md-editor-v3';
import 'md-editor-v3/lib/style.css';
const text = ref('Hello Editor!');
const onUploadImg = (files: any) => {
console.log(files);
};
</script>
|
2301_82000044/my-api-gateway
|
my-api-gateway-admin/src/views/markdown.vue
|
Vue
|
mit
| 652
|
<template>
<div class="container">
<div class="plugins-tips">通过 v-permiss 自定义指令实现权限管理，使用非 admin 账号登录，可查看效果。</div>
<div class="mgb20">
<span class="label">角色：</span>
<el-select v-model="role" @change="handleChange">
<el-option label="超级管理员" value="admin"></el-option>
<el-option label="普通用户" value="user"></el-option>
</el-select>
</div>
<div class="mgb20 tree-wrapper">
<el-tree
ref="tree"
:data="data"
node-key="id"
default-expand-all
show-checkbox
:default-checked-keys="checkedKeys"
/>
</div>
<el-button type="primary" @click="onSubmit">保存权限</el-button>
</div>
</template>
<script setup lang="ts" name="permission">
import { ref } from 'vue';
import { ElTree } from 'element-plus';
import { usePermissStore } from '../store/permiss';
const role = ref<string>('admin');
interface Tree {
id: string;
label: string;
children?: Tree[];
}
const data: Tree[] = [
{
id: '1',
label: '系统首页'
},
{
id: '2',
label: '基础表格',
children: [
{
id: '15',
label: '编辑'
},
{
id: '16',
label: '删除'
}
]
},
{
id: '3',
label: 'tab选项卡'
},
{
id: '4',
label: '表单相关',
children: [
{
id: '5',
label: '基本表单'
},
{
id: '6',
label: '文件上传'
},
{
id: '7',
label: '三级菜单',
children: [
{
id: '8',
label: '富文本编辑器'
},
{
id: '9',
label: 'markdown编辑器'
}
]
}
]
},
{
id: '10',
label: '自定义图标'
},
{
id: '11',
label: 'schart图表'
},
{
id: '13',
label: '权限管理'
},
{
id: '14',
label: '支持作者'
}
];
const permiss = usePermissStore();
// 获取当前权限
const checkedKeys = ref<string[]>([]);
const getPremission = () => {
// 请求接口返回权限
checkedKeys.value = permiss.defaultList[role.value];
};
getPremission();
// 保存权限
const tree = ref<InstanceType<typeof ElTree>>();
const onSubmit = () => {
// 获取选中的权限
console.log(tree.value!.getCheckedKeys(false));
};
const handleChange = (val: string[]) => {
tree.value!.setCheckedKeys(permiss.defaultList[role.value]);
};
</script>
<style scoped>
.tree-wrapper {
max-width: 500px;
}
.label {
font-size: 14px;
}
</style>
|
2301_82000044/my-api-gateway
|
my-api-gateway-admin/src/views/permission.vue
|
Vue
|
mit
| 2,396
|
<template>
<div>
<div class="container">
<div class="handle-box">
<el-select v-model="query.address" placeholder="地址" class="handle-select mr10">
<el-option key="1" label="广东省" value="广东省"></el-option>
<el-option key="2" label="湖南省" value="湖南省"></el-option>
</el-select>
<el-input v-model="query.name" placeholder="用户名" class="handle-input mr10"></el-input>
<el-button type="primary" :icon="Search" @click="handleSearch">搜索</el-button>
<el-button type="primary" :icon="Plus">新增</el-button>
</div>
<el-table :data="tableData" border class="table" ref="multipleTable" header-cell-class-name="table-header">
<el-table-column prop="id" label="ID" width="55" align="center"></el-table-column>
<el-table-column prop="name" label="用户名"></el-table-column>
<el-table-column label="账户余额">
<template #default="scope">￥{{ scope.row.money }}</template>
</el-table-column>
<el-table-column label="头像(查看大图)" align="center">
<template #default="scope">
<el-image
class="table-td-thumb"
:src="scope.row.thumb"
:z-index="10"
:preview-src-list="[scope.row.thumb]"
preview-teleported
>
</el-image>
</template>
</el-table-column>
<el-table-column prop="address" label="地址"></el-table-column>
<el-table-column label="状态" align="center">
<template #default="scope">
<el-tag
:type="scope.row.state === '成功' ? 'success' : scope.row.state === '失败' ? 'danger' : ''"
>
{{ scope.row.state }}
</el-tag>
</template>
</el-table-column>
<el-table-column prop="date" label="注册时间"></el-table-column>
<el-table-column label="操作" width="220" align="center">
<template #default="scope">
<el-button text :icon="Edit" @click="handleEdit(scope.$index, scope.row)" v-permiss="15">
编辑
</el-button>
<el-button text :icon="Delete" class="red" @click="handleDelete(scope.$index)" v-permiss="16">
删除
</el-button>
</template>
</el-table-column>
</el-table>
<div class="pagination">
<el-pagination
background
layout="total, prev, pager, next"
:current-page="query.pageIndex"
:page-size="query.pageSize"
:total="pageTotal"
@current-change="handlePageChange"
></el-pagination>
</div>
</div>
<!-- 编辑弹出框 -->
<el-dialog title="编辑" v-model="editVisible" width="30%">
<el-form label-width="70px">
<el-form-item label="用户名">
<el-input v-model="form.name"></el-input>
</el-form-item>
<el-form-item label="地址">
<el-input v-model="form.address"></el-input>
</el-form-item>
</el-form>
<template #footer>
<span class="dialog-footer">
<el-button @click="editVisible = false">取 消</el-button>
<el-button type="primary" @click="saveEdit">确 定</el-button>
</span>
</template>
</el-dialog>
</div>
</template>
<script setup lang="ts" name="basetable">
import { ref, reactive } from 'vue';
import { ElMessage, ElMessageBox } from 'element-plus';
import { Delete, Edit, Search, Plus } from '@element-plus/icons-vue';
import { fetchData } from '../api/index';
interface TableItem {
id: number;
name: string;
money: string;
state: string;
date: string;
address: string;
}
const query = reactive({
address: '',
name: '',
pageIndex: 1,
pageSize: 10
});
const tableData = ref<TableItem[]>([]);
const pageTotal = ref(0);
// 获取表格数据
const getData = () => {
fetchData().then(res => {
tableData.value = res.data.list;
pageTotal.value = res.data.pageTotal || 50;
});
};
getData();
// 查询操作
const handleSearch = () => {
query.pageIndex = 1;
getData();
};
// 分页导航
const handlePageChange = (val: number) => {
query.pageIndex = val;
getData();
};
// 删除操作
const handleDelete = (index: number) => {
// 二次确认删除
ElMessageBox.confirm('确定要删除吗？', '提示', {
type: 'warning'
})
.then(() => {
ElMessage.success('删除成功');
tableData.value.splice(index, 1);
})
.catch(() => {});
};
// 表格编辑时弹窗和保存
const editVisible = ref(false);
let form = reactive({
name: '',
address: ''
});
let idx: number = -1;
const handleEdit = (index: number, row: any) => {
idx = index;
form.name = row.name;
form.address = row.address;
editVisible.value = true;
};
const saveEdit = () => {
editVisible.value = false;
ElMessage.success(`修改第 ${idx + 1} 行成功`);
tableData.value[idx].name = form.name;
tableData.value[idx].address = form.address;
};
</script>
<style scoped>
.handle-box {
margin-bottom: 20px;
}
.handle-select {
width: 120px;
}
.handle-input {
width: 300px;
}
.table {
width: 100%;
font-size: 14px;
}
.red {
color: #F56C6C;
}
.mr10 {
margin-right: 10px;
}
.table-td-thumb {
display: block;
margin: auto;
width: 40px;
height: 40px;
}
</style>
|
2301_82000044/my-api-gateway
|
my-api-gateway-admin/src/views/table.vue
|
Vue
|
mit
| 4,997
|
<template>
<div class="container">
<el-tabs v-model="message">
<el-tab-pane :label="`未读消息(${state.unread.length})`" name="first">
<el-table :data="state.unread" :show-header="false" style="width: 100%">
<el-table-column>
<template #default="scope">
<span class="message-title">{{ scope.row.title }}</span>
</template>
</el-table-column>
<el-table-column prop="date" width="180"></el-table-column>
<el-table-column width="120">
<template #default="scope">
<el-button size="small" @click="handleRead(scope.$index)">标为已读</el-button>
</template>
</el-table-column>
</el-table>
<div class="handle-row">
<el-button type="primary">全部标为已读</el-button>
</div>
</el-tab-pane>
<el-tab-pane :label="`已读消息(${state.read.length})`" name="second">
<template v-if="message === 'second'">
<el-table :data="state.read" :show-header="false" style="width: 100%">
<el-table-column>
<template #default="scope">
<span class="message-title">{{ scope.row.title }}</span>
</template>
</el-table-column>
<el-table-column prop="date" width="150"></el-table-column>
<el-table-column width="120">
<template #default="scope">
<el-button type="danger" @click="handleDel(scope.$index)">删除</el-button>
</template>
</el-table-column>
</el-table>
<div class="handle-row">
<el-button type="danger">删除全部</el-button>
</div>
</template>
</el-tab-pane>
<el-tab-pane :label="`回收站(${state.recycle.length})`" name="third">
<template v-if="message === 'third'">
<el-table :data="state.recycle" :show-header="false" style="width: 100%">
<el-table-column>
<template #default="scope">
<span class="message-title">{{ scope.row.title }}</span>
</template>
</el-table-column>
<el-table-column prop="date" width="150"></el-table-column>
<el-table-column width="120">
<template #default="scope">
<el-button @click="handleRestore(scope.$index)">还原</el-button>
</template>
</el-table-column>
</el-table>
<div class="handle-row">
<el-button type="danger">清空回收站</el-button>
</div>
</template>
</el-tab-pane>
</el-tabs>
</div>
</template>
<script setup lang="ts" name="tabs">
import { ref, reactive } from 'vue';
const message = ref('first');
const state = reactive({
unread: [
{
date: '2018-04-19 20:00:00',
title: '【系统通知】该系统将于今晚凌晨2点到5点进行升级维护'
},
{
date: '2018-04-19 21:00:00',
title: '今晚12点整发大红包，先到先得'
}
],
read: [
{
date: '2018-04-19 20:00:00',
title: '【系统通知】该系统将于今晚凌晨2点到5点进行升级维护'
}
],
recycle: [
{
date: '2018-04-19 20:00:00',
title: '【系统通知】该系统将于今晚凌晨2点到5点进行升级维护'
}
]
});
const handleRead = (index: number) => {
const item = state.unread.splice(index, 1);
state.read = item.concat(state.read);
};
const handleDel = (index: number) => {
const item = state.read.splice(index, 1);
state.recycle = item.concat(state.recycle);
};
const handleRestore = (index: number) => {
const item = state.recycle.splice(index, 1);
state.read = item.concat(state.read);
};
</script>
<style>
.message-title {
cursor: pointer;
}
.handle-row {
margin-top: 30px;
}
</style>
|
2301_82000044/my-api-gateway
|
my-api-gateway-admin/src/views/tabs.vue
|
Vue
|
mit
| 3,514
|
<template>
<div class="container">
<div class="content-title">支持拖拽</div>
<div class="plugins-tips">
Element Plus自带上传组件。 访问地址：
<a href="https://element-plus.org/zh-CN/component/upload.html" target="_blank">Element Plus Upload</a>
</div>
<el-upload
class="upload-demo"
drag
action="http://jsonplaceholder.typicode.com/api/posts/"
multiple
:on-change="handle"
>
<el-icon class="el-icon--upload"><upload-filled /></el-icon>
<div class="el-upload__text">
将文件拖到此处，或
<em>点击上传</em>
</div>
</el-upload>
<div class="content-title">支持裁剪</div>
<div class="plugins-tips">
vue-cropperjs：一个封装了 cropperjs 的 Vue 组件。 访问地址：
<a href="https://github.com/Agontuk/vue-cropperjs" target="_blank">vue-cropperjs</a>。 示例请查看
<router-link to="/user">个人中心</router-link>
</div>
</div>
</template>
<script setup lang="ts">
const handle = (rawFile: any) => {
console.log(rawFile);
};
</script>
<style scoped>
.content-title {
font-weight: 400;
line-height: 50px;
margin: 10px 0;
font-size: 22px;
color: #1f2f3d;
}
.upload-demo {
width: 360px;
}
</style>
|
2301_82000044/my-api-gateway
|
my-api-gateway-admin/src/views/upload.vue
|
Vue
|
mit
| 1,436
|
<template>
<div>
<el-row :gutter="20">
<el-col :span="12">
<el-card shadow="hover">
<template #header>
<div class="clearfix">
<span>基础信息</span>
</div>
</template>
<div class="info">
<div class="info-image" @click="showDialog">
<el-avatar :size="100" :src="avatarImg" />
<span class="info-edit">
<i class="el-icon-lx-camerafill"></i>
</span>
</div>
<div class="info-name">{{ name }}</div>
<div class="info-desc">不可能！我的代码怎么可能会有bug！</div>
</div>
</el-card>
</el-col>
<el-col :span="12">
<el-card shadow="hover">
<template #header>
<div class="clearfix">
<span>账户编辑</span>
</div>
</template>
<el-form label-width="90px">
<el-form-item label="用户名："> {{ name }} </el-form-item>
<el-form-item label="旧密码：">
<el-input type="password" v-model="form.old"></el-input>
</el-form-item>
<el-form-item label="新密码：">
<el-input type="password" v-model="form.new"></el-input>
</el-form-item>
<el-form-item label="个人简介：">
<el-input v-model="form.desc"></el-input>
</el-form-item>
<el-form-item>
<el-button type="primary" @click="onSubmit">保存</el-button>
</el-form-item>
</el-form>
</el-card>
</el-col>
</el-row>
<el-dialog title="裁剪图片" v-model="dialogVisible" width="600px">
<vue-cropper
ref="cropper"
:src="imgSrc"
:ready="cropImage"
:zoom="cropImage"
:cropmove="cropImage"
style="width: 100%; height: 400px"
></vue-cropper>
<template #footer>
<span class="dialog-footer">
<el-button class="crop-demo-btn" type="primary"
>选择图片
<input class="crop-input" type="file" name="image" accept="image/*" @change="setImage" />
</el-button>
<el-button type="primary" @click="saveAvatar">上传并保存</el-button>
</span>
</template>
</el-dialog>
</div>
</template>
<script setup lang="ts" name="user">
import { reactive, ref } from 'vue';
import VueCropper from 'vue-cropperjs';
import 'cropperjs/dist/cropper.css';
import avatar from '../assets/img/img.jpg';
const name = localStorage.getItem('ms_username');
const form = reactive({
old: '',
new: '',
desc: '不可能！我的代码怎么可能会有bug！'
});
const onSubmit = () => {};
const avatarImg = ref(avatar);
const imgSrc = ref('');
const cropImg = ref('');
const dialogVisible = ref(false);
const cropper: any = ref();
const showDialog = () => {
dialogVisible.value = true;
imgSrc.value = avatarImg.value;
};
const setImage = (e: any) => {
const file = e.target.files[0];
if (!file.type.includes('image/')) {
return;
}
const reader = new FileReader();
reader.onload = (event: any) => {
dialogVisible.value = true;
imgSrc.value = event.target.result;
cropper.value && cropper.value.replace(event.target.result);
};
reader.readAsDataURL(file);
};
const cropImage = () => {
cropImg.value = cropper.value.getCroppedCanvas().toDataURL();
};
const saveAvatar = () => {
avatarImg.value = cropImg.value;
dialogVisible.value = false;
};
</script>
<style scoped>
.info {
text-align: center;
padding: 35px 0;
}
.info-image {
position: relative;
margin: auto;
width: 100px;
height: 100px;
background: #f8f8f8;
border: 1px solid #eee;
border-radius: 50px;
overflow: hidden;
}
.info-edit {
display: flex;
justify-content: center;
align-items: center;
position: absolute;
left: 0;
top: 0;
width: 100%;
height: 100%;
background: rgba(0, 0, 0, 0.5);
opacity: 0;
transition: opacity 0.3s ease;
}
.info-edit i {
color: #eee;
font-size: 25px;
}
.info-image:hover .info-edit {
opacity: 1;
}
.info-name {
margin: 15px 0 10px;
font-size: 24px;
font-weight: 500;
color: #262626;
}
.crop-demo-btn {
position: relative;
}
.crop-input {
position: absolute;
width: 100px;
height: 40px;
left: 0;
top: 0;
opacity: 0;
cursor: pointer;
}
</style>
|
2301_82000044/my-api-gateway
|
my-api-gateway-admin/src/views/user.vue
|
Vue
|
mit
| 4,042
|
import { defineConfig } from 'vite';
import vue from '@vitejs/plugin-vue';
import VueSetupExtend from 'vite-plugin-vue-setup-extend';
import AutoImport from 'unplugin-auto-import/vite';
import Components from 'unplugin-vue-components/vite';
import { ElementPlusResolver } from 'unplugin-vue-components/resolvers';
export default defineConfig({
base: './',
plugins: [
vue(),
VueSetupExtend(),
AutoImport({
resolvers: [ElementPlusResolver()]
}),
Components({
resolvers: [ElementPlusResolver()]
})
],
optimizeDeps: {
include: ['schart.js']
}
});
|
2301_82000044/my-api-gateway
|
my-api-gateway-admin/vite.config.ts
|
TypeScript
|
mit
| 568
|
package zack.gateway.assist;
/**
* @author zack
* @description 网关异常
*/
public class GatewayException extends RuntimeException {
public GatewayException(String msg) {
super(msg);
}
public GatewayException(String msg, Throwable cause) {
super(msg, cause);
}
}
|
2301_82000044/my-api-gateway
|
my-api-gateway-assist/src/main/java/zack/gateway/assist/GatewayException.java
|
Java
|
mit
| 309
|
package zack.gateway.assist.application;
import io.netty.channel.Channel;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextClosedEvent;
import zack.gateway.assist.config.GatewayServiceProperties;
import zack.gateway.assist.domain.model.aggregates.ApplicationSystemRichInfo;
import zack.gateway.assist.domain.model.vo.ApplicationInterfaceVO;
import zack.gateway.assist.domain.model.vo.ApplicationSystemVO;
import zack.gateway.assist.domain.service.GatewayCenterService;
import zack.gateway.core.mapping.HttpCommandType;
import zack.gateway.core.mapping.HttpStatement;
import zack.gateway.core.session.Configuration;
import java.util.List;
/** 注册网关算力，拉取rpc服务信息并添加到网关
* @author A1793
*/
public class GatewayApplication implements ApplicationContextAware,ApplicationListener<ContextClosedEvent> {
private Logger logger = LoggerFactory.getLogger(GatewayApplication.class);
private GatewayServiceProperties properties;
private GatewayCenterService gatewayCenterService;
private Configuration configuration;
private Channel channel;
public GatewayApplication(GatewayServiceProperties gatewayServiceProperties,
GatewayCenterService gatewayCenterService,
Configuration configuration,
Channel channel) {
this.properties = gatewayServiceProperties;
this.gatewayCenterService = gatewayCenterService;
this.configuration = configuration;
this.channel = channel;
}
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
// 1. 注册网关服务；每一个用于转换 HTTP 协议泛化调用到 RPC 接口的网关都是一个算力，这些算力需要注册网关配置中心
try{
gatewayCenterService.doRegister(properties.getAddress(),
properties.getGroupId(),
properties.getGatewayId(),
properties.getGatewayName(),
properties.getGatewayAddress());
addMapper("");
}catch (Exception e){
logger.error("网关服务启动失败，停止服务。{}", e.getMessage(), e);
throw e;
}
}
public void addMapper(String systemId) {
ApplicationSystemRichInfo applicationSystemRichInfo = gatewayCenterService.pullApplicationSystemRichInfo(properties.getAddress(),
properties.getGatewayId(),
systemId);
if(applicationSystemRichInfo == null){
logger.warn("网关{}服务注册映射为空，请排查 gatewayCenterService.pullApplicationSystemRichInfo 是否检索到此网关算力需要拉取的配置数据。", systemId);
return;
}
List<ApplicationSystemVO> applicationSystemVOS = applicationSystemRichInfo.getApplicationSystemVOS();
for (ApplicationSystemVO applicationSystemVO : applicationSystemVOS) {
List<ApplicationInterfaceVO> interfaceList = applicationSystemVO.getInterfaceList();
if(interfaceList == null || interfaceList.isEmpty()){
logger.warn("网关{}服务注册映射为空，请排查 gatewayCenterService.pullApplicationSystemRichInfo 是否检索到此网关算力需要拉取的配置数据。", systemId);
return;
}
for (ApplicationInterfaceVO interfaceVO :interfaceList ) {
//设置注册中心的接口信息
configuration.registryConfig(applicationSystemVO.getSystemId(),
applicationSystemVO.getSystemRegistry(),
interfaceVO.getInterfaceId(),
interfaceVO.getInterfaceVersion());
//设置方法调用的映射信息
interfaceVO.getMethodList().forEach(interfaceMethodVO -> {
HttpStatement httpStatement = new HttpStatement(
applicationSystemVO.getSystemId(),
interfaceVO.getInterfaceId(),
interfaceMethodVO.getMethodId(),
interfaceMethodVO.getParameterType(),
interfaceMethodVO.getUri(),
HttpCommandType.valueOf(interfaceMethodVO.getHttpCommandType()),
interfaceMethodVO.isAuth()
);
configuration.addMapper(httpStatement);
logger.info("网关服务注册映射 系统：{} 接口：{} 方法：{}", applicationSystemVO.getSystemId(), interfaceVO.getInterfaceId(), interfaceMethodVO.getMethodId());
});
}
}
}
@Override
public void onApplicationEvent(ContextClosedEvent contextClosedEvent) {
try{
if(channel.isActive()){
logger.info("应用容器关闭，Api网关服务关闭。localAddress：{}", channel.localAddress());
channel.close();
}
}catch(Exception e){
logger.error("应用容器关闭，Api网关服务关闭失败", e);
}
}
public void receiveMessage(Object message){
addMapper(message.toString().substring(1,message.toString().length()-1));
}
}
|
2301_82000044/my-api-gateway
|
my-api-gateway-assist/src/main/java/zack/gateway/assist/application/GatewayApplication.java
|
Java
|
mit
| 5,588
|
package zack.gateway.assist.common;
/**
* @author A1793
*/
public class Result<T> {
String code;
String info;
T data;
public T getData() {
return data;
}
public void setData(T data) {
this.data = data;
}
public String getCode() {
return code;
}
public void setCode(String code) {
this.code = code;
}
public String getInfo() {
return info;
}
public void setInfo(String info) {
this.info = info;
}
}
|
2301_82000044/my-api-gateway
|
my-api-gateway-assist/src/main/java/zack/gateway/assist/common/Result.java
|
Java
|
mit
| 517
|
package zack.gateway.assist.config;
import io.netty.channel.Channel;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.jedis.JedisClientConfiguration;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.listener.PatternTopic;
import org.springframework.data.redis.listener.RedisMessageListenerContainer;
import org.springframework.data.redis.listener.adapter.MessageListenerAdapter;
import redis.clients.jedis.JedisPoolConfig;
import zack.gateway.assist.application.GatewayApplication;
import zack.gateway.assist.domain.service.GatewayCenterService;
import zack.gateway.core.session.Configuration;
import zack.gateway.core.session.defaults.DefaultGatewaySessionFactory;
import zack.gateway.core.socket.GatewaySocketServer;
import java.net.ServerSocket;
import java.time.Duration;
import java.util.Map;
import java.util.concurrent.*;
/**
* @author A1793
*/
@EnableConfigurationProperties(GatewayServiceProperties.class)
public class GatewayAutoConfig {
private Logger logger = LoggerFactory.getLogger(GatewayAutoConfig.class);
@Bean
public GatewayCenterService registerGatewayService() {
return new GatewayCenterService();
}
@Bean
public GatewayApplication gatewayApplication(GatewayServiceProperties properties,
GatewayCenterService gatewayCenterService,
Configuration configuration,
Channel channel) {
return new GatewayApplication(properties, gatewayCenterService,configuration,channel);
}
@Bean
public Configuration configuration(GatewayServiceProperties properties) {
Configuration configuration = new Configuration();
String[] split = properties.getGatewayAddress().split(":");
configuration.setHost(split[0]);
configuration.setPort(Integer.parseInt(split[1]));
return configuration;
}
@Bean
public Channel initGateway(Configuration configuration) throws ExecutionException, InterruptedException {
DefaultGatewaySessionFactory defaultGatewaySessionFactory = new DefaultGatewaySessionFactory(configuration);
GatewaySocketServer serverSocket = new GatewaySocketServer(configuration, defaultGatewaySessionFactory);
Future<Channel> future = Executors.newFixedThreadPool(2).submit(serverSocket);
Channel channel = future.get();
if (null == channel) {
throw new RuntimeException("api gateway core netty server start error channel is null");
}
while(!channel.isActive()){
Thread.sleep(500);
}
return channel;
}
/**
* 根据注册中心的redis配置创建redis连接
* @param properties
* @param gatewayCenterService
* @return
*/
@Bean("connectionFactory")
public RedisConnectionFactory redisConnectionFactory(GatewayServiceProperties properties,GatewayCenterService gatewayCenterService) {
Map<String, String> redisConfig = gatewayCenterService.queryRedisConfig(properties.getAddress());
RedisStandaloneConfiguration redisStandaloneConfiguration = new RedisStandaloneConfiguration();
redisStandaloneConfiguration.setHostName(redisConfig.get("host"));
redisStandaloneConfiguration.setPort(Integer.parseInt(redisConfig.get("port")));
JedisPoolConfig poolConfig = new JedisPoolConfig();
poolConfig.setMaxTotal(100);
poolConfig.setMaxWaitMillis(30 * 1000);
poolConfig.setMinIdle(20);
poolConfig.setMaxIdle(40);
poolConfig.setTestWhileIdle(true);
JedisClientConfiguration jedisClientConfiguration = JedisClientConfiguration.builder()
.connectTimeout(Duration.ofSeconds(30))
.clientName("api-gateway-assist-redis-" + properties.getGatewayId())
.usePooling()
.poolConfig(poolConfig).build();
return new JedisConnectionFactory(redisStandaloneConfiguration, jedisClientConfiguration);
}
/**
* 设置消息监听
* @param properties
* @param redisConnectionFactory
* @param listenerAdapter
* @return
*/
@Bean
public RedisMessageListenerContainer messageListenerContainer(GatewayServiceProperties properties,
@Qualifier("connectionFactory") RedisConnectionFactory redisConnectionFactory,
MessageListenerAdapter listenerAdapter) {
RedisMessageListenerContainer container = new RedisMessageListenerContainer();
container.setConnectionFactory(redisConnectionFactory);
container.addMessageListener(listenerAdapter,new PatternTopic(properties.getGatewayId()));
return container;
}
/**
* 设置监听适配器，当收到信息时调用的方法
* @param gatewayApplication
* @return
*/
@Bean
public MessageListenerAdapter messageListenerAdapter(GatewayApplication gatewayApplication) {
return new MessageListenerAdapter(gatewayApplication,"receiveMessage");
}
}
|
2301_82000044/my-api-gateway
|
my-api-gateway-assist/src/main/java/zack/gateway/assist/config/GatewayAutoConfig.java
|
Java
|
mit
| 5,634
|
package zack.gateway.assist.config;
import org.springframework.boot.context.properties.ConfigurationProperties;
/**
* @author A1793
*/
@ConfigurationProperties("api-gateway")
public class GatewayServiceProperties {
/** 注册中心地址 */
private String address;
/** 分组ID */
private String groupId;
/** 网关ID */
private String gatewayId;
/** 网关名称 */
private String gatewayName;
/** 网关地址 */
private String gatewayAddress;
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public String getGroupId() {
return groupId;
}
public void setGroupId(String groupId) {
this.groupId = groupId;
}
public String getGatewayId() {
return gatewayId;
}
public void setGatewayId(String gatewayId) {
this.gatewayId = gatewayId;
}
public String getGatewayName() {
return gatewayName;
}
public void setGatewayName(String gatewayName) {
this.gatewayName = gatewayName;
}
public String getGatewayAddress() {
return gatewayAddress;
}
public void setGatewayAddress(String gatewayAddress) {
this.gatewayAddress = gatewayAddress;
}
}
|
2301_82000044/my-api-gateway
|
my-api-gateway-assist/src/main/java/zack/gateway/assist/config/GatewayServiceProperties.java
|
Java
|
mit
| 1,314
|
package zack.gateway.assist.domain.model.aggregates;
import zack.gateway.assist.domain.model.vo.ApplicationSystemVO;
import java.util.List;
/**
* @author zack
* @description 网关算力配置信息
122.51.38.****/
public class ApplicationSystemRichInfo {
/** 网关ID */
private String gatewayId;
/** 系统列表 */
private List<ApplicationSystemVO> applicationSystemVOS;
public String getGatewayId() {
return gatewayId;
}
public void setGatewayId(String gatewayId) {
this.gatewayId = gatewayId;
}
public List<ApplicationSystemVO> getApplicationSystemVOS() {
return applicationSystemVOS;
}
public void setApplicationSystemVOS(List<ApplicationSystemVO> applicationSystemVOList) {
this.applicationSystemVOS = applicationSystemVOList;
}
}
|
2301_82000044/my-api-gateway
|
my-api-gateway-assist/src/main/java/zack/gateway/assist/domain/model/aggregates/ApplicationSystemRichInfo.java
|
Java
|
mit
| 835
|
package zack.gateway.assist.domain.model.vo;
/**
* @author zack
* @description 接口方法 VO
122.51.38.****/
public class ApplicationInterfaceMethodVO {
/** 系统标识 */
private String systemId;
/** 接口标识 */
private String interfaceId;
/** 方法标识 */
private String methodId;
/** 方法名称 */
private String methodName;
/** 参数类型(RPC 限定单参数注册)；new String[]{"java.lang.String"}、new String[]{"cn.bugstack.gateway.rpc.dto.XReq"} */
private String parameterType;
/** 网关接口 */
private String uri;
/** 接口类型；GET、POST、PUT、DELETE */
private String httpCommandType;
/** 是否鉴权；true = 1是、false = 0否 */
private Integer auth;
public String getSystemId() {
return systemId;
}
public void setSystemId(String systemId) {
this.systemId = systemId;
}
public String getInterfaceId() {
return interfaceId;
}
public void setInterfaceId(String interfaceId) {
this.interfaceId = interfaceId;
}
public String getMethodId() {
return methodId;
}
public void setMethodId(String methodId) {
this.methodId = methodId;
}
public String getMethodName() {
return methodName;
}
public void setMethodName(String methodName) {
this.methodName = methodName;
}
public String getParameterType() {
return parameterType;
}
public void setParameterType(String parameterType) {
this.parameterType = parameterType;
}
public String getUri() {
return uri;
}
public void setUri(String uri) {
this.uri = uri;
}
public String getHttpCommandType() {
return httpCommandType;
}
public void setHttpCommandType(String httpCommandType) {
this.httpCommandType = httpCommandType;
}
public Integer getAuth() {
return auth;
}
public void setAuth(Integer auth) {
this.auth = auth;
}
public boolean isAuth(){
return auth == 1;
}
}
|
2301_82000044/my-api-gateway
|
my-api-gateway-assist/src/main/java/zack/gateway/assist/domain/model/vo/ApplicationInterfaceMethodVO.java
|
Java
|
mit
| 2,110
|
package zack.gateway.assist.domain.model.vo;
import java.util.List;
/**
* @author zack
* @description 应用接口 VO
122.51.38.****/
public class ApplicationInterfaceVO {
/** 系统标识 */
private String systemId;
/** 接口标识 */
private String interfaceId;
/** 接口名称 */
private String interfaceName;
/** 接口版本 */
private String interfaceVersion;
/** 方法接口 */
private List<ApplicationInterfaceMethodVO> methodList;
public String getSystemId() {
return systemId;
}
public void setSystemId(String systemId) {
this.systemId = systemId;
}
public String getInterfaceId() {
return interfaceId;
}
public void setInterfaceId(String interfaceId) {
this.interfaceId = interfaceId;
}
public String getInterfaceName() {
return interfaceName;
}
public void setInterfaceName(String interfaceName) {
this.interfaceName = interfaceName;
}
public String getInterfaceVersion() {
return interfaceVersion;
}
public void setInterfaceVersion(String interfaceVersion) {
this.interfaceVersion = interfaceVersion;
}
public List<ApplicationInterfaceMethodVO> getMethodList() {
return methodList;
}
public void setMethodList(List<ApplicationInterfaceMethodVO> methodList) {
this.methodList = methodList;
}
}
|
2301_82000044/my-api-gateway
|
my-api-gateway-assist/src/main/java/zack/gateway/assist/domain/model/vo/ApplicationInterfaceVO.java
|
Java
|
mit
| 1,429
|
package zack.gateway.assist.domain.model.vo;
import java.util.List;
/**
* @author zack
* @description 应用服务 VO
122.51.38.****/
public class ApplicationSystemVO {
/** 系统标识 */
private String systemId;
/** 系统名称 */
private String systemName;
/** 系统类型；RPC、HTTP*/
private String systemType;
/** 注册中心；zookeeper://127.0.0.1:2181*/
private String systemRegistry;
/** 接口方法 */
private List<ApplicationInterfaceVO> interfaceList;
public String getSystemId() {
return systemId;
}
public void setSystemId(String systemId) {
this.systemId = systemId;
}
public String getSystemName() {
return systemName;
}
public void setSystemName(String systemName) {
this.systemName = systemName;
}
public String getSystemType() {
return systemType;
}
public void setSystemType(String systemType) {
this.systemType = systemType;
}
public String getSystemRegistry() {
return systemRegistry;
}
public void setSystemRegistry(String systemRegistry) {
this.systemRegistry = systemRegistry;
}
public List<ApplicationInterfaceVO> getInterfaceList() {
return interfaceList;
}
public void setInterfaceList(List<ApplicationInterfaceVO> interfaceList) {
this.interfaceList = interfaceList;
}
}
|
2301_82000044/my-api-gateway
|
my-api-gateway-assist/src/main/java/zack/gateway/assist/domain/model/vo/ApplicationSystemVO.java
|
Java
|
mit
| 1,426
|
package zack.gateway.assist.domain.service;
import cn.hutool.http.HttpUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import zack.gateway.assist.GatewayException;
import zack.gateway.assist.common.Result;
import zack.gateway.assist.domain.model.aggregates.ApplicationSystemRichInfo;
import java.util.HashMap;
import java.util.Map;
/**注册网关算力节点服务
* @author A1793
*/
public class GatewayCenterService {
private Logger logger = LoggerFactory.getLogger(GatewayCenterService.class);
public void doRegister(String address,String groupId,String gatewayId,String gatewayName,String gatewayAddress){
Map<String, Object> map = new HashMap<>();
map.put("groupId", groupId);
map.put("gatewayId", gatewayId);
map.put("gatewayName", gatewayName);
map.put("gatewayAddress", gatewayAddress);
String resultStr = null ;
try{
resultStr = HttpUtil.post(address + "/wg/admin/config/registerGateway", map,350000);
}catch (Exception e){
logger.error("网关服务注册异常，链接资源不可用：{}", address + "/wg/admin/config/registerGateway");
throw e;
}
Result result = JSON.parseObject(resultStr, Result.class);
logger.info("向网关中心注册网关算力服务 gatewayId：{} gatewayName：{} gatewayAddress：{} 注册结果：{}", gatewayId, gatewayName, gatewayAddress, resultStr);
if (!"0000".equals(result.getCode())) {
throw new GatewayException("网关服务注册异常 [gatewayId：" + gatewayId + "] 、[gatewayAddress：" + gatewayAddress + "]");
}
}
public ApplicationSystemRichInfo pullApplicationSystemRichInfo(String address,String gatewayId,String systemId) {
Map<String, Object> parameterMap = new HashMap<>();
parameterMap.put("gatewayId", gatewayId);
parameterMap.put("systemId", systemId);
String resultStr = null;
try{
resultStr = HttpUtil.post(address + "/wg/admin/config/queryApplicationSystemRichInfo", parameterMap,3500000);
}catch (Exception e){
logger.error("网关服务拉取异常，链接资源不可用：{}", address + "/wg/admin/config/queryApplicationSystemRichInfo");
throw e;
}
Result<ApplicationSystemRichInfo> result = JSON.parseObject(resultStr, new TypeReference<Result<ApplicationSystemRichInfo>>() {
});
if (!"0000".equals(result.getCode())) {
throw new GatewayException("从网关中心拉取应用服务和接口的配置信息到本地完成注册异常 [gatewayId：" + gatewayId + "]");
}
return result.getData();
}
public Map<String,String> queryRedisConfig(String address){
String resultStr = null;
try{
resultStr = HttpUtil.post(address + "/wg/admin/config/queryRedisConfig", "", 3500000);
}catch (Exception e){
logger.error("网关服务拉取配置异常，链接资源不可用：{}", address + "/wg/admin/config/queryRedisConfig", e);
throw e;
}
Result<Map<String, String>> result = JSON.parseObject(resultStr, new TypeReference<Result<Map<String, String>>>() {
});
logger.info("从网关中心拉取Redis配置信息完成。result：{}", resultStr);
if(!"0000".equals(result.getCode())){
throw new GatewayException("从网关中心拉取Redis配置信息异常");
}
return result.getData();
}
}
|
2301_82000044/my-api-gateway
|
my-api-gateway-assist/src/main/java/zack/gateway/assist/domain/service/GatewayCenterService.java
|
Java
|
mit
| 3,623
|
# 基础镜像
FROM openjdk:8-jre-slim
# 作者
MAINTAINER zackzky
# 配置
ENV PARAMS=""
# 时区
ENV TZ=PRC
RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
# 添加应用
ADD target/my-api-gateway-center.jar /my-api-gateway-center.jar
## 在镜像运行为容器后执行的命令
ENTRYPOINT ["sh","-c","java -jar $JAVA_OPTS /my-api-gateway-center.jar $PARAMS"]
|
2301_82000044/my-api-gateway
|
my-api-gateway-center/Dockerfile
|
Dockerfile
|
mit
| 394
|
docker build -f ./Dockerfile -t zackzky/my-api-gateway-center:1.1 .
|
2301_82000044/my-api-gateway
|
my-api-gateway-center/build.sh
|
Shell
|
mit
| 67
|
<html>
<head>
<title>Welcome to nginx!</title>
<style>
html { color-scheme: light dark; }
body { width: 35em; margin: 0 auto;
font-family: Tahoma, Verdana, Arial, sans-serif; }
</style>
</head>
<body>
<h1>Welcome to nginx!</h1>
<p>If you see this page, the nginx web server is successfully installed and
working. Further configuration is required.</p>
<p>For online documentation and support please refer to
<a href="http://nginx.org/">nginx.org</a>.<br/>
Commercial support is available at
<a href="http://nginx.com/">nginx.com</a>.</p>
<p><em>Thank you for using nginx.</em></p>
</body>
</html>
|
2301_82000044/my-api-gateway
|
my-api-gateway-center/docs/data/html/index.html
|
HTML
|
mit
| 656
|
docker run \
--name Nginx \
-d \
-v /mnt/c/javaData/git_test/my-api-gateway-center/docs/data/html:/usr/share/nginx/html \
-v /mnt/c/javaData/git_test/my-api-gateway-center/docs/data/nginx/nginx.conf:/etc/nginx/nginx.conf \
-p 8090:80 \
nginx
|
2301_82000044/my-api-gateway
|
my-api-gateway-center/nginx.sh
|
Shell
|
mit
| 241
|
#!/bin/bash
# https://cr.console.aliyun.com/cn-hangzhou/instance/credentials
# Ensure the script exits if any command fails
set -e
# Define variables for the registry and image
ALIYUN_REGISTRY="crpi-f2fnckn7fe4gfuf0.cn-hangzhou.personal.cr.aliyuncs.com"
NAMESPACE="zackzky"
IMAGE_NAME="my-api-gateway-center"
IMAGE_TAG="1.1"
# 读取本地配置文件
if [ -f ".local-config" ]; then
source .local-config
else
echo ".local-config 文件不存在，请创建并填写 ALIYUN_USERNAME 和 ALIYUN_PASSWORD"
exit 1
fi
# Login to Aliyun Docker Registry
echo "Logging into Aliyun Docker Registry..."
docker login --username="${ALIYUN_USERNAME}" --password="${ALIYUN_PASSWORD}" $ALIYUN_REGISTRY
# Tag the Docker image
echo "Tagging the Docker image..."
docker tag ${NAMESPACE}/${IMAGE_NAME}:${IMAGE_TAG} ${ALIYUN_REGISTRY}/${NAMESPACE}/${IMAGE_NAME}:${IMAGE_TAG}
# Push the Docker image to Aliyun
echo "Pushing the Docker image to Aliyun..."
docker push ${ALIYUN_REGISTRY}/${NAMESPACE}/${IMAGE_NAME}:${IMAGE_TAG}
echo "Docker image pushed successfully! "
echo "检出地址：docker pull ${ALIYUN_REGISTRY}/${NAMESPACE}/${IMAGE_NAME}:${IMAGE_TAG}"
echo "标签设置：docker tag ${ALIYUN_REGISTRY}/${NAMESPACE}/${IMAGE_NAME}:${IMAGE_TAG} ${NAMESPACE}/${IMAGE_NAME}:${IMAGE_TAG}"
# Logout from Aliyun Docker Registry
echo "Logging out from Aliyun Docker Registry..."
docker logout $ALIYUN_REGISTRY
|
2301_82000044/my-api-gateway
|
my-api-gateway-center/push.sh
|
Shell
|
mit
| 1,407
|
package zack.gateway.center;
import org.springframework.beans.factory.annotation.Configurable;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
@Configurable
public class ApiGatewayApplication {
public static void main(String[] args) {
SpringApplication.run(ApiGatewayApplication.class, args);
}
}
|
2301_82000044/my-api-gateway
|
my-api-gateway-center/src/main/java/zack/gateway/center/ApiGatewayApplication.java
|
Java
|
mit
| 412
|
package zack.gateway.center.application;
import zack.gateway.center.domain.manage.model.aggregates.ApplicationSystemRichInfo;
import zack.gateway.center.domain.manage.model.vo.ApplicationInterfaceMethodVO;
import zack.gateway.center.domain.manage.model.vo.GatewayServerDetailVO;
import zack.gateway.center.domain.manage.model.vo.GatewayServerVO;
import java.util.List;
/**
* @author zack
* @description 网关配置服务
*/
public interface IConfigManageService {
List<GatewayServerVO> queryGatewayServerList();
boolean registerGatewayServerNode(String groupId, String gatewayId, String gatewayName, String gatewayAddress);
ApplicationSystemRichInfo queryApplicationSystemRichInfo(String gatewayId,String systemId);
String queryGatewayDistributionGatewayBySystemId(String systemId);
List<GatewayServerDetailVO> queryGatewayServerDetailList();
void distributionGatewayServerNode(String groupId, String gatewayId, String systemId);
}
|
2301_82000044/my-api-gateway
|
my-api-gateway-center/src/main/java/zack/gateway/center/application/IConfigManageService.java
|
Java
|
mit
| 976
|
package zack.gateway.center.application;
import zack.gateway.center.domain.operation.model.vo.*;
import zack.gateway.center.infrastructure.common.OperationRequest;
import zack.gateway.center.infrastructure.common.OperationResult;
public interface IDataOperationManageService {
OperationResult<GatewayServerDataVO> queryGatewayServer(OperationRequest<String> request);
OperationResult<ApplicationSystemDataVO> queryApplicationSystem(OperationRequest<ApplicationSystemDataVO> request);
OperationResult<ApplicationInterfaceDataVO> queryApplicationInterface(OperationRequest<ApplicationInterfaceDataVO> request);
OperationResult<ApplicationInterfaceMethodDataVO> queryApplicationInterfaceMethod(OperationRequest<ApplicationInterfaceMethodDataVO> request);
OperationResult<GatewayServerDetaiDatalVO> queryGatewayServerDetail(OperationRequest<GatewayServerDetaiDatalVO> request);
OperationResult<GatewayDistributionDataVO> queryGatewayDistribution(OperationRequest<GatewayDistributionDataVO> request);
}
|
2301_82000044/my-api-gateway
|
my-api-gateway-center/src/main/java/zack/gateway/center/application/IDataOperationManageService.java
|
Java
|
mit
| 1,033
|
package zack.gateway.center.application;
import zack.gateway.center.domain.docker.model.aggregates.NginxConfig;
import java.io.IOException;
/**加载负载均衡服务
* @author A1793
*/
public interface ILoadBalancingService {
public void updateNginxConfig(NginxConfig nginxConfig) throws IOException, InterruptedException;
}
|
2301_82000044/my-api-gateway
|
my-api-gateway-center/src/main/java/zack/gateway/center/application/ILoadBalancingService.java
|
Java
|
mit
| 339
|
package zack.gateway.center.application;
import java.util.Map;
/** redis消息服务
* @author A1793
*/
public interface IMessageService {
public Map<String,String> queryRedisConfig();
public void pushMessage(String gatewayId,Object systemId);
}
|
2301_82000044/my-api-gateway
|
my-api-gateway-center/src/main/java/zack/gateway/center/application/IMessageService.java
|
Java
|
mit
| 260
|
package zack.gateway.center.application;
import zack.gateway.center.domain.register.model.vo.ApplicationInterfaceMethodVO;
import zack.gateway.center.domain.register.model.vo.ApplicationInterfaceVO;
import zack.gateway.center.domain.register.model.vo.ApplicationSystemVO;
public interface IRegisterManageService {
void registerApplication(ApplicationSystemVO applicationSystemVO);
void registerApplicationInterface(ApplicationInterfaceVO applicationInterfaceVO);
void registerApplicationInterfaceMethod(ApplicationInterfaceMethodVO applicationInterfaceMethodVO);
}
|
2301_82000044/my-api-gateway
|
my-api-gateway-center/src/main/java/zack/gateway/center/application/IRegisterManageService.java
|
Java
|
mit
| 584
|
package zack.gateway.center.domain.docker.model.aggregates;
import zack.gateway.center.domain.docker.model.vo.LocationVO;
import zack.gateway.center.domain.docker.model.vo.UpstreamVO;
import java.util.List;
/**
* @author A1793
*/
public class NginxConfig {
private String applicationName;
private String nginxName;
private String localNginxPath;
private String remoteNginxPath;
/** 负载均衡列表 */
private List<UpstreamVO> upstreamList;
/** 反向代理列表 */
private List<LocationVO> locationList;
public NginxConfig(String applicationName, String nginxName, String localNginxPath, String remoteNginxPath, List<UpstreamVO> upstreamList, List<LocationVO> locationList) {
this.applicationName = applicationName;
this.nginxName = nginxName;
this.localNginxPath = localNginxPath;
this.remoteNginxPath = remoteNginxPath;
this.upstreamList = upstreamList;
this.locationList = locationList;
}
public NginxConfig(List<UpstreamVO> upstreamList, List<LocationVO> locationList) {
this.applicationName = "api-gateway-center";
this.nginxName = "Nginx";
this.localNginxPath = "/mnt/c/javaData/git_test/my-api-gateway-center/docs/data/nginx/nginx.conf";
this.remoteNginxPath = "/etc/nginx/";
this.upstreamList = upstreamList;
this.locationList = locationList;
}
public String getApplicationName() {
return applicationName;
}
public void setApplicationName(String applicationName) {
this.applicationName = applicationName;
}
public String getNginxName() {
return nginxName;
}
public void setNginxName(String nginxName) {
this.nginxName = nginxName;
}
public String getLocalNginxPath() {
return localNginxPath;
}
public void setLocalNginxPath(String localNginxPath) {
this.localNginxPath = localNginxPath;
}
public String getRemoteNginxPath() {
return remoteNginxPath;
}
public void setRemoteNginxPath(String remoteNginxPath) {
this.remoteNginxPath = remoteNginxPath;
}
public List<UpstreamVO> getUpstreamList() {
return upstreamList;
}
public void setUpstreamList(List<UpstreamVO> upstreamList) {
this.upstreamList = upstreamList;
}
public List<LocationVO> getLocationList() {
return locationList;
}
public void setLocationList(List<LocationVO> locationList) {
this.locationList = locationList;
}
}
|
2301_82000044/my-api-gateway
|
my-api-gateway-center/src/main/java/zack/gateway/center/domain/docker/model/aggregates/NginxConfig.java
|
Java
|
mit
| 2,549
|
package zack.gateway.center.domain.docker.model.vo;
/** 反向代理配置
* @author A1793
*/
public class LocationVO {
String name;
String Proxy_pass;
public LocationVO(String name, String Proxy_pass) {
this.name = name;
this.Proxy_pass = Proxy_pass;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getProxy_pass() {
return Proxy_pass;
}
public void setProxy_pass(String proxy_pass) {
this.Proxy_pass = proxy_pass;
}
}
|
2301_82000044/my-api-gateway
|
my-api-gateway-center/src/main/java/zack/gateway/center/domain/docker/model/vo/LocationVO.java
|
Java
|
mit
| 590
|
package zack.gateway.center.domain.docker.model.vo;
import java.util.List;
/**
*
* 下游服务地址配置
* #设置下游服务器地址(java项目的地址)
* upstream api01 {
* least_conn;
*
* server 192.168.1.3:9001;
* server 192.168.1.3:9002;
* }
* @author A1793
*/
public class UpstreamVO {
// upstream api01
String name;
// 负载策略；least_conn;、 ip_hash;
String strategy;
//服务端地址
List<String> servers;
public UpstreamVO(String name, String strategy, List<String> servers) {
this.name = name;
this.strategy = strategy;
this.servers = servers;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getStrategy() {
return strategy;
}
public void setStrategy(String strategy) {
this.strategy = strategy;
}
public List<String> getServers() {
return servers;
}
public void setServers(List<String> servers) {
this.servers = servers;
}
}
|
2301_82000044/my-api-gateway
|
my-api-gateway-center/src/main/java/zack/gateway/center/domain/docker/model/vo/UpstreamVO.java
|
Java
|
mit
| 1,121
|
package zack.gateway.center.domain.docker.service;
import zack.gateway.center.application.ILoadBalancingService;
import zack.gateway.center.domain.docker.model.aggregates.NginxConfig;
import java.io.IOException;
/**抽象的负载均衡加载服务
* @author A1793
*/
public abstract class AbstractLoadBalancingService implements ILoadBalancingService {
/**
* 加载负载均衡：
* 1.更新本地的nginx.conf文件，（docker启动时，本地的conf挂载到了容器内部的conf）
* 2.在nginx容器内部执行reload命令
* @param nginxConfig
*/
@Override
public void updateNginxConfig(NginxConfig nginxConfig) throws IOException, InterruptedException {
String filePath = createNginxConfigFile(nginxConfig);
refreshNginxConfig(nginxConfig.getNginxName());
}
public abstract String createNginxConfigFile(NginxConfig nginxConfig ) throws IOException;
public abstract void refreshNginxConfig(String nginxName) throws InterruptedException, IOException;
}
|
2301_82000044/my-api-gateway
|
my-api-gateway-center/src/main/java/zack/gateway/center/domain/docker/service/AbstractLoadBalancingService.java
|
Java
|
mit
| 1,035
|
package zack.gateway.center.domain.docker.service;
import com.github.dockerjava.api.DockerClient;
import com.github.dockerjava.api.async.ResultCallback;
import com.github.dockerjava.api.command.ExecCreateCmdResponse;
import com.github.dockerjava.core.DefaultDockerClientConfig;
import com.github.dockerjava.core.DockerClientBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import zack.gateway.center.application.ILoadBalancingService;
import zack.gateway.center.domain.docker.model.aggregates.NginxConfig;
import zack.gateway.center.domain.docker.model.vo.LocationVO;
import zack.gateway.center.domain.docker.model.vo.UpstreamVO;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
/**
* @author A1793
*/
@Service
public class LoadBalancingService extends AbstractLoadBalancingService{
private Logger logger = LoggerFactory.getLogger(LoadBalancingService.class);
@Value("${nginx.server_name}")
private String serverName;
@Override
public String createNginxConfigFile(NginxConfig nginxConfig) throws IOException {
String nginxConfigStr = buildNginxConfig(nginxConfig.getUpstreamList(),nginxConfig.getLocationList());
File file = new File("/data/nginx/nginx.conf");
if(!file.exists()){
boolean success = file.createNewFile();
if(success){
logger.info("创建了新的nginx.conf文件");
}else{
logger.info("文件创建失败");
}
}
FileWriter fileWriter = new FileWriter(file);
fileWriter.write(nginxConfigStr);
fileWriter.close();
//返回文件的绝对路径
return file.getAbsolutePath();
}
/**
* docker容器reload
* @param nginxName
*/
@Override
public void refreshNginxConfig(String nginxName) throws InterruptedException, IOException {
//与docker的守护进程建立连接
DefaultDockerClientConfig config = DefaultDockerClientConfig.createDefaultConfigBuilder().
withDockerHost("unix:///var/run/docker.sock").
build();
//对docker容器的操作都要通过这个client与docker守护进程之间的通信完成，client发出请求，守护进程接收到后执行操作
DockerClient client = DockerClientBuilder.getInstance(config).build();
//获取要操作的容器的id
String containerId = client.listContainersCmd()
//通过双括号快速初始化集合，实际是匿名内部类
.withNameFilter(new ArrayList<String>(){{add(nginxName);}})
.exec()
.get(0)
.getId();
//docker主进程命令执行分为两部分，exec（创建命令计划）和start（实际执行）
//在docker内存基于容器id建立命令执行计划
ExecCreateCmdResponse execCreateCmdResponse = client
.execCreateCmd(containerId)
.withCmd("nginx","-s","reload")
.exec();
//发送请求，docker主进程实际执行reload命令
client.execStartCmd(execCreateCmdResponse.getId()).
exec(new ResultCallback.Adapter<>())
.awaitCompletion();
client.close();
}
private String buildNginxConfig(List<UpstreamVO> upstreams, List<LocationVO> locations) {
//默认nginx配置
String config = "\n" +
"user nginx;\n" +
"worker_processes auto;\n" +
"\n" +
"error_log /var/log/nginx/error.log notice;\n" +
"pid /var/run/nginx.pid;\n" +
"\n" +
"\n" +
"events {\n" +
" worker_connections 1024;\n" +
"}\n" +
"\n" +
"\n" +
"http {\n" +
" include /etc/nginx/mime.types;\n" +
" default_type application/octet-stream;\n" +
"\n" +
" log_format main '$remote_addr - $remote_user [$time_local] \"$request\" '\n" +
" '$status $body_bytes_sent \"$http_referer\" '\n" +
" '\"$http_user_agent\" \"$http_x_forwarded_for\"';\n" +
"\n" +
" access_log /var/log/nginx/access.log main;\n" +
"\n" +
" sendfile on;\n" +
" #tcp_nopush on;\n" +
"\n" +
" keepalive_timeout 65;\n" +
"\n" +
" #gzip on;\n" +
"\n" +
" include /etc/nginx/conf.d/*.conf;\n" +
"\n" +
" # 设定负载均衡的服务器列表\n" +
"upstream_config_placeholder" +
"\n" +
" # HTTP服务器\n" +
" server {\n" +
" # 监听80端口，用于HTTP协议\n" +
" listen 80;\n" +
"\n" +
" # 定义使用IP/域名访问\n" +
" server_name "+ serverName+";\n" +
"\n" +
" # 首页\n" +
" index index.html;\n" +
"\n" +
" # 反向代理的路径（upstream绑定），location 后面设置映射的路径\n" +
"\n" +
"location_config_placeholder" +
" }\n" +
"}\n";
// 组装配置 Upstream
StringBuilder upstreamStr = new StringBuilder();
for (UpstreamVO upstream : upstreams) {
upstreamStr.append("\t").append("upstream").append(" ").append(upstream.getName()).append(" {\r\n");
upstreamStr.append("\t").append("\t").append(upstream.getStrategy()).append("\r\n").append("\r\n");
List<String> servers = upstream.getServers();
for (String server : servers) {
upstreamStr.append("\t").append("\t").append("server").append(" ").append(server).append(";").append("\r\n");
}
upstreamStr.append("\t").append("}").append("\r\n").append("\r\n");
}
// 组装配置 Location
StringBuilder locationStr = new StringBuilder();
for (LocationVO location : locations) {
locationStr.append("\t").append("\t").append("location").append(" ").append(location.getName()).append(" {\r\n");
// rewrite ^/api01/(.*)$ /$1 break; 设置重写URL，在代理后去掉根路径 api01 此字段只是配合路由，不做处理
locationStr.append("\t").append("\t").append("\t").append("rewrite ^").append(location.getName()).append("(.*)$ /$1 break;").append("\r\n");
//设置转发路径
locationStr.append("\t").append("\t").append("\t").append("proxy_pass").append(" ").append(location.getProxy_pass()).append("\r\n");
//设置代理头
locationStr.append("\t").append("\t").append("\t").append("proxy_set_header").append(" ").append("HOST $host;").append("\r\n");
locationStr.append("\t").append("\t").append("\t").append("proxy_set_header").append(" ").append("X-Real-IP $remote_addr;").append("\r\n");
locationStr.append("\t").append("\t").append("\t").append("proxy_set_header").append(" ").append("X-Forwarded-For $proxy_add_x_forwarded_for;").append("\r\n");
locationStr.append("\t").append("\t").append("\t").append("proxy_set_header").append(" ").append("X-Forwarded-Proto $scheme;").append("\r\n");
locationStr.append("\t").append("\t").append("}").append("\r\n").append("\r\n");
}
// 替换配置
config = config.replace("upstream_config_placeholder", upstreamStr.toString());
config = config.replace("location_config_placeholder", locationStr.toString());
return config;
}
}
|
2301_82000044/my-api-gateway
|
my-api-gateway-center/src/main/java/zack/gateway/center/domain/docker/service/LoadBalancingService.java
|
Java
|
mit
| 8,192
|
package zack.gateway.center.domain.manage.model.aggregates;
import zack.gateway.center.domain.manage.model.vo.ApplicationSystemVO;
import java.util.List;
/**网关关联的应用信息
* @author A1793
*/
public class ApplicationSystemRichInfo {
private String gatewayId;
private List<ApplicationSystemVO> applicationSystemVOS;
public ApplicationSystemRichInfo() {
}
public ApplicationSystemRichInfo(String gatewayId, List<ApplicationSystemVO> applicationSystemVOS) {
this.gatewayId = gatewayId;
this.applicationSystemVOS = applicationSystemVOS;
}
public String getGatewayId() {
return gatewayId;
}
public void setGatewayId(String gatewayId) {
this.gatewayId = gatewayId;
}
public List<ApplicationSystemVO> getApplicationSystemVOS() {
return applicationSystemVOS;
}
public void setApplicationSystemVOS(List<ApplicationSystemVO> applicationSystemVOS) {
this.applicationSystemVOS = applicationSystemVOS;
}
}
|
2301_82000044/my-api-gateway
|
my-api-gateway-center/src/main/java/zack/gateway/center/domain/manage/model/aggregates/ApplicationSystemRichInfo.java
|
Java
|
mit
| 1,021
|
package zack.gateway.center.domain.manage.model.vo;
public class ApplicationInterfaceMethodVO {
/** 系统标识 */
private String systemId;
/** 接口标识 */
private String interfaceId;
/** 方法标识 */
private String methodId;
/** 方法名称 */
private String methodName;
/** 参数类型(RPC 限定单参数注册)；new String[]{"java.lang.String"}、new String[]{"cn.bugstack.gateway.rpc.dto.XReq"} */
private String parameterType;
/** 网关接口 */
private String uri;
/** 接口类型；GET、POST、PUT、DELETE */
private String httpCommandType;
/** 是否鉴权；true = 1是、false = 0否 */
private Integer auth;
public String getSystemId() {
return systemId;
}
public void setSystemId(String systemId) {
this.systemId = systemId;
}
public String getInterfaceId() {
return interfaceId;
}
public void setInterfaceId(String interfaceId) {
this.interfaceId = interfaceId;
}
public String getMethodId() {
return methodId;
}
public void setMethodId(String methodId) {
this.methodId = methodId;
}
public String getMethodName() {
return methodName;
}
public void setMethodName(String methodName) {
this.methodName = methodName;
}
public String getParameterType() {
return parameterType;
}
public void setParameterType(String parameterType) {
this.parameterType = parameterType;
}
public String getUri() {
return uri;
}
public void setUri(String uri) {
this.uri = uri;
}
public String getHttpCommandType() {
return httpCommandType;
}
public void setHttpCommandType(String httpCommandType) {
this.httpCommandType = httpCommandType;
}
public Integer getAuth() {
return auth;
}
public void setAuth(Integer auth) {
this.auth = auth;
}
}
|
2301_82000044/my-api-gateway
|
my-api-gateway-center/src/main/java/zack/gateway/center/domain/manage/model/vo/ApplicationInterfaceMethodVO.java
|
Java
|
mit
| 1,987
|
package zack.gateway.center.domain.manage.model.vo;
import java.util.List;
public class ApplicationInterfaceVO {
/** 系统标识 */
private String systemId;
/** 接口标识 */
private String interfaceId;
/** 接口名称 */
private String interfaceName;
/** 接口版本 */
private String interfaceVersion;
/** 方法接口 */
private List<ApplicationInterfaceMethodVO> methodList;
public String getSystemId() {
return systemId;
}
public void setSystemId(String systemId) {
this.systemId = systemId;
}
public String getInterfaceId() {
return interfaceId;
}
public void setInterfaceId(String interfaceId) {
this.interfaceId = interfaceId;
}
public String getInterfaceName() {
return interfaceName;
}
public void setInterfaceName(String interfaceName) {
this.interfaceName = interfaceName;
}
public String getInterfaceVersion() {
return interfaceVersion;
}
public void setInterfaceVersion(String interfaceVersion) {
this.interfaceVersion = interfaceVersion;
}
public List<ApplicationInterfaceMethodVO> getMethodList() {
return methodList;
}
public void setMethodList(List<ApplicationInterfaceMethodVO> methodList) {
this.methodList = methodList;
}
}
|
2301_82000044/my-api-gateway
|
my-api-gateway-center/src/main/java/zack/gateway/center/domain/manage/model/vo/ApplicationInterfaceVO.java
|
Java
|
mit
| 1,365
|
package zack.gateway.center.domain.manage.model.vo;
import java.util.List;
public class ApplicationSystemVO {
/** 系统标识 */
private String systemId;
/** 系统名称 */
private String systemName;
/** 系统类型；RPC、HTTP*/
private String systemType;
/** 注册中心；zookeeper://127.0.0.1:2181*/
private String systemRegistry;
/** 接口方法 */
private List<ApplicationInterfaceVO> interfaceList;
public String getSystemId() {
return systemId;
}
public void setSystemId(String systemId) {
this.systemId = systemId;
}
public String getSystemName() {
return systemName;
}
public void setSystemName(String systemName) {
this.systemName = systemName;
}
public String getSystemType() {
return systemType;
}
public void setSystemType(String systemType) {
this.systemType = systemType;
}
public String getSystemRegistry() {
return systemRegistry;
}
public void setSystemRegistry(String systemRegistry) {
this.systemRegistry = systemRegistry;
}
public List<ApplicationInterfaceVO> getInterfaceList() {
return interfaceList;
}
public void setInterfaceList(List<ApplicationInterfaceVO> interfaceList) {
this.interfaceList = interfaceList;
}
}
|
2301_82000044/my-api-gateway
|
my-api-gateway-center/src/main/java/zack/gateway/center/domain/manage/model/vo/ApplicationSystemVO.java
|
Java
|
mit
| 1,361
|
package zack.gateway.center.domain.manage.model.vo;
import java.util.Date;
/**
* @author zack
* @description 网关服务明细
*/
public class GatewayServerDetailVO {
/** 自增ID */
private Integer id;
/** 分组标识 */
private String groupId;
/** 网关标识 */
private String gatewayId;
/** 网关名称 */
private String gatewayName;
/** 网关地址 */
private String gatewayAddress;
/** 服务状态 */
private Integer status;
/** 创建时间 */
private Date createTime;
/** 更新时间 */
private Date updateTime;
public String getGatewayId() {
return gatewayId;
}
public void setGatewayId(String gatewayId) {
this.gatewayId = gatewayId;
}
public String getGatewayName() {
return gatewayName;
}
public void setGatewayName(String gatewayName) {
this.gatewayName = gatewayName;
}
public String getGatewayAddress() {
return gatewayAddress;
}
public void setGatewayAddress(String gatewayAddress) {
this.gatewayAddress = gatewayAddress;
}
public Integer getStatus() {
return status;
}
public void setStatus(Integer status) {
this.status = status;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getGroupId() {
return groupId;
}
public void setGroupId(String groupId) {
this.groupId = groupId;
}
public Date getCreateTime() {
return createTime;
}
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
public Date getUpdateTime() {
return updateTime;
}
public void setUpdateTime(Date updateTime) {
this.updateTime = updateTime;
}
}
|
2301_82000044/my-api-gateway
|
my-api-gateway-center/src/main/java/zack/gateway/center/domain/manage/model/vo/GatewayServerDetailVO.java
|
Java
|
mit
| 1,861
|
package zack.gateway.center.domain.manage.model.vo;
/**
* @author zack
* @description 网关服务配置
122.51.38.****/
public class GatewayServerVO {
/** 分组标识 */
private String groupId;
/** 分组名称 */
private String groupName;
public String getGroupId() {
return groupId;
}
public void setGroupId(String groupId) {
this.groupId = groupId;
}
public String getGroupName() {
return groupName;
}
public void setGroupName(String groupName) {
this.groupName = groupName;
}
}
|
2301_82000044/my-api-gateway
|
my-api-gateway-center/src/main/java/zack/gateway/center/domain/manage/model/vo/GatewayServerVO.java
|
Java
|
mit
| 577
|
/**
* @description 网关管理
* @author zack
*/
package zack.gateway.center.domain.manage;
|
2301_82000044/my-api-gateway
|
my-api-gateway-center/src/main/java/zack/gateway/center/domain/manage/package-info.java
|
Java
|
mit
| 99
|
package zack.gateway.center.domain.manage.repository;
import zack.gateway.center.domain.manage.model.vo.GatewayServerDetailVO;
import zack.gateway.center.domain.manage.model.vo.GatewayServerVO;
import zack.gateway.center.domain.manage.model.vo.ApplicationInterfaceMethodVO;
import zack.gateway.center.domain.manage.model.vo.ApplicationInterfaceVO;
import zack.gateway.center.domain.manage.model.vo.ApplicationSystemVO;
import java.util.List;
/**
* @author zack
* @description 网关配置仓储服务
*/
public interface IConfigManageRepository {
List<GatewayServerVO> queryGatewayServerList();
boolean registerGatewayServerNode(String groupId, String gatewayId, String gatewayName, String gatewayAddress, Integer available);
GatewayServerDetailVO queryGatewayServerDetail(String gatewayId, String gatewayAddress);
boolean updateGatewayStatus(String gatewayId, String gatewayAddress, Integer available);
List<String> queryGatewayDistributionSystemIdList(String gatewayId);
List<ApplicationSystemVO> queryApplicationSystemList(List<String> systemIdList);
List<ApplicationInterfaceVO> queryApplicationInterfaceList(String systemId);
List<ApplicationInterfaceVO> queryApplicationInterfaceList(List<String> interfaceIdList);
List<ApplicationInterfaceMethodVO> queryApplicationInterfaceMethodList(String systemId, String interfaceId);
List<ApplicationInterfaceMethodVO> queryApplicationInterfaceMethodListByKeys(List<InterfaceKey> keys);
String queryGatewayDistributionBySystemId(String systemId);
List<GatewayServerDetailVO> queryGatewayServerDetailList();
ApplicationSystemVO queryApplicationSystemBySystemId(String systemId);
void distributionGatewayServerNode(String groupId, String gatewayId, String systemId, String systemName);
}
|
2301_82000044/my-api-gateway
|
my-api-gateway-center/src/main/java/zack/gateway/center/domain/manage/repository/IConfigManageRepository.java
|
Java
|
mit
| 1,815
|
package zack.gateway.center.domain.manage.repository;
/**
* @author A1793
*/
public class InterfaceKey {
String systemId;
String interfaceId;
public InterfaceKey(String systemId, String interfaceId) {
this.systemId = systemId;
this.interfaceId = interfaceId;
}
public String getSystemId() {
return systemId;
}
public void setSystemId(String systemId) {
this.systemId = systemId;
}
public String getInterfaceId() {
return interfaceId;
}
public void setInterfaceId(String interfaceId) {
this.interfaceId = interfaceId;
}
}
|
2301_82000044/my-api-gateway
|
my-api-gateway-center/src/main/java/zack/gateway/center/domain/manage/repository/InterfaceKey.java
|
Java
|
mit
| 626
|
package zack.gateway.center.domain.manage.service;
import org.apache.commons.lang.StringUtils;
import org.springframework.dao.DuplicateKeyException;
import org.springframework.stereotype.Service;
import zack.gateway.center.application.IConfigManageService;
import zack.gateway.center.domain.manage.model.aggregates.ApplicationSystemRichInfo;
import zack.gateway.center.domain.manage.model.vo.ApplicationInterfaceMethodVO;
import zack.gateway.center.domain.manage.model.vo.GatewayServerDetailVO;
import zack.gateway.center.domain.manage.model.vo.GatewayServerVO;
import zack.gateway.center.domain.manage.repository.IConfigManageRepository;
import zack.gateway.center.domain.manage.model.vo.ApplicationInterfaceVO;
import zack.gateway.center.domain.manage.model.vo.ApplicationSystemVO;
import zack.gateway.center.domain.manage.repository.InterfaceKey;
import zack.gateway.center.infrastructure.common.Constants;
import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
/**
* @author zack
* @description 网关配置服务
*/
@Service
public class ConfigManageService implements IConfigManageService {
@Resource
private IConfigManageRepository configManageRepository;
@Override
public List<GatewayServerVO> queryGatewayServerList() {
return configManageRepository.queryGatewayServerList();
}
@Override
public boolean registerGatewayServerNode(String groupId, String gatewayId, String gatewayName, String gatewayAddress) {
GatewayServerDetailVO gatewayServerDetailVO = configManageRepository.queryGatewayServerDetail(gatewayId, gatewayAddress);
if (null == gatewayServerDetailVO) {
try {
return configManageRepository.registerGatewayServerNode(groupId, gatewayId, gatewayName, gatewayAddress, Constants.GatewayStatus.Available);
} catch (DuplicateKeyException e) {
return configManageRepository.updateGatewayStatus(gatewayId, gatewayAddress, Constants.GatewayStatus.Available);
}
} else {
return configManageRepository.updateGatewayStatus(gatewayId, gatewayAddress, Constants.GatewayStatus.Available);
}
}
@Override
public ApplicationSystemRichInfo queryApplicationSystemRichInfo(String gatewayId,String systemIdOut) {
// 1. 查询出网关ID对应的关联系统ID集合。也就是一个网关ID会被分配一些系统RPC服务注册进来，需要把这些服务查询出来。
List<String> systemIdList = configManageRepository.queryGatewayDistributionSystemIdList(gatewayId);
if(null == systemIdList || systemIdList.isEmpty()){
return null;
}
if(!systemIdOut.equals("")){
systemIdList.add(systemIdOut);
}
// 2. 查询系统ID对应的系统列表信息
List<ApplicationSystemVO> applicationSystemVOList = configManageRepository.queryApplicationSystemList(systemIdList);
if(null == applicationSystemVOList || applicationSystemVOList.isEmpty()){
return null;
}
List<ApplicationInterfaceVO> applicationInterfaceVOS = configManageRepository.queryApplicationInterfaceList(systemIdList);
//将systemId和接口对应
Map<String, List<ApplicationInterfaceVO>> interfaceMap = applicationInterfaceVOS.stream()
.collect(Collectors.groupingBy(ApplicationInterfaceVO::getSystemId));
List<InterfaceKey> interfaceKeys = applicationInterfaceVOS.stream()
.map(interf -> new InterfaceKey(interf.getSystemId(), interf.getInterfaceId()))
.collect(Collectors.toList());
List<ApplicationInterfaceMethodVO> applicationInterfaceMethodVOS = configManageRepository.queryApplicationInterfaceMethodListByKeys(interfaceKeys);
//组装applicationSystemVO
Map<String, List<ApplicationInterfaceMethodVO>> methodMap = applicationInterfaceMethodVOS.stream()
.collect(Collectors.groupingBy(me -> me.getSystemId() + ":" + me.getInterfaceId()));
for(ApplicationSystemVO applicationSystemVO : applicationSystemVOList) {
String systemId = applicationSystemVO.getSystemId();
List<ApplicationInterfaceVO> interfaceVOList = interfaceMap.getOrDefault(systemId, Collections.emptyList());
applicationSystemVO.setInterfaceList(interfaceVOList);
for(ApplicationInterfaceVO applicationInterfaceVO : interfaceVOList) {
String interfaceId = applicationInterfaceVO.getInterfaceId();
List<ApplicationInterfaceMethodVO> methodVOList = methodMap.getOrDefault(systemId +":" + interfaceId, Collections.emptyList());
applicationInterfaceVO.setMethodList(methodVOList);
}
}
return new ApplicationSystemRichInfo(gatewayId, applicationSystemVOList);
}
@Override
public String queryGatewayDistributionGatewayBySystemId(String systemId) {
return configManageRepository.queryGatewayDistributionBySystemId(systemId);
}
@Override
public List<GatewayServerDetailVO> queryGatewayServerDetailList() {
List<GatewayServerDetailVO> gatewayServerDetailVOList = configManageRepository.queryGatewayServerDetailList();
if(null == gatewayServerDetailVOList || gatewayServerDetailVOList.isEmpty()){
return Collections.emptyList();
}
return gatewayServerDetailVOList;
}
@Override
public void distributionGatewayServerNode(String groupId, String gatewayId, String systemId) {
ApplicationSystemVO systemVO = configManageRepository.queryApplicationSystemBySystemId(systemId);
String systemName = systemVO.getSystemName();
if(StringUtils.isBlank(systemName)){
throw new RuntimeException("网关算力与系统挂载配置失败，systemId：" + systemId + " 在数据库表「application_system」中不存在！");
}
configManageRepository.distributionGatewayServerNode(groupId,gatewayId,systemId,systemName);
}
}
|
2301_82000044/my-api-gateway
|
my-api-gateway-center/src/main/java/zack/gateway/center/domain/manage/service/ConfigManageService.java
|
Java
|
mit
| 6,144
|
package zack.gateway.center.domain.message.service;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import zack.gateway.center.application.IMessageService;
import javax.annotation.Resource;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
/**
* @author A1793
*/
@Service
public class MessageService implements IMessageService {
@Value("122.51.38.***")
String host;
@Value("16379")
Integer port;
@Resource
Publisher publisher;
/**
*
* @return
*/
@Override
public Map<String, String> queryRedisConfig() {
return new HashMap<String, String>() {{
put("host", host);
put("port", String.valueOf(port));
}};
}
@Override
public void pushMessage(String gatewayId, Object message) {
publisher.pushMessage(gatewayId, message);
}
}
|
2301_82000044/my-api-gateway
|
my-api-gateway-center/src/main/java/zack/gateway/center/domain/message/service/MessageService.java
|
Java
|
mit
| 932
|
package zack.gateway.center.domain.message.service;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
/**
* @author A1793
*/
@Service
public class Publisher {
private final RedisTemplate<String,Object> redisTemplate;
public Publisher(RedisTemplate<String, Object> redisTemplate) {
this.redisTemplate = redisTemplate;
}
public void pushMessage(String topic,Object message){
redisTemplate.convertAndSend(topic,message);
}
}
|
2301_82000044/my-api-gateway
|
my-api-gateway-center/src/main/java/zack/gateway/center/domain/message/service/Publisher.java
|
Java
|
mit
| 518
|
package zack.gateway.center.domain.message.service.config;
import com.alibaba.fastjson.support.spring.FastJsonRedisSerializer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
/**
* @author A1793
*/
@Configuration
public class PublisherConfig {
@Bean
public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory redisConnectionFactory){
RedisTemplate<String,Object> redisTemplate = new RedisTemplate<>();
redisTemplate.setConnectionFactory(redisConnectionFactory);
redisTemplate.setDefaultSerializer(new FastJsonRedisSerializer<Object>(Object.class));
return redisTemplate;
}
}
|
2301_82000044/my-api-gateway
|
my-api-gateway-center/src/main/java/zack/gateway/center/domain/message/service/config/PublisherConfig.java
|
Java
|
mit
| 834
|
package zack.gateway.center.domain.operation.model.vo;
/**
* @author zack
* @description 应用接口 VO
*/
public class ApplicationInterfaceDataVO {
/** 系统标识 */
private String systemId;
/** 接口标识 */
private String interfaceId;
/** 接口名称 */
private String interfaceName;
/** 接口版本 */
private String interfaceVersion;
public ApplicationInterfaceDataVO() {
}
public ApplicationInterfaceDataVO(String systemId, String interfaceId) {
this.systemId = systemId;
this.interfaceId = interfaceId;
}
public String getSystemId() {
return systemId;
}
public void setSystemId(String systemId) {
this.systemId = systemId;
}
public String getInterfaceId() {
return interfaceId;
}
public void setInterfaceId(String interfaceId) {
this.interfaceId = interfaceId;
}
public String getInterfaceName() {
return interfaceName;
}
public void setInterfaceName(String interfaceName) {
this.interfaceName = interfaceName;
}
public String getInterfaceVersion() {
return interfaceVersion;
}
public void setInterfaceVersion(String interfaceVersion) {
this.interfaceVersion = interfaceVersion;
}
}
|
2301_82000044/my-api-gateway
|
my-api-gateway-center/src/main/java/zack/gateway/center/domain/operation/model/vo/ApplicationInterfaceDataVO.java
|
Java
|
mit
| 1,309
|
package zack.gateway.center.domain.operation.model.vo;
/**
* @author zack
* @description 接口方法 VO
*/
public class ApplicationInterfaceMethodDataVO {
/** 系统标识 */
private String systemId;
/** 接口标识 */
private String interfaceId;
/** 方法标识 */
private String methodId;
/** 方法名称 */
private String methodName;
/** 参数类型(RPC 限定单参数注册)；new String[]{"java.lang.String"}、new String[]{"cn.bugstack.gateway.rpc.dto.XReq"} */
private String parameterType;
/** 网关接口 */
private String uri;
/** 接口类型；GET、POST、PUT、DELETE */
private String httpCommandType;
/** 是否鉴权；true = 1是、false = 0否 */
private Integer auth;
public ApplicationInterfaceMethodDataVO() {
}
public ApplicationInterfaceMethodDataVO(String systemId, String interfaceId) {
this.systemId = systemId;
this.interfaceId = interfaceId;
}
public String getSystemId() {
return systemId;
}
public void setSystemId(String systemId) {
this.systemId = systemId;
}
public String getInterfaceId() {
return interfaceId;
}
public void setInterfaceId(String interfaceId) {
this.interfaceId = interfaceId;
}
public String getMethodId() {
return methodId;
}
public void setMethodId(String methodId) {
this.methodId = methodId;
}
public String getMethodName() {
return methodName;
}
public void setMethodName(String methodName) {
this.methodName = methodName;
}
public String getParameterType() {
return parameterType;
}
public void setParameterType(String parameterType) {
this.parameterType = parameterType;
}
public String getUri() {
return uri;
}
public void setUri(String uri) {
this.uri = uri;
}
public String getHttpCommandType() {
return httpCommandType;
}
public void setHttpCommandType(String httpCommandType) {
this.httpCommandType = httpCommandType;
}
public Integer getAuth() {
return auth;
}
public void setAuth(Integer auth) {
this.auth = auth;
}
}
|
2301_82000044/my-api-gateway
|
my-api-gateway-center/src/main/java/zack/gateway/center/domain/operation/model/vo/ApplicationInterfaceMethodDataVO.java
|
Java
|
mit
| 2,272
|