使用 bark，Android 可以使用 gotify~



## docker 部署

`docker run -dt --name bark -p 16009:8080 -v /disk/app/bark/data:/data finab/bark-server`

## ios 应用下载
下载 bark，添加服务器

![IMG_4836.PNG](/static/img/eb9cfee42c115c2595268127e7cf2f37.IMG_4836.PNG)

## 发送请求
curl https://bark.ioiox.com/your_key/标题/内容

更多参见 bark 应用里的例子

ios 消息推送

树莓派的存储卡空间不足，迁移到机械硬盘中~



- 关闭 `docker` 服务 `systemctl stop docker.socket`
- 迁移路径 `rsync -avzP /var/lib/docker  /disk/docker`
- 备份数据目录 `mv /var/lib/docker /var/lib/docker.bak`
- 添加软链接 `ln -s /disk/docker/ /var/lib/`
- 重启 `docker` 服务 `systemctl start docker`
- **确认 `docker` 正常**
- 删除备份目录 `rm -rf /var/lib/docker.bak`

docker 迁移

基于 docker 搭建 node-exporter + Prometheus + Grafana 服务器监控平台
![image.png](/static/img/a737c85315a34c42978f48da16a3d713.image.png)


# 安装
## 安装 node-export
`docker run -d --restart=always -p 9100:9100 prom/node-exporter`

验证：访问 http://服务器IP:9100/metrics

![image.png](/static/img/603f9177fe340e8e62ab80023d0a43f4.image.png)

## 安装 Prometheus
准备 `/disk/app/prometheus/prometheus.yml`，`IP地址` 替换成 node-exporter 所在服务器地址
```yml
global:
  scrape_interval: 60s
  evaluation_interval: 60s
 
scrape_configs:
  - job_name: prometheus
    static_configs:
      - targets: ['localhost:9090']
        labels:
          instance: prometheus
 
  - job_name: linux
    static_configs:
      - targets: ['IP地址:9100']
        labels:
          instance: localhost
```
创建 docker 容器 `docker run -d --restart=always -p 9090:9090 -v /disk/app/prometheus/prometheus.yml:/etc/prometheus/prometheus.yml prom/prometheus`

验证：访问 http://IP地址:9090
![image.png](/static/img/f27d773f60e8bb4b9cf5232172b9436a.image.png)

## 安装 grafana
`docker run -d --restart=always --name grafana -p 3000:3000  grafana/grafana`

访问 192.168.1.3:3000，用户名密码都是 admin

添加数据源
![image.png](/static/img/7817ec5761d0b6a9c04e4af4d59bbebc.image.png)

