Rust文本处理快速入门

'$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';

[dependencies]
encoding_rs = "0.8.33"
regex = "1.10.2"
serde_json = "1.0.108"

// https://youerning.top/post/rust-text-processing-tutorial/
use std::collections::HashMap;
use std::io::BufRead;
use std::io::BufReader;
use std::io::Result;
use std::fs::File;
use serde_json::Value;


fn main() -> Result<()>{
    let filepath = "caddy.log";
    let file = File::open(filepath)?;
    let reader = BufReader::new(file);

    let mut url_counter = HashMap::new();
    for line in reader.lines() {
        match line  {
            Ok(line) => {
                // println!("line: {line}");
                if let Err(_) = serde_json::from_str::<Value>(&line) {
                    continue
                }
                
                let data: Value = serde_json::from_str(&line).unwrap();
                if let None = data.get("request") {
                    continue
                }
                // 这样的代码太形式化了，应该有类似于GJSON之类的库, 不够我没有用过
                // 所以这里就这样吧, 后文用展开宏节省一下代码。
                // 其实这里也可以用Options的and_then方法，但是还需要写一个匿名函数，不是很喜欢。
                if let None = data.get("request").unwrap().get("uri") {
                    continue
                }
                let uri = data.get("request").unwrap().get("uri").unwrap();
                if let None = uri.as_str() {
                    continue
                }
                let uri = uri.as_str().unwrap();
                // *url_counter.entry(uri.to_owned()).or_insert(0) += 1;
                let v = url_counter.entry(uri.to_owned()).or_insert(0);
                *v += 1;
            },
            Err(err) => {
                return Err(err)
            }
        }
    }
    println!("url_counter: {url_counter:?}");
    
    Ok(())
}

// https://youerning.top/post/rust-text-processing-tutorial/
use std::collections::HashMap;
use std::io::BufRead;
use std::io::BufReader;
use std::io::Result;
use std::fs::File;


fn main() -> Result<()>{
    let filepath = "nginx.log";
    let file = File::open(filepath)?;
    let reader = BufReader::new(file);

    let mut url_counter = HashMap::new();
    for line in reader.lines() {
        match line  {
            Ok(line) => {
                // println!("line: {line}");
                let spilts:Vec<&str> = line.split_whitespace().collect();
                if spilts.len() < 13 {
                    continue
                }
                // 注意: 这里不会考虑包含代理的日志记录
                // 如果是代理的日志记录可能是 http://xxxx:xxx/abc这种格式
                if !spilts.get(6).unwrap().starts_with("/") {
                    continue
                }

                let uri = *spilts.get(6).unwrap();
                // *url_counter.entry(uri.to_owned()).or_insert(0) += 1;
                let v = url_counter.entry(uri.to_owned()).or_insert(0);
                *v += 1;
            },
            Err(err) => {
                return Err(err)
            }
        }
    }
    println!("url_counter: {url_counter:?}");
    
    Ok(())
}

url_counter: {"/": 1, "/hello": 2}

use std::io::Result;
use std::fs::File;


fn main() -> Result<()>{
    let filepath = "caddy.log";
    let file = File::open(filepath)?;
    Ok(())
}

use std::io::{Result, ErrorKind};
use std::fs::File;


fn main() -> Result<()>{
    let filepath = "caddy.log";
    let file = match File::open(filepath) {
        Ok(file) => file,
        Err(err) => {
            if err.kind() == ErrorKind::NotFound{
                println!("文件不存在");
            }
            return Err(err)
        }
    };
    Ok(())
}

use std::path::Path;


fn main() {
    let path = Path::new("caddy.logx");
    if !path.exists() {
        println!("文件不存在");
    }
}

use std::io::{Result, Read};
use std::fs::File;


fn main() -> Result<()>{
    let filepath = "caddy.log";
    let mut file = File::open(filepath)?;
    let mut content = String::new();
    file.read_to_string(&mut content)?;
    println!("content: {content}");
    Ok(())
}

use std::io::{Result, Error, ErrorKind};
use std::fs;
use encoding_rs::GBK;


fn main() -> Result<()>{
    let filepath = "gbk.log";
    let content = fs::read(&filepath)?;
    println!("{}", content.len());
    let (content, _, had_err) = GBK.decode(&content);
    if had_err {
        return Err(Error::new(ErrorKind::Other, "使用GBK解码失败"))
    }
    println!("{}", content.len());
    println!("content: {content:?}");
    Ok(())
}

use regex::Regex;

fn main() {
    let log = r#"172.17.0.1 - - [20/Dec/2023:01:37:27 +0000] "GET /hello HTTP/1.1" 200 612 "-" "curl/7.29.0" "-""#;
    let pattern = Regex::new(r#".+?"GET\s+(.+)\s+HTTP.+?"#).unwrap();
    // 判断是否匹配
    if pattern.is_match(log) {
        println!("该日志匹配正则表达式")
    } else {
        panic!("无法匹配正则表达式")
    }

    // 获取匹配的部分
    if let Some(caps) = pattern.captures(log) {
        println!("{caps:?}");
        let uri = caps.get(1).unwrap().as_str();
        println!("uri: {uri}");
    } else {
        panic!("无法捕获表达式里的内容")
    }
}

use serde_json::json;

macro_rules! serde_get {
    ($value: ident, $first: expr) => {
        {
            match ($value).get($first) {
                Some(val) => Some(val),
                None => {
                    None
                }
            }
        }
    };

    ($value: ident, $first: expr, $($others:expr)+) => {
        {
            match ($value).get($first) {
                Some(val) => {
                    serde_get!(val, $($others)+)
                },
                None => {
                    None
                }
            }
        }
    };
    // 使用声明宏处理递归调用的关键在于$($others:tt)*
    ($value: ident, $first: expr, $($others:tt)* ) => { 
        {
            match ($value).get($first) {
                Some(val) => {
                    serde_get!(val, $($others)+)
                }
                None => None
            }
        }
    };
    
}


fn main() {
    let object = json!({
        "key11": {"key12": "key13"},
        "key21": {"key22": {"key23": "key24"}}
    });
    
    if let None = serde_get!(object, "xx") {
        println!("不存在键xx");
    }

    if let Some(val) = serde_get!(object, "key11", "key12") {
        println!(r#"object["key11"]["key12"] = {val:}"#);
    }

    if let Some(val) = serde_get!(object, "key21", "key22", "key23") {
        println!(r#"object["key21"]["key21"]["key23"] = {val:}"#);
    }

    if let Some(val) = serde_get!(object, "key21", "key22", "key23", "key24") {
        println!(r#"object["key21"]["key21"]["key23"]["key33"] = {val:}"#);
    } else {
        println!(r#"object["key21"]["key21"]["key23"]["key33"]不存在"#);
    }
}