最小化部署 git server ~





# 创建用户
`adduser git`

# 切换到 git 用户
`su - git`

# 创建裸仓库
没有工作目录，专用于服务器存储，不能直接编辑文件

```shell
mkdir -p /home/git/myproject.git
cd /home/git/myproject.git
git init --bare
```

# 创建钩子脚本
```shell
vim /home/git/myproject.git/hooks/post-receive
# 赋予执行权限
chmod +x /home/git/myproject.git/hooks/post-receive
```
钩子脚本内容
```shell
#!/bin/bash
# 执行你的自定义脚本
/path/to/your/script.sh
# 可选：输出日志到文件（调试用）
# echo "$(date): Push received" >> /tmp/git-hook.log
```

# 使用
```shell
git remote set-url origin ssh://git@42tr.cn:8899/home/git/x.git
```
本地使用
```shell
git clone ssh://git@127.0.0.1/home/git/x.git
```
钩子脚本权限问题 `sudo visudo` 增加一行
```
git ALL=(root) NOPASSWD: /path/to/your/script.sh
```
然后钩子脚本中改用 `sudo /path/to/your/script.sh` 执行

轻量化部署 git server

测试 cpu 和写入性能~



`Cargo.toml`
```toml
[package]
name = "test01"
version = "0.1.0"
edition = "2024"

[dependencies]
rand = "0.9.2"
rand_xoshiro = "0.7.0"
rayon = "1.11.0"
```

`main.rs`
```rust
use rand_xoshiro::Xoshiro256PlusPlus;
use rand::{RngCore, SeedableRng};
use std::fs::File;
use std::io::{BufWriter, Write};
use std::time::Instant;
use rayon::prelude::*;   // ← 需要这个

const CHARSET: &[u8; 64] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
const LINE_LEN: usize = 100;
const BATCH: usize = 100000;
const TOTAL_LINE: usize = 10_000_000;
const THREAD_NUM: usize = 8;

fn main() {
    rayon::ThreadPoolBuilder::new()
        .num_threads(THREAD_NUM)
        .build_global()
        .unwrap();

    let start = Instant::now();

    (0..THREAD_NUM).into_par_iter().for_each(|chunk| {
        let mut rng = Xoshiro256PlusPlus::seed_from_u64(123456 + chunk as u64);

        let filename = format!("log{}.txt", chunk);
        let file = File::create(filename).unwrap();
        let mut writer = BufWriter::new(file);

        let mut buf = vec![0u8; BATCH * LINE_LEN];

        for _ in 0..(TOTAL_LINE / THREAD_NUM / BATCH) {
            rng.fill_bytes(&mut buf);

            for b in &mut buf {
                *b = CHARSET[(*b & 63) as usize];
            }

            writer.write_all(&buf).unwrap();
        }

        writer.flush().unwrap();
    });

    println!("Time: {:?}", start.elapsed());
}
```

在 m1 macbook pro 8c 上
```plaintext
Time: 1.50388325s
```

rust 性能测试

QQ邮箱自动清理邮件，注意备份重要信息~



### `cargo.toml`
```toml
[package]
name = "email_helper"
version = "0.1.0"
edition = "2024"

[dependencies]
imap = "2.4"
native-tls = "0.2"
mailparse = "0.14"
serde = { version = "1", features = ["derive"] }
serde_json = "1"
anyhow = "1"
chrono = { version = "0.4", features = ["serde"] }
encoding_rs = "0.8"
```

