700 lines
23 KiB
Rust
700 lines
23 KiB
Rust
use std::collections::HashSet;
|
||
use std::path::{Path, PathBuf};
|
||
use std::time::Duration;
|
||
|
||
use futures_util::StreamExt;
|
||
use serde_json::Value;
|
||
use sqlx::SqlitePool;
|
||
use tauri::{AppHandle, Emitter, Manager, State};
|
||
use tauri_helper::auto_collect_command;
|
||
use tokio::io::AsyncWriteExt;
|
||
|
||
use crate::models::{
|
||
ApiResponse, FrpDownload, FrpDownloadPayload, FrpDownloadProgress, FrpRelease,
|
||
};
|
||
|
||
/// GitHub 镜像加速前缀（国内访问 GitHub 不稳定，拉取版本与下载统一走镜像）
|
||
const GITHUB_MIRROR: &str = "https://gh-proxy.com/";
|
||
/// frp 仓库 releases API
|
||
const RELEASES_API: &str = "https://api.github.com/repos/fatedier/frp/releases?per_page=30";
|
||
/// 下载进度事件名
|
||
const PROGRESS_EVENT: &str = "frp-download-progress";
|
||
|
||
/// frp_downloads 表统一查询字段
|
||
macro_rules! frp_fields {
|
||
() => {
|
||
"id, version, os, arch, platform, file_name, archive_path, frpc_path, frps_path, file_size, source, created_at, updated_at"
|
||
};
|
||
}
|
||
|
||
fn http_client() -> Result<reqwest::Client, reqwest::Error> {
|
||
reqwest::Client::builder()
|
||
.user_agent("FrpcPilot/0.1 (+https://github.com/fatedier/frp)")
|
||
.connect_timeout(Duration::from_secs(15))
|
||
.build()
|
||
}
|
||
|
||
/// 当前运行平台（os + arch），并映射为 frp 发行包的命名
|
||
fn current_platform() -> (String, String) {
|
||
let os = match std::env::consts::OS {
|
||
"macos" => "darwin",
|
||
other => other,
|
||
}
|
||
.to_string();
|
||
let arch = match std::env::consts::ARCH {
|
||
"x86_64" => "amd64",
|
||
"aarch64" => "arm64",
|
||
"x86" => "386",
|
||
other => other,
|
||
}
|
||
.to_string();
|
||
(os, arch)
|
||
}
|
||
|
||
/// 解析发行包文件名，返回 (版本, os, arch)
|
||
///
|
||
/// 形如 `frp_0.71.0_windows_amd64.zip` / `frp_0.71.0_linux_arm_hf.tar.gz`，
|
||
/// arch 部分可能包含下划线（如 arm_hf、mips_softfloat），故剩余部分整体拼接。
|
||
fn parse_asset(name: &str) -> Option<(String, String, String)> {
|
||
let rest = name.strip_prefix("frp_")?;
|
||
let rest = rest
|
||
.strip_suffix(".tar.gz")
|
||
.or_else(|| rest.strip_suffix(".zip"))?;
|
||
let mut parts = rest.split('_');
|
||
let version = parts.next()?.to_string();
|
||
let os = parts.next()?.to_string();
|
||
let arch = parts.collect::<Vec<_>>().join("_");
|
||
if version.is_empty() || os.is_empty() || arch.is_empty() {
|
||
return None;
|
||
}
|
||
Some((version, os, arch))
|
||
}
|
||
|
||
/// 从文件名中解析版本号（形如 0.71.0），返回带 v 前缀的版本号
|
||
fn parse_version(name: &str) -> Option<String> {
|
||
for raw in name.split(|c: char| !(c.is_ascii_digit() || c == '.' || c == 'v' || c == 'V')) {
|
||
let token = raw.trim_start_matches(|c| c == 'v' || c == 'V');
|
||
let parts: Vec<&str> = token.split('.').collect();
|
||
let valid = parts.len() >= 3
|
||
&& parts[..3]
|
||
.iter()
|
||
.all(|p| !p.is_empty() && p.chars().all(|c| c.is_ascii_digit()));
|
||
if valid {
|
||
return Some(format!("v{}.{}.{}", parts[0], parts[1], parts[2]));
|
||
}
|
||
}
|
||
None
|
||
}
|
||
|
||
async fn fetch_locals(pool: &SqlitePool) -> Result<Vec<FrpDownload>, sqlx::Error> {
|
||
sqlx::query_as::<_, FrpDownload>(concat!(
|
||
"SELECT ",
|
||
frp_fields!(),
|
||
" FROM frp_downloads ORDER BY id ASC"
|
||
))
|
||
.fetch_all(pool)
|
||
.await
|
||
}
|
||
|
||
async fn fetch_local(
|
||
pool: &SqlitePool,
|
||
version: &str,
|
||
platform: &str,
|
||
) -> Result<FrpDownload, sqlx::Error> {
|
||
sqlx::query_as::<_, FrpDownload>(concat!(
|
||
"SELECT ",
|
||
frp_fields!(),
|
||
" FROM frp_downloads WHERE version = ? AND platform = ?"
|
||
))
|
||
.bind(version)
|
||
.bind(platform)
|
||
.fetch_one(pool)
|
||
.await
|
||
}
|
||
|
||
/// 拉取 frp releases（镜像优先，失败回退直连）
|
||
async fn fetch_releases(client: &reqwest::Client) -> Result<Vec<Value>, String> {
|
||
let urls = [
|
||
format!("{GITHUB_MIRROR}{RELEASES_API}"),
|
||
RELEASES_API.to_string(),
|
||
];
|
||
let mut last_err = String::new();
|
||
for url in urls {
|
||
match client.get(&url).send().await {
|
||
Ok(resp) if resp.status().is_success() => match resp.json::<Value>().await {
|
||
Ok(Value::Array(list)) => return Ok(list),
|
||
Ok(_) => last_err = "返回数据格式异常".to_string(),
|
||
Err(e) => last_err = e.to_string(),
|
||
},
|
||
Ok(resp) => last_err = format!("HTTP {}", resp.status()),
|
||
Err(e) => last_err = e.to_string(),
|
||
}
|
||
}
|
||
Err(format!("获取 Frp 版本列表失败：{last_err}"))
|
||
}
|
||
|
||
/// 应用数据目录下的 frp 版本存储根目录
|
||
fn versions_dir(app: &AppHandle) -> Result<PathBuf, String> {
|
||
Ok(app
|
||
.path()
|
||
.app_data_dir()
|
||
.map_err(|e| e.to_string())?
|
||
.join("frp")
|
||
.join("versions"))
|
||
}
|
||
|
||
/// 发送下载进度事件
|
||
fn emit_progress(
|
||
app: &AppHandle,
|
||
payload: &FrpDownloadPayload,
|
||
downloaded: u64,
|
||
total: u64,
|
||
status: &str,
|
||
message: Option<&str>,
|
||
) {
|
||
let percent = if total > 0 {
|
||
((downloaded as f64 / total as f64) * 100.0).clamp(0.0, 100.0).round() as u8
|
||
} else {
|
||
0
|
||
};
|
||
let _ = app.emit(
|
||
PROGRESS_EVENT,
|
||
FrpDownloadProgress {
|
||
key: payload.file_name.clone(),
|
||
version: payload.version.clone(),
|
||
platform: payload.platform.clone(),
|
||
downloaded,
|
||
total,
|
||
percent,
|
||
status: status.to_string(),
|
||
message: message.map(|m| m.to_string()),
|
||
},
|
||
);
|
||
}
|
||
|
||
/// 获取 Frp 版本列表（返回所有架构的发行包，并合并本机已下载 / 已导入记录）
|
||
///
|
||
/// 前端根据平台下拉列表在本地过滤，避免频繁请求 GitHub API 触发限流；
|
||
/// 默认仅展示当前运行平台由前端完成。
|
||
#[tauri::command]
|
||
#[auto_collect_command]
|
||
pub async fn get_frp_releases(
|
||
state: State<'_, SqlitePool>,
|
||
) -> Result<ApiResponse<Vec<FrpRelease>>, String> {
|
||
let client = match http_client() {
|
||
Ok(c) => c,
|
||
Err(e) => return Ok(ApiResponse::error(500, &e.to_string())),
|
||
};
|
||
let releases = match fetch_releases(&client).await {
|
||
Ok(list) => list,
|
||
Err(e) => return Ok(ApiResponse::error(500, &e)),
|
||
};
|
||
let locals = match fetch_locals(&state).await {
|
||
Ok(list) => list,
|
||
Err(e) => return Ok(ApiResponse::error(500, &e.to_string())),
|
||
};
|
||
|
||
let (cur_os, cur_arch) = current_platform();
|
||
let cur_platform = format!("{cur_os}_{cur_arch}");
|
||
|
||
let mut list: Vec<FrpRelease> = Vec::new();
|
||
let mut matched: HashSet<String> = HashSet::new();
|
||
|
||
for rel in &releases {
|
||
let version = rel
|
||
.get("tag_name")
|
||
.and_then(Value::as_str)
|
||
.unwrap_or_default()
|
||
.to_string();
|
||
if version.is_empty() {
|
||
continue;
|
||
}
|
||
let published_at = rel
|
||
.get("published_at")
|
||
.and_then(Value::as_str)
|
||
.unwrap_or_default()
|
||
.to_string();
|
||
let Some(assets) = rel.get("assets").and_then(Value::as_array) else {
|
||
continue;
|
||
};
|
||
|
||
for asset in assets {
|
||
let name = asset.get("name").and_then(Value::as_str).unwrap_or_default();
|
||
let Some((_v, os, arch)) = parse_asset(name) else {
|
||
continue;
|
||
};
|
||
let platform = format!("{os}_{arch}");
|
||
let matches = os == cur_os && arch == cur_arch;
|
||
|
||
let size = asset.get("size").and_then(Value::as_i64).unwrap_or(0);
|
||
let download_count = asset
|
||
.get("download_count")
|
||
.and_then(Value::as_i64)
|
||
.unwrap_or(0);
|
||
let url = asset
|
||
.get("browser_download_url")
|
||
.and_then(Value::as_str)
|
||
.unwrap_or_default()
|
||
.to_string();
|
||
|
||
let local = locals
|
||
.iter()
|
||
.find(|l| l.version == version && l.platform == platform);
|
||
if let Some(l) = local {
|
||
matched.insert(format!("{}|{}", l.version, l.platform));
|
||
}
|
||
|
||
list.push(FrpRelease {
|
||
version: version.clone(),
|
||
os,
|
||
arch,
|
||
platform,
|
||
file_name: name.to_string(),
|
||
size,
|
||
download_count,
|
||
published_at: published_at.clone(),
|
||
mirror_url: format!("{GITHUB_MIRROR}{url}"),
|
||
download_url: url,
|
||
downloaded: local.is_some(),
|
||
is_current: matches,
|
||
local_only: false,
|
||
local_id: local.map(|l| l.id),
|
||
frpc_path: local.and_then(|l| l.frpc_path.clone()),
|
||
frps_path: local.and_then(|l| l.frps_path.clone()),
|
||
});
|
||
}
|
||
}
|
||
|
||
// 本机已下载 / 导入但未匹配到发行包的记录，单独作为本地卡片展示
|
||
for l in &locals {
|
||
if matched.contains(&format!("{}|{}", l.version, l.platform)) {
|
||
continue;
|
||
}
|
||
list.push(FrpRelease {
|
||
version: l.version.clone(),
|
||
os: l.os.clone(),
|
||
arch: l.arch.clone(),
|
||
platform: l.platform.clone(),
|
||
file_name: l.file_name.clone(),
|
||
size: l.file_size,
|
||
download_count: 0,
|
||
published_at: String::new(),
|
||
download_url: String::new(),
|
||
mirror_url: String::new(),
|
||
downloaded: true,
|
||
is_current: l.platform == cur_platform,
|
||
local_only: true,
|
||
local_id: Some(l.id),
|
||
frpc_path: l.frpc_path.clone(),
|
||
frps_path: l.frps_path.clone(),
|
||
});
|
||
}
|
||
|
||
// 当前平台优先，其次版本新到旧
|
||
list.sort_by(|a, b| {
|
||
let ap = a.platform == cur_platform;
|
||
let bp = b.platform == cur_platform;
|
||
bp.cmp(&ap)
|
||
.then_with(|| b.published_at.cmp(&a.published_at))
|
||
.then_with(|| b.version.cmp(&a.version))
|
||
});
|
||
|
||
Ok(ApiResponse::success(list))
|
||
}
|
||
|
||
/// 获取本机已下载 / 已导入的 Frp 版本列表（仪表盘选择 frpc 版本用）
|
||
#[tauri::command]
|
||
#[auto_collect_command]
|
||
pub async fn get_frp_downloads(
|
||
state: State<'_, SqlitePool>,
|
||
) -> Result<ApiResponse<Vec<FrpDownload>>, String> {
|
||
let list = sqlx::query_as::<_, FrpDownload>(concat!(
|
||
"SELECT ",
|
||
frp_fields!(),
|
||
" FROM frp_downloads ORDER BY created_at DESC, id DESC"
|
||
))
|
||
.fetch_all(&*state)
|
||
.await;
|
||
|
||
Ok(match list {
|
||
Ok(list) => ApiResponse::success(list),
|
||
Err(e) => ApiResponse::error(500, &e.to_string()),
|
||
})
|
||
}
|
||
|
||
/// 下载并解压指定 Frp 发行包
|
||
#[tauri::command]
|
||
#[auto_collect_command]
|
||
pub async fn download_frp(
|
||
app: AppHandle,
|
||
state: State<'_, SqlitePool>,
|
||
payload: FrpDownloadPayload,
|
||
) -> Result<ApiResponse<FrpDownload>, String> {
|
||
match do_download(&app, &state, &payload).await {
|
||
Ok(row) => Ok(ApiResponse::success(row)),
|
||
Err(e) => {
|
||
emit_progress(&app, &payload, 0, 0, "error", Some(&e));
|
||
Ok(ApiResponse::error(500, &e))
|
||
}
|
||
}
|
||
}
|
||
|
||
async fn do_download(
|
||
app: &AppHandle,
|
||
pool: &SqlitePool,
|
||
payload: &FrpDownloadPayload,
|
||
) -> Result<FrpDownload, String> {
|
||
let client = http_client().map_err(|e| e.to_string())?;
|
||
|
||
let ver_dir = versions_dir(app)?.join(&payload.version);
|
||
let extract_dir = ver_dir.join(&payload.platform);
|
||
tokio::fs::create_dir_all(&extract_dir)
|
||
.await
|
||
.map_err(|e| e.to_string())?;
|
||
let archive_path = ver_dir.join(&payload.file_name);
|
||
|
||
// 压缩包不存在（或为空）时才重新下载
|
||
let need_download = match tokio::fs::metadata(&archive_path).await {
|
||
Ok(meta) => meta.len() == 0,
|
||
Err(_) => true,
|
||
};
|
||
if need_download {
|
||
download_file(app, &client, payload, &archive_path).await?;
|
||
}
|
||
|
||
// 已解压过则跳过解压
|
||
if find_binary(&extract_dir, "frpc").is_none() && find_binary(&extract_dir, "frps").is_none() {
|
||
emit_progress(app, payload, 0, 0, "extracting", None);
|
||
extract_archive(&archive_path, &extract_dir).await?;
|
||
}
|
||
|
||
let frpc = find_binary(&extract_dir, "frpc");
|
||
let frps = find_binary(&extract_dir, "frps");
|
||
if frpc.is_none() && frps.is_none() {
|
||
return Err("解压完成，但未找到 frpc / frps 可执行文件".to_string());
|
||
}
|
||
if let Some(path) = &frpc {
|
||
make_executable(path);
|
||
}
|
||
if let Some(path) = &frps {
|
||
make_executable(path);
|
||
}
|
||
|
||
let size = tokio::fs::metadata(&archive_path)
|
||
.await
|
||
.map(|m| m.len() as i64)
|
||
.unwrap_or(0);
|
||
|
||
sqlx::query(
|
||
"INSERT INTO frp_downloads (version, os, arch, platform, file_name, archive_path, frpc_path, frps_path, file_size, source) \
|
||
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 'download') \
|
||
ON CONFLICT(version, platform) DO UPDATE SET \
|
||
file_name = excluded.file_name, archive_path = excluded.archive_path, \
|
||
frpc_path = excluded.frpc_path, frps_path = excluded.frps_path, \
|
||
file_size = excluded.file_size, source = 'download', \
|
||
updated_at = datetime('now', 'localtime')",
|
||
)
|
||
.bind(&payload.version)
|
||
.bind(&payload.os)
|
||
.bind(&payload.arch)
|
||
.bind(&payload.platform)
|
||
.bind(&payload.file_name)
|
||
.bind(archive_path.to_string_lossy().to_string())
|
||
.bind(frpc.as_ref().map(|p| p.to_string_lossy().to_string()))
|
||
.bind(frps.as_ref().map(|p| p.to_string_lossy().to_string()))
|
||
.bind(size)
|
||
.execute(pool)
|
||
.await
|
||
.map_err(|e| e.to_string())?;
|
||
|
||
emit_progress(app, payload, 1, 1, "done", None);
|
||
fetch_local(pool, &payload.version, &payload.platform)
|
||
.await
|
||
.map_err(|e| e.to_string())
|
||
}
|
||
|
||
/// 下载压缩包（镜像优先，失败回退直连），并持续上报进度
|
||
async fn download_file(
|
||
app: &AppHandle,
|
||
client: &reqwest::Client,
|
||
payload: &FrpDownloadPayload,
|
||
archive_path: &Path,
|
||
) -> Result<(), String> {
|
||
let urls = [
|
||
format!("{GITHUB_MIRROR}{}", payload.download_url),
|
||
payload.download_url.clone(),
|
||
];
|
||
let mut last_err = String::new();
|
||
|
||
for url in urls {
|
||
match client.get(&url).send().await {
|
||
Ok(resp) if resp.status().is_success() => {
|
||
let total = resp.content_length().unwrap_or(0);
|
||
let mut file = tokio::fs::File::create(archive_path)
|
||
.await
|
||
.map_err(|e| e.to_string())?;
|
||
let mut downloaded: u64 = 0;
|
||
let mut stream = resp.bytes_stream();
|
||
let mut stream_err: Option<String> = None;
|
||
emit_progress(app, payload, 0, total, "downloading", None);
|
||
|
||
while let Some(chunk) = stream.next().await {
|
||
match chunk {
|
||
Ok(bytes) => {
|
||
file.write_all(&bytes).await.map_err(|e| e.to_string())?;
|
||
downloaded += bytes.len() as u64;
|
||
emit_progress(app, payload, downloaded, total, "downloading", None);
|
||
}
|
||
Err(e) => {
|
||
stream_err = Some(e.to_string());
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
if let Some(err) = stream_err {
|
||
// 本次下载中断，清理残缺文件后尝试下一个源
|
||
let _ = file.shutdown().await;
|
||
let _ = tokio::fs::remove_file(archive_path).await;
|
||
last_err = err;
|
||
continue;
|
||
}
|
||
|
||
let _ = file.flush().await;
|
||
return Ok(());
|
||
}
|
||
Ok(resp) => last_err = format!("HTTP {}", resp.status()),
|
||
Err(e) => last_err = e.to_string(),
|
||
}
|
||
}
|
||
|
||
Err(format!("下载失败：{last_err}"))
|
||
}
|
||
|
||
/// 解压发行包。Windows 为 zip、类 Unix 为 tar.gz，统一使用系统 tar 命令
|
||
/// （Windows 10+ 内置 bsdtar，可同时处理 zip 与 tar.gz）
|
||
async fn extract_archive(archive: &Path, dest: &Path) -> Result<(), String> {
|
||
let archive = archive.to_path_buf();
|
||
let dest = dest.to_path_buf();
|
||
tokio::task::spawn_blocking(move || {
|
||
let output = std::process::Command::new("tar")
|
||
.arg("-xf")
|
||
.arg(&archive)
|
||
.arg("-C")
|
||
.arg(&dest)
|
||
.output()
|
||
.map_err(|e| format!("调用 tar 解压失败：{e}"))?;
|
||
if !output.status.success() {
|
||
return Err(format!(
|
||
"解压失败：{}",
|
||
String::from_utf8_lossy(&output.stderr).trim()
|
||
));
|
||
}
|
||
Ok(())
|
||
})
|
||
.await
|
||
.map_err(|e| e.to_string())?
|
||
}
|
||
|
||
/// 在目录中递归查找 frpc / frps 可执行文件
|
||
fn find_binary(dir: &Path, stem: &str) -> Option<PathBuf> {
|
||
let stem_lower = stem.to_ascii_lowercase();
|
||
let mut stack = vec![dir.to_path_buf()];
|
||
while let Some(current) = stack.pop() {
|
||
let Ok(entries) = std::fs::read_dir(¤t) else {
|
||
continue;
|
||
};
|
||
for entry in entries.flatten() {
|
||
let path = entry.path();
|
||
if path.is_dir() {
|
||
stack.push(path);
|
||
continue;
|
||
}
|
||
let Some(name) = path.file_name().map(|s| s.to_string_lossy().to_ascii_lowercase())
|
||
else {
|
||
continue;
|
||
};
|
||
if name == stem_lower || name == format!("{stem_lower}.exe") {
|
||
return Some(path);
|
||
}
|
||
}
|
||
}
|
||
None
|
||
}
|
||
|
||
#[cfg(unix)]
|
||
fn make_executable(path: &Path) {
|
||
use std::os::unix::fs::PermissionsExt;
|
||
if let Ok(meta) = std::fs::metadata(path) {
|
||
let mut perms = meta.permissions();
|
||
perms.set_mode(0o755);
|
||
let _ = std::fs::set_permissions(path, perms);
|
||
}
|
||
}
|
||
|
||
#[cfg(not(unix))]
|
||
fn make_executable(_path: &Path) {}
|
||
|
||
/// 删除已下载 / 已导入的版本（同时清理本地文件）
|
||
#[tauri::command]
|
||
#[auto_collect_command]
|
||
pub async fn delete_frp(
|
||
app: AppHandle,
|
||
state: State<'_, SqlitePool>,
|
||
id: i64,
|
||
) -> Result<ApiResponse<()>, String> {
|
||
let row = match sqlx::query_as::<_, FrpDownload>(concat!(
|
||
"SELECT ",
|
||
frp_fields!(),
|
||
" FROM frp_downloads WHERE id = ?"
|
||
))
|
||
.bind(id)
|
||
.fetch_optional(&*state)
|
||
.await
|
||
{
|
||
Ok(Some(row)) => row,
|
||
Ok(None) => return Ok(ApiResponse::error(404, "记录不存在")),
|
||
Err(e) => return Ok(ApiResponse::error(500, &e.to_string())),
|
||
};
|
||
|
||
if let Ok(base) = versions_dir(&app) {
|
||
let ver_dir = base.join(&row.version);
|
||
let _ = tokio::fs::remove_dir_all(ver_dir.join(&row.platform)).await;
|
||
if let Some(archive) = &row.archive_path {
|
||
let _ = tokio::fs::remove_file(archive).await;
|
||
}
|
||
// 版本目录已空则一并删除
|
||
if let Ok(mut entries) = tokio::fs::read_dir(&ver_dir).await {
|
||
if matches!(entries.next_entry().await, Ok(None)) {
|
||
let _ = tokio::fs::remove_dir(&ver_dir).await;
|
||
}
|
||
}
|
||
}
|
||
|
||
match sqlx::query("DELETE FROM frp_downloads WHERE id = ?")
|
||
.bind(id)
|
||
.execute(&*state)
|
||
.await
|
||
{
|
||
Ok(_) => Ok(ApiResponse::success_empty()),
|
||
Err(e) => Ok(ApiResponse::error(500, &e.to_string())),
|
||
}
|
||
}
|
||
|
||
/// 导入本地已下载的 frpc / frps（记录可执行文件路径，不复制文件）
|
||
#[tauri::command]
|
||
#[auto_collect_command]
|
||
pub async fn import_frp(
|
||
app: AppHandle,
|
||
state: State<'_, SqlitePool>,
|
||
) -> Result<ApiResponse<Vec<FrpDownload>>, String> {
|
||
use tauri_plugin_dialog::DialogExt;
|
||
|
||
let picked = app
|
||
.dialog()
|
||
.file()
|
||
.set_title("选择本地已下载的 frpc / frps")
|
||
.blocking_pick_files();
|
||
let Some(files) = picked else {
|
||
return Ok(ApiResponse::success(Vec::new()));
|
||
};
|
||
|
||
let (os, arch) = current_platform();
|
||
let platform = format!("{os}_{arch}");
|
||
let mut result = Vec::new();
|
||
|
||
for file in files {
|
||
let path = match file.into_path() {
|
||
Ok(path) => path,
|
||
Err(e) => return Ok(ApiResponse::error(500, &e.to_string())),
|
||
};
|
||
let file_name = path
|
||
.file_name()
|
||
.map(|s| s.to_string_lossy().to_string())
|
||
.unwrap_or_default();
|
||
let size = std::fs::metadata(&path).map(|m| m.len() as i64).unwrap_or(0);
|
||
let lower = file_name.to_ascii_lowercase();
|
||
let is_frps = lower.contains("frps");
|
||
let version = parse_version(&file_name).unwrap_or_else(|| file_name.clone());
|
||
let full = path.to_string_lossy().to_string();
|
||
let (frpc_path, frps_path) = if is_frps {
|
||
(None, Some(full))
|
||
} else {
|
||
(Some(full), None)
|
||
};
|
||
|
||
let exec = sqlx::query(
|
||
"INSERT INTO frp_downloads (version, os, arch, platform, file_name, frpc_path, frps_path, file_size, source) \
|
||
VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'import') \
|
||
ON CONFLICT(version, platform) DO UPDATE SET \
|
||
frpc_path = COALESCE(excluded.frpc_path, frp_downloads.frpc_path), \
|
||
frps_path = COALESCE(excluded.frps_path, frp_downloads.frps_path), \
|
||
file_size = CASE WHEN excluded.file_size > 0 THEN excluded.file_size ELSE frp_downloads.file_size END, \
|
||
source = 'import', updated_at = datetime('now', 'localtime')",
|
||
)
|
||
.bind(&version)
|
||
.bind(&os)
|
||
.bind(&arch)
|
||
.bind(&platform)
|
||
.bind(&file_name)
|
||
.bind(frpc_path)
|
||
.bind(frps_path)
|
||
.bind(size)
|
||
.execute(&*state)
|
||
.await;
|
||
|
||
match exec {
|
||
Ok(_) => {
|
||
if let Ok(row) = fetch_local(&state, &version, &platform).await {
|
||
result.push(row);
|
||
}
|
||
}
|
||
Err(e) => return Ok(ApiResponse::error(500, &e.to_string())),
|
||
}
|
||
}
|
||
|
||
Ok(ApiResponse::success(result))
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use super::*;
|
||
|
||
#[test]
|
||
fn parse_asset_handles_common_names() {
|
||
assert_eq!(
|
||
parse_asset("frp_0.71.0_windows_amd64.zip"),
|
||
Some(("0.71.0".into(), "windows".into(), "amd64".into()))
|
||
);
|
||
assert_eq!(
|
||
parse_asset("frp_0.71.0_linux_arm64.tar.gz"),
|
||
Some(("0.71.0".into(), "linux".into(), "arm64".into()))
|
||
);
|
||
// arch 含下划线的情况
|
||
assert_eq!(
|
||
parse_asset("frp_0.71.0_linux_arm_hf.tar.gz"),
|
||
Some(("0.71.0".into(), "linux".into(), "arm_hf".into()))
|
||
);
|
||
assert_eq!(parse_asset("frp_0.71.0_linux_mips_softfloat.tar.gz"), {
|
||
Some(("0.71.0".into(), "linux".into(), "mips_softfloat".into()))
|
||
});
|
||
assert_eq!(parse_asset("readme.md"), None);
|
||
}
|
||
|
||
#[test]
|
||
fn parse_version_extracts_semver() {
|
||
assert_eq!(parse_version("frpc_0.71.0_windows_amd64.exe"), Some("v0.71.0".into()));
|
||
assert_eq!(parse_version("frps-v0.60.0"), Some("v0.60.0".into()));
|
||
assert_eq!(parse_version("frpc.exe"), None);
|
||
assert_eq!(parse_version("frpc_0.71.exe"), None);
|
||
}
|
||
|
||
#[test]
|
||
fn current_platform_is_known() {
|
||
let (os, arch) = current_platform();
|
||
assert!(!os.is_empty());
|
||
assert!(!arch.is_empty());
|
||
println!("current platform: {os}_{arch}");
|
||
}
|
||
}
|