open-coroutine 0.6.4

The open-coroutine is a simple, efficient and generic stackful-coroutine library.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

use std::env::var;
use std::fs::{read_dir, rename};
use std::path::PathBuf;
use tracing::{info, Level};
use tracing_appender::rolling::{RollingFileAppender, Rotation};

fn main() {
    // init log
    let out_dir = PathBuf::from(var("OUT_DIR").expect("env not found"));
    let target_dir = out_dir
        .parent()
        .expect("can not find deps dir")
        .parent()
        .expect("can not find deps dir")
        .parent()
        .expect("can not find deps dir")
        .parent()
        .expect("can not find deps dir");
    _ = tracing_subscriber::fmt()
        .with_writer(RollingFileAppender::new(
            Rotation::NEVER,
            target_dir,
            "open-coroutine-build.log",
        ))
        .with_thread_names(true)
        .with_line_number(true)
        .with_max_level(Level::INFO)
        .with_timer(tracing_subscriber::fmt::time::OffsetTime::new(
            time::UtcOffset::from_hms(8, 0, 0).expect("create UtcOffset failed !"),
            time::format_description::well_known::Rfc2822,
        ))
        .try_init();
    // build dylib
    let target = var("TARGET").expect("env not found");
    let mut cargo = std::process::Command::new("cargo");
    let mut cmd = cargo.arg("build").arg("--target").arg(target.clone());
    if cfg!(not(debug_assertions)) {
        cmd = cmd.arg("--release");
    }
    if let Err(e) = cmd
        .arg("--manifest-path")
        .arg(
            PathBuf::from(var("CARGO_MANIFEST_DIR").expect("env not found"))
                .parent()
                .expect("parent not found")
                .join("hook")
                .join("Cargo.toml"),
        )
        .arg("--target-dir")
        .arg(out_dir.clone())
        .status()
    {
        panic!("failed to build build dylib {e}");
    }
    //fix dylib name
    let hook_deps = out_dir
        .join(target)
        .join(if cfg!(debug_assertions) {
            "debug"
        } else {
            "release"
        })
        .join("deps");
    let deps = out_dir
        .parent()
        .expect("can not find deps dir")
        .parent()
        .expect("can not find deps dir")
        .parent()
        .expect("can not find deps dir")
        .join("deps");
    let dir = read_dir(hook_deps.clone())
        .unwrap_or_else(|_| read_dir(deps.clone()).expect("can not find deps dir"));
    info!("deps: {deps:?}");
    info!("hook_deps:{hook_deps:?}");
    info!("dir:{dir:?}");
    let lib_names = [
        String::from("libopen_coroutine_hook.so"),
        String::from("libopen_coroutine_hook.dylib"),
        String::from("open_coroutine_hook.lib"),
    ];
    for entry in dir.flatten() {
        let file_name = entry.file_name().to_string_lossy().to_string();
        if !file_name.contains("open_coroutine_hook") {
            continue;
        }
        if lib_names.contains(&file_name) {
            break;
        }
        if file_name.eq("open_coroutine_hook.dll") {
            continue;
        }
        info!("{file_name:?}");
        if cfg!(target_os = "linux") && file_name.ends_with(".so") {
            rename(
                hook_deps.join(file_name.clone()),
                deps.join("libopen_coroutine_hook.so"),
            )
            .unwrap_or_else(|_| {
                rename(deps.join(file_name), deps.join("libopen_coroutine_hook.so"))
                    .expect("rename to libopen_coroutine_hook.so failed!")
            });
        } else if cfg!(target_os = "macos") && file_name.ends_with(".dylib") {
            rename(
                hook_deps.join(file_name.clone()),
                deps.join("libopen_coroutine_hook.dylib"),
            )
            .unwrap_or_else(|_| {
                rename(
                    deps.join(file_name),
                    deps.join("libopen_coroutine_hook.dylib"),
                )
                .expect("rename to libopen_coroutine_hook.dylib failed!")
            });
        } else if cfg!(windows) {
            if file_name.ends_with(".dll") {
                rename(
                    hook_deps.join(file_name.clone()),
                    deps.join("open_coroutine_hook.dll"),
                )
                .unwrap_or_else(|_| {
                    rename(deps.join(file_name), deps.join("open_coroutine_hook.dll"))
                        .expect("rename to open_coroutine_hook.dll failed!")
                });
            } else if file_name.ends_with(".lib") {
                rename(
                    hook_deps.join(file_name.clone()),
                    deps.join("open_coroutine_hook.lib"),
                )
                .unwrap_or_else(|_| {
                    rename(deps.join(file_name), deps.join("open_coroutine_hook.lib"))
                        .expect("rename to open_coroutine_hook.lib failed!")
                });
            }
        }
    }
    //link hook dylib
    println!("cargo:rustc-link-lib=dylib=open_coroutine_hook");
}