### `main.rs`
```rust
use std::net::TcpStream;

use anyhow::Result;
use imap::{
    Session,
    types::{Fetch, Flag, ZeroCopy},
};
use mailparse::{MailHeaderMap, parse_mail};
use native_tls::{TlsConnector, TlsStream};

fn main() -> Result<()> {
    let imap_server = "smtp.qq.com";
    let imap_port = 993;
    let username = "xxx";
    let password = "xxx"; // 授权码

    // 创建 TLS 连接
    let tls = TlsConnector::builder().build()?;
    let client = native_tls::TlsConnector::connect(
        &tls,
        imap_server,
        std::net::TcpStream::connect((imap_server, imap_port))?,
    )?;

    // 使用 imap 2.4 登录
    let mut imap_session = imap::Client::new(client)
        .login(username, password)
        .map_err(|e| e.0)?;

    // 选择 INBOX
    let mailbox = imap_session.select("INBOX")?;
    println!("Total messages in INBOX: {}", mailbox.exists);

    let batch_size = 100;
    let mut start = 1;
    let total = mailbox.exists;
    while start <= total {
        let end = std::cmp::min(start + batch_size - 1, total);
        let sequence_set = format!("{}:{}", start, end);
        println!("Fetching emails {}-{}", start, end);

        let messages = imap_session.fetch(&sequence_set, "(UID FLAGS BODY.PEEK[])")?;
        println!("Fetched {} messages", messages.len());
        let result = handle_messages(&messages, &mut imap_session);
        if result.is_err() {
            println!("Error handling messages: {}", result.err().unwrap());
        }
        start += batch_size;
    }

    // 删除标记的邮件
    imap_session.expunge()?;

    imap_session.logout()?;
    println!("Completed");
    Ok(())
}

fn handle_messages(
    messages: &ZeroCopy<Vec<Fetch>>,
    session: &mut Session<TlsStream<TcpStream>>,
) -> Result<()> {
    for msg in messages.iter() {
        let uid = msg.uid;
        if uid.is_none() {
            println!("uid is none");
            continue;
        }
        let uid = uid.unwrap();
        if let Some(body) = msg.body() {
            let parsed = parse_mail(body)?;

            // 邮件头
            let subject = parsed
                .headers
                .get_first_value("Subject")
                .unwrap_or_default();
            let from = parsed.headers.get_first_value("From").unwrap_or_default();
            let seen = msg.flags().iter().any(|f| matches!(f, Flag::Seen));
            if !seen {
                println!("Email '{}' (UID {}) has not been seen", subject, uid);
                continue;
            }
            if from.contains("联想") || subject.contains("校招") || subject.contains("应聘")
                || subject.contains("校园招聘") || from.contains("校园招聘") || from.contains("校招") || from.contains("yunying1@alimail.zhaopin.com") || from.contains("service@steelport.zhaopin.com") || from.contains("RMASERVER@msi.com") || from.contains("billing@microsoft.com") || from.contains("noreply@steampowered.com") || from.contains("MicrosoftOffice365@email.office.com") || subject.contains("投递进度") || from.contains("no-reply@gitmail.oschina.net") || from.contains("imooc@dm.mukewang.com")
                || subject.contains("漫画更新")
                || subject.contains("ACM TechNews")
                || subject.contains("简单百宝箱")
                || subject.contains("启动完成")
                || (subject.contains("提醒") && from.contains("1055894396@qq.com"))
                || subject.contains("This is jumpserver.")
                || subject.contains("对您很感兴趣，邀您沟通")
                // 阿里云
                || from.contains("aliyun.com")
                // GitHub
                || from.contains("notifications@github.com")
                || subject.contains("[GitHub]")
                // other
                || from.contains("acmhelp@acm.org")
                || from.contains("no-reply@unity3d.com")
                || subject.contains("验证码") || subject.contains("Verification Code") || subject.contains("统一身份认证平台通知") || subject.contains("激活码") || subject.contains("email verification code") || subject.contains("用户注册确认") || subject.contains("Verify your email address")
                || from.contains("support@codepen.io") || from.contains("noreply@topcoder.com") || from.contains("music@tencent.com") || from.contains("cloud_noreply@tencent.com")
                || from.contains("ccfdigital@ccfservice.cn")
                || from.contains("csdn.net")
                || from.contains("51job.com")
                || from.contains("noreply@icloud.com.cn")
                || from.contains("no-reply@email.leetcode.cn") || from.contains("no-reply@email.leetcode-cn.com") || from.contains("no-reply@leetcode.com")
                || from.contains("admin@qq.com") || from.contains("10000@qq.com")
                || from.contains("topcoder.com")
                || subject.contains("安全提醒")
                || from.contains("support@codepen.io")
                || from.contains("huawei_ebg@research-satisfaction.com")
                || from.contains("contact@gitpod.io")
                || from.contains("no_reply@email.apple.com") || from.contains("shipping_notification@orders.apple.com") || from.contains("MarketResearch@insideapple.apple.com>") || from.contains("contact@scenario.com") || from.contains("no-reply@email.apple.com") || from.contains("do_not_reply@apple.com") || from.contains("OnlineResearch@insideapple.apple.com")
                || from.contains("info@service.yuque.com")
                || from.contains("noreply@shmail.ibeisen.com")
                || from.contains("noreply@blizzardgames.cn")
                || from.contains("updates-noreply@linkedin.com")
                || from.contains("no-reply@notify.docker.com")
                || from.contains("maya@meilisearch.com")
                || from.contains("notifications@gitbook.com")
                || from.contains("noreply@wakatime.com")
                || from.contains("hello@promos.memrise.com") || from.contains("elasticon@elastic.co") || from.contains("replies@oracle-mail.com") || from.contains("jobs-listings@linkedin.com") || from.contains("support@gitguardian.com") || from.contains("e@notification.coding.net") || from.contains("membership@ccf.org.cn") || from.contains("developer@photonengine.com") || from.contains("film@tencent.com") || from.contains("welcome@openrouter.ai")
            {
                // 标记删除
                let uid = msg.uid.ok_or("无法获取 UID").unwrap();
                session.uid_store(uid.to_string(), "+FLAGS (\\Deleted)")?;
                session.expunge()?;
                println!("Marked email '{}' (UID {}) for deletion", subject, uid);
            }
        }
    }
    Ok(())
}

```