下载ID为11074的[模板文件](https://grafana.com/grafana/dashboards/11074)
![image.png](/static/img/d9518468ce8790a340294635d815b3b0.image.png)
使用下载的模板文件创建仪表盘
![image.png](/static/img/58cb1399a5f3fb29b47bb7c61b73fabc.image.png)
效果
![image.png](/static/img/a737c85315a34c42978f48da16a3d713.image.png)

服务监控

使用 log 加具体实现库，完成 rust 的日志操作~



# log - 日志门面
`slf4j` 是 Java 的日志门面库，`log` 是 Rust 的日志门面库，由官方积极维护可以放心使用。相应的日志 API 已成为事实上的标准，被其它日志框架所使用，有了日志门面开发者可以很方便切换自己的日志框架。
> A lightweight logging facade.
> 
> The log crate provides a single logging API that abstracts over the actual logging implementation. Libraries can use the logging API provided by this crate, and the consumer of those libraries can choose the logging implementation that is most suitable for its use case.
> 
> If no logging implementation is selected, the facade falls back to a “noop” implementation that ignores all log messages. The overhead in this case is very small - just an integer load, comparison and jump.
> 
> A log request consists of a target, a level, and a body. A target is a string which defaults to the module path of the location of the log request, though that default may be overridden. Logger implementations typically use the target to filter requests based on some user configuration.

## 使用
引入
```toml
[dependencies]
log = "0.4"
```
或
```shell
cargo add log
```
使用
```rust
use log::{info, warn,error,trace};

fn main() {
    // 记录日志
    info!("This is an info message");
    warn!("This is a warning message");
    error!("This is an error message");
    trace!("This is an trace message");
}
```
运行上面的示例，实际上看不到任何输出。因为 log 仅仅是日志门面库，它并不具备完整的日志库功能！
因为 log 仅仅是日志门面库，对于库和应用的开发者来说使用方法是有区别的，这也是 log 包这么设计的优势所在。

除了以上常用的，`log` 还提供了 `log!` 和 `log_enabled!` 宏，后者用于确定一条消息在当前模块中，对于给定的日志级别是否能够被记录。
```rust
use log::Level::Debug;
use log::{debug, log_enabled};

// 判断能否记录 Debug 消息
if log_enabled!(Debug) {
    let data = expensive_call();
     // 下面的日志记录较为昂贵，因此我们先在前面判断了是否能够记录，能，才继续这里的逻辑
    debug!("expensive debug data: {} {}", data.x, data.y);
}
if log_enabled!(target: "Global", Debug) {
   let data = expensive_call();
   debug!(target: "Global", "expensive debug data: {} {}", data.x, data.y);
}
```
而 `log!` 宏就简单的多，它是一个通用的日志记录方式，因此需要我们手动指定日志级别：
```rust
use log::{log, Level};

let data = (42, "Forty-two");
let private_data = "private";

log!(Level::Error, "Received errors: {}, {}", data.0, data.1);
log!(target: "app_events", Level::Warn, "App warning: {}, {}, {}",
    data.0, data.1, private_data);
```


### 库的开发者
作为库的开发者，你只要在库中使用门面库即可，将具体的日志库交给用户去选择和绑定：
```rust
use log::{info, trace, warn};
pub fn deal_with_something() {
    // 开始处理

    // 记录一些日志
    trace!("a trace log");
    info!("a info long: {}", "abc");
    warn!("a warning log: {}, retrying", err);

    // 结束处理
}
```
### 应用开发者
如果是应用开发者，就需要去选择一个具体的日志库了。

目前已经有了不少日志库实现，官方在 github 上也推荐了一些 ，主要分为以下几类：

- 简单的最小记录器，如 env_logger 等
- 复杂的可配置框架，如 log4rs 等
- 其他设施的适配器，如 syslog、db_logger 等
- 对于 WebAssembly 二进制文件：console_log
- 对于动态库：需要在日志上构造一个 FFI 安全包装器，以便在库中进行初始化。
- 实用程序，如 alterable_logger 等

### 日志库开发者
对于日志库开发者而言，自然要实现自己的 Log 特征:
```rust
use log::{Record, Level, Metadata};
struct SimpleLogger;
impl log::Log for SimpleLogger {
    fn enabled(&self, metadata: &Metadata) -> bool {
        metadata.level() <= Level::Info
    }
    fn log(&self, record: &Record) {
        if self.enabled(record.metadata()) {
            println!("{} - {}", record.level(), record.args());
        }
    }
    fn flush(&self) {}
}
```
除此之外，还需要包装下 `set_logger` 和 `set_max_level`：
```rust
use log::{SetLoggerError, LevelFilter};
static LOGGER: SimpleLogger = SimpleLogger;
pub fn init() -> Result<(), SetLoggerError> {
    log::set_logger(&LOGGER)
        .map(|()| log::set_max_level(LevelFilter::Info))
}
```
然后在 `main` 函数里设置全局记录器：
```rust
use log::{info, warn,error,trace};

fn main() {
    //设置日志
    init();
    // 记录日志
    info!("This is an info message");
    warn!("This is a warning message");
    error!("This is an error message");
    trace!("This is an trace message");
}
```
运行后终端输出如下，因为设置日志等级为Info，所以没有输出Trace等级日志：
```log
INFO - This is an info message
WARN - This is a warning message
ERROR - This is an error message
```

# log4rs
[`log4rs`](https://github.com/estk/log4rs/tree/main) 是一个高度可配置的日志框架，以 Java 的 `Logback` 和 `log4j` 库为模型。

## 使用
### 添加依赖
```shell
cargo add log4rs
```
### 添加配置文件
在项目根目录下，创建一个 `log4rs.yaml` 配置文件，并添加以下内容：
```yaml
refresh_rate: 30 seconds

appenders:
  stdout:
    kind: console
    encoder:
      pattern: "{d(%Y-%m-%d %H:%M:%S.%f)} [{l}] {t} - {m}{n}"
  
  rolling_file:
    kind: rolling_file
    path: logs/test.log
    append: true 
    encoder:
      pattern: "{d(%Y-%m-%d %H:%M:%S.%f)} [{l}] {t} - {m}{n}"
    policy:
      kind: compound
      trigger:
        kind: size
        limit: 10 mb
      roller:        
        kind: fixed_window
        pattern: logs/test.{}.log
        base: 1
        count: 5
        
root:
  level: info 
  appenders:
    - stdout
    - rolling_file
```
上面配置文件设定日志输出到控制台、文件，文件按10 mb大小滚动，只保留最近五个文件。各个配置字段的具体含义可以参考配置：
- refresh_rate：用于确定 log4rs 扫描配置文件以查找更改的频率，如果发现更改，记录器将自动重新配置
- appender： 负责将日志收集到文件、控制台或系统日志, 可配置多个
- stdout、rolling_file：追加器的唯一标识字符串，自己随便定义，它的 kind 字段只支持console、file、rolling_file 三种实现
- encoder： 负责将 log 信息转换为合适的格式, 如固定格式的平文本或json
- pattern：编码模板，格式可配置，具体格式详见pattern
- policy：策略字段，策略必须具有 kind 字段，默认（且仅受支持）策略为 kind: compound
- trigger：触发器字段用于指示何时滚动日志文件，支持 size 和 time 两种类型，这里使用的是按大小

### 使用
```rust
use log::*;
use log4rs;

fn main() {
    log4rs::init_file("log4rs.yaml", Default::default()).unwrap();

    for i in 1..=1000 {
        info!("This is loop iteration {}", i);
    }
}
```
运行结果
```log
2024-04-01 15:43:28.596832500 [INFO] hello_world - This is loop iteration 1
```

# 参考
> [Rust 实现日志记录功能](https://www.cnblogs.com/timefiles/p/18108881)

Rust 日志

canvas 实现粒子效果案例~



```html
<html>
    <head> </head>
    <body>
        <canvas id="canvas"></canvas>
        <script>
            class Vector2 {
                constructor(x, y) {
                    this.x = x;
                    this.y = y;
                }
                set(x, y) {
                    this.x = x;
                    this.y = y;
                    return this;
                }
                clone() {
                    return new Vector2(this.x, this.y);
                }
                add(v) {
                    this.x += v.x;
                    this.y += v.y;
                    return this;
                }
                sub(v) {
                    this.x -= v.x;
                    this.y -= v.y;
                    return this;
                }
                mult(v) {
                    this.x *= v.x;
                    this.y *= v.y;
                    return this;
                }
                magnitude() {
                    return Math.sqrt(this.x * this.x + this.y * this.y);
                }
                setFromScalarAngle(scalar, angle) {
                    this.x = Math.cos(angle) * scalar;
                    this.y = Math.sin(angle) * scalar;
                }
            }

            class Particle {
                constructor(canvas, x, y, scalar, direction, radius, color) {
                    this.canvas = canvas;
                    this.position = new Vector2(x, y);
                    this.velocity = new Vector2();
                    this.velocity.setFromScalarAngle(scalar, direction);
                    this.radius = radius;
                    this.color = color;
                    this.range = 100;
                }
                update() {
                    this.position.add(this.velocity);

                    if (this.position.x - this.range > this.canvas.width) {
                        this.position.x = this.canvas.width / 2;
                        this.position.y = this.canvas.height / 2;
                    }
                    if (this.position.x + this.range < 0) {
                        this.position.x = this.canvas.width / 2;
                        this.position.y = this.canvas.height / 2;
                    }
                    if (this.position.y - this.range > this.canvas.height) {
                        this.position.x = this.canvas.width / 2;
                        this.position.y = this.canvas.height / 2;
                    }
                    if (this.position.y + this.range < 0) {
                        this.position.x = this.canvas.width / 2;
                        this.position.y = this.canvas.height / 2;
                    }
                }
            }

            window.onload = function () {
                var canvas = document.getElementById("canvas"),
                    ctx = canvas.getContext("2d"),
                    width = (canvas.width = window.innerWidth),
                    height = (canvas.height = window.innerHeight),
                    particles = [],
                    particleNum = 100,
                    colors = [
                        "#0952BD",
                        "#A5BFF0",
                        "#118CD6",
                        "#1AAEE8",
                        "#F2E8C9",
                    ];

                window.onresize = () => {
                    width = canvas.width = window.innerWidth;
                    height = canvas.height = window.innerHeight;
                };

                function randomIntFromRange(min, max) {
                    return Math.floor(Math.random() * (max - min + 1) + min);
                }
                function randomColor(colors) {
                    return colors[Math.floor(Math.random() * colors.length)];
                }

                for (let i = 0; i < particleNum; i++) {
                    particles.push(
                        new Particle(
                            canvas,
                            canvas.width / 2,
                            canvas.height / 2,
                            Math.random() * 8 + 2,
                            Math.random() * Math.PI * 2,
                            randomIntFromRange(5, 7),
                            randomColor(colors),
                        ),
                    );
                }

                function draw() {
                    for (let i = 0; i < particleNum; i++) {
                        var p = particles[i];
                        p.update();
                        ctx.save();
                        ctx.beginPath();
                        ctx.arc(
                            p.position.x,
                            p.position.y,
                            p.radius,
                            0,
                            Math.PI * 2,
                        );
                        ctx.shadowColor = p.color;
                        ctx.shadowBlur = 5;
                        ctx.shadowOffsetX = 0;
                        ctx.shadowOffsetY = 0;
                        ctx.globalAlpha = "1";
                        ctx.fillStyle = p.color;
                        ctx.fill();
                        ctx.restore();
                    }
                }

                render();

                function render() {
                    ctx.fillStyle = "hsla(260,40%,5%,.2)";
                    ctx.fillRect(0, 0, width, height);
                    draw();
                    requestAnimationFrame(render);
                }
            };
        </script>
    </body>
</html>
```