邮件清理

在很多实际应用场景中，我们无法依赖网络请求（如高德、百度地图 API），例如：
- 内网系统
- 数据安全要求高的环境
- 移动端离线应用
- 批量处理大量地理数据

这时，**离线地理编码（Offline Geocoding）** 就成为必要选择。本文将介绍如何使用 GeoJSON + Shapely 在 Python 中实现 **经纬度 ↔ 地区名称** 的双向转换，并支持计算两地距离。



## 核心思路
- 数据源：使用包含中国行政区划边界的 GeoJSON 文件（如省、市、区县）
- 空间判断：利用 shapely 判断点是否在多边形内（反向编码）
- 几何中心：取行政区多边形的质心作为代表经纬度（正向编码）
- 距离计算：采用 Haversine 公式计算球面距离

## 所需依赖
```python
pip install shapely
```

## 数据准备
以下 `GeoJSON` 文件（可从[阿里云 DataV 地理工具](https://datav.aliyun.com/portal/school/atlas/area_selector?spm=a2ty_o01.29997173.0.0.691f51719yR1dE)下载）：
- `geo_province.json`：省级边界
- `geo_city.json`：市级边界
- `geo_china.json`：区县级边界（全国）

## 核心代码
```python
import json
import math
from shapely.geometry import Point, shape

class OfflineGeocoder:
    def __init__(self, geojson_paths):
        self.features = []
        self.code2name = {}
        for geojson_path in geojson_paths:
            with open(geojson_path, 'r', encoding='utf-8') as f:
                geojson_data = json.load(f)
                self.features.extend(geojson_data['features'])
                for feature in geojson_data['features']:
                    self.code2name[feature['properties']['adcode']] = feature['properties']['name']

        self.name_index = {}
        for feat in self.features:
            props = feat['properties']
            key = f"{props.get('name', '')}"
            self.name_index[key] = feat

    def position2region(self, lat, lon):
        """经纬度 → 地区"""
        point = Point(lon, lat)
        features = []
        for feat in self.features:
            if shape(feat['geometry']).contains(point):
                features.append(feat)
        ans = ""
        for feat in features:
            props = feat['properties']
            temp = ""
            for code in props.get('acroutes', []):
                temp += f"{self.code2name.get(code, '')}-"
            temp += f"{props.get('name', '')}"
            if len(temp) > len(ans):
                ans = temp
        return ans

    def region2position(self, full_name):
        """地区 → 经纬度（质心）"""
        feat = self.name_index.get(full_name)
        if not feat:
            return None
        centroid = shape(feat['geometry']).centroid
        return {'lat': centroid.y, 'lon': centroid.x}

    def distance_of_regions(self, region1, region2):
        """
        地区 → 距离（千米），保留 2 位小数
        """
        pos1 = self.region2position(region1)
        pos2 = self.region2position(region2)
        if not pos1 or not pos2:
            return None
        dis = self.distance_of_position(pos1['lat'], pos1['lon'], pos2['lat'], pos2['lon']) / 1000
        return f"{dis:.2f} km"

    def distance_of_position(self, lat1, lon1, lat2, lon2):
        """经纬度 → 距离（米）"""

        # 将度转换为弧度
        lat1_rad = math.radians(lat1)
        lon1_rad = math.radians(lon1)
        lat2_rad = math.radians(lat2)
        lon2_rad = math.radians(lon2)

        # 地球半径（米）
        R = 6371000

        # Haversine公式计算两点间距离
        dlat = lat2_rad - lat1_rad
        dlon = lon2_rad - lon1_rad

        a = math.sin(dlat/2)**2 + math.cos(lat1_rad) * math.cos(lat2_rad) * math.sin(dlon/2)**2
        c = 2 * math.atan2(math.sqrt(a), math.sqrt(1-a))

        distance = R * c
        return distance

Geo = OfflineGeocoder(["geo_china.json", "geo_province.json", "geo_city.json"])
```

测试

```python
from geo_helper import Geo

# 位置转地区
print(Geo.position2region(39.9087, 116.4729))

# 地区转位置
print(Geo.region2position("银川市"))

# 地区距离
print(Geo.distance_of_regions("银川市", "北京市"))
```

### ⚠️ 注意事项
- 地区重名问题：当前实现以“地区名”为 key，若存在重名（如多个“朝阳区”），会覆盖。生产环境建议使用 adcode 或完整路径作为 key。
- 性能优化：若需高频查询，可对多边形建立 R-tree 空间索引（使用 rtree 库）。
- 数据：可以自定义区域，新增对应的 json 文件即可。

离线环境下实现经纬度与地区名称双向转换

服务有的时候内存会升高，加个日志~



1. 先写个记录日志的脚本

```shell
#!/bin/bash

# 监控 systemctl status x 的脚本
# 作者: Assistant
# 日期: 2024

# 配置变量
SERVICE_NAME="x"
LOG_FILE="/var/log/x_status.log"
MAX_LOG_SIZE=100  # 最大日志文件大小（MB），超过则轮转

# 获取当前时间戳
TIMESTAMP=$(date '+%Y-%m-%d %H:%M:%S')

# 检查 systemctl 命令是否存在
if ! command -v systemctl &> /dev/null; then
    echo "[$TIMESTAMP] ERROR: systemctl command not found" >> "$LOG_FILE"
    exit 1
fi

# 检查服务是否存在
if ! systemctl list-units --full --all | grep -q "^${SERVICE_NAME}\."; then
    echo "[$TIMESTAMP] ERROR: Service '$SERVICE_NAME' not found" >> "$LOG_FILE"
    exit 1
fi

# 获取服务状态信息
STATUS_OUTPUT=$(systemctl status "$SERVICE_NAME" 2>&1)

# 写入日志文件
{
    echo "=== Status check at $TIMESTAMP ==="
    echo "$STATUS_OUTPUT"
    echo "=================================="
    echo ""
} >> "$LOG_FILE"

# 日志轮转功能（可选）
if [ -f "$LOG_FILE" ]; then
    # 获取当前日志文件大小（MB）
    CURRENT_SIZE=$(du -m "$LOG_FILE" 2>/dev/null | cut -f1)
    
    # 如果日志文件超过最大大小，进行轮转
    if [ "$CURRENT_SIZE" -gt "$MAX_LOG_SIZE" ]; then
        mv "$LOG_FILE" "${LOG_FILE}.old"
        echo "[$TIMESTAMP] Log file rotated due to size limit" >> "$LOG_FILE"
    fi
fi

echo "[$TIMESTAMP] Status check completed successfully"
```

2. 创建服务文件 `/etc/systemd/system/x-monitor.service`
```
[Unit]
Description=Monitor X service status
After=network.target

[Service]
Type=oneshot
ExecStart=/usr/local/bin/monitor_x_status.sh
User=root
```

3. 创建定时器文件 `/etc/systemd/system/x-monitor.timer`
```
[Unit]
Description=Run X service monitor every minute
Requires=x-monitor.service

[Timer]
OnCalendar=*:*:00
Persistent=true

[Install]
WantedBy=timers.target
```

4. 启用并启动定时器
```
# 重新加载 systemd 配置
sudo systemctl daemon-reload

# 启用并启动定时器
sudo systemctl enable --now x-monitor.timer

# 查看定时器状态
sudo systemctl status x-monitor.timer
```

5. 停止监控
```
systemctl disable --now x-monitor.timer
```