(Jin Qing's Column, Nov., 2022)

dtLink

dtLink defines a link between 2 polygons. It is an internal data structure.

A dtLink is owned by its source polygon.

How link is used

The links are used in findPath(), to search all the neighbor polygons, from the current best polygon.

fields of dtLink

dtLink has 2 required fields:

• neighbor: the neighbor polygon reference that is linked to.
• edge: index of the polygon edge that owns this link. It is used in getPortalPoints() and raycast().

If the link is a boundary link, which links to other tile, then it has more fields:

• side: defines on which side the link is. 8 sides. It is used in findPath() and raycast().
• bmin: defines the minimum sub-edge area.
• bmax: defines the maximum sub-edge area. bmin and bmax are used in portal finding.

How are links created

Links are not saved to navmesh file. They are created on navmesh loading in addTile().

dtNavMesh::addTile() add a tile to the navmesh. A tile is a square block of the map.

The main job of dtNavMesh::addTile() is to create links inside this tile and between this tile and other tiles. Actually a block indexed by (x, y) of constant size has many layers for multi-floor map. A dtMeshTile is actually a layer with an index of (x, y, layer).

5 steps to create all links:

1. Connect internal links

connectIntLinks() iterates all the polygons in the tile and create links for them by the help of neighbors information of the polygons.

2. Base off-mesh connections

baseOffMeshLinks() bases off-mesh connections to their starting polygons and connect connections inside the tile.

Off-mesh connection is between 2 points which are inside a tile or between 2 adjacent tiles.

For each off-mesh connection, there creates a specific polygon consisting of 2 vertices. See DT_POLYTYPE_OFFMESH_CONNECTION.

baseOffMeshLinks() creates 2 links for each off-mesh connection:

• From the off-mesh connection polygon to the source polygon
• From the source polygon to the off-mesh connection polygon

The destinaton polygon of the off-mesh connection is skipped here.

3. Connect external off-mesn links within this tile

connectExtOffMeshLinks() with the source and target tile be this tile.

connectExtOffMeshLinks() searches off-mesh connections that are from this tile to the target tile by checking the side direction of the connection.

It creates a link from off-mesh connection polygon to the target tile. For bidirectional connection, it also creates a link from the target polygon to the off-mesh connection polygon.

So for each off-mesh connection of this tile, 3 or 4 links are created by baseOffMeshLinks() and connectExtOffMeshLinks(), one on the source polygon, one on the destination polygon and 1/2 on the off-mesh connection polygon.

4. Connect with layers in current tile

For each layer other than this layer in this tile:

• Create links from this layer to other layer
• Create links from other layer to this layer
• Create links of the off-mesh connection from this layer to other layer
• Create links of the off-mesh connection from other layer to this layer

5. Connect with neighbour tiles

Check 9 neighbor tiles' layers, and create links just like previous step:

• Create links from this layer to neighnor layer
• Create links from neighnor layer to this layer
• Create links of the off-mesh connection from this layer to neighnor layer
• Create links of the off-mesh connection from neighnor layer to this layer

By now, for every off-mesh connection of all the loaded tiles, 3/4 links are created.

Reference

• https://blog.csdn.net/icebergliu1234/article/details/80322392

From: https://www.modernescpp.com/index.php/c-core-guidelines-how-to-pass-function-parameters

Parameter passing expression rules:

• F.15: Prefer simple and conventional ways of passing information
• F.16: For “in” parameters, pass cheaply-copied types by value and others by reference to const
• F.17: For “in-out” parameters, pass by reference to non-const
• F.18: For “consume” parameters, pass by X&& and std::move the parameter
• F.19: For “forward” parameters, pass by TP&& and only std::forward the parameter
• F.20: For “out” output values, prefer return values to output parameters
• F.21: To return multiple “out” values, prefer returning a tuple or struct
• F.60: Prefer T* over T& when “no argument” is a valid option

(Jin Qing's Column, Oct., 2022)

cursive::Cursive can store any user data:

pub struct Cursive {
    ...
    // User-provided data.
    user_data: Box<dyn Any>,
}
impl Cursive {
    ...
    pub fn set_user_data<T: Any>(&mut self, user_data: T) {
        self.user_data = Box::new(user_data);
    }
    pub fn user_data<T: Any>(&mut self) -> Option<&mut T> {
        self.user_data.downcast_mut()
    }
    pub fn take_user_data<T: Any>(&mut self) -> Option<T> {
        ...
    }
    pub fn with_user_data<F, T, R>(&mut self, f: F) -> Option<R>
    where
        F: FnOnce(&mut T) -> R,
        T: Any,
    {
        self.user_data().map(f)
    }

Example:

let mut siv = cursive_core::Cursive::new();
// Start with a simple `Vec<i32>` as user data.
siv.set_user_data(vec![1i32, 2, 3]);
assert_eq!(siv.user_data::<Vec<i32>>(), Some(&mut vec![1i32, 2, 3]));
// Let's mutate the data a bit.
siv.with_user_data(|numbers: &mut Vec<i32>| numbers.push(4));
// If mutable reference is not enough, we can take the data by value.
let data: Vec<i32> = siv.take_user_data().unwrap();
assert_eq!(data, vec![1i32, 2, 3, 4]);
// At this point the user data was removed and is no longer available.
assert_eq!(siv.user_data::<Vec<i32>>(), None);

from: C++ Programming Guidelines (cginternals.github.io)

When naming accessors within classes, non-trivial getters and queries, i.e., those that perform calculations, you should prepended get. All other getters have no prefix and setters have the set prefix.

(Jin Qing's Column, Apr., 2022)

This code compiles error:

      trait MyCallback: FnMut(&u32) -> () { }
impl<F: FnMut(&u32) -> ()> MyCallback for F { }
fn process_data(mut f: impl MyCallback) -> () {
    f(&0)
}
fn process_data_2(mut f: impl FnMut(&u32) -> ()) -> () {
    f(&0)
}
fn main() {
    // Doesn't compile
    process_data(|_| ());
    // Compiles
    process_data_2(|_| ());
}

    

      expected type `for<'r> FnMut<(&'r u32,)>`
              found type `FnMut<(&u32,)>`

    

Fix:

          process_data(|_: &_| ());

    

See: https://stackoverflow.com/questions/61671460/rust-type-mismatch-resolving-forr-with-closure-trait-alias-argument

Also see: https://github.com/rust-lang/rust/issues/58639

Sometimes, Rust needs a type annotation in closure.

(Jin Qing's Column, Apr., 2022)

Using navmesh generated by recastnavigation, we found the agent will collide into the wall when it is walking along the navmesh path.

After some inspection, we found the reason is that at the collision position, the position on the path is simply too close to the wall, which is less than the agent radius.

If the agent radius is zero, the navmesh contour may inside the wall.

Displaying the raw contour and contour, we can see the raw contour which is jigsaw shaped is right, but the simplied contour uses a straight line to replace the jigsaw edge, and causes the error.

The parameter "Max Edge Error" controls how the contour is simplified, which default is 1.3, which means a vertex can deviate from the final contour in the range of 1.3 times of cell size.

We hope the error is on only one side of the contour instead of on both sides. In other words, the contour should within the raw contour.

walkContour() finds a raw contour which is a polygon. simplifyContour() simplifies the raw contour resulting a simpler polygon.

The steps of simplifyContour():

1. Find lower-left and upper-right vertices of the contour to form the initial simplified polygon.
2. For each edge of the simplified polygon
   1. For each point between 2 points of the edge
      1. Find the point that is the most distant from the edge
   2. If the distance is larger than the max error, add the point to the simplified polygon
3. Split too long edges.

We make these modifications:

• The distance is signed
  • If the point is outside the walkable area, just make sure it is less than the max error
  • If the point is inside the walkable area
    • Add it to the simplified polygon to make sure the final contour is within the raw area

There are 2 kinds of contour:

• Outline of a walkable area
• Hole of a walkable area

We should decide the kind of the contour before simplifyContour(). If the start cell (x, y) is in the raw contour polygon, then it is an outline not a hole contour. Because (x, y) may be one of the vetex of the polygon, we use (x + 0.5, y + 0.5) instead, which is the center of the cell.

The result will be like this:

Compare with the orignal contour:

(Jin Qing's Column, Mar., 2022)

rustup-init.exe may fail if some anti-virus software is running with realtime protection.

The error message is like this after many retries:

error: could not rename component file from 'C:\.../rust/html' to 'C:\.../rust/html'

See: https://github.com/rust-lang/rustup/issues/1912

And it is not possible to stop the anti-virus for a corporate laptop.

There is a way to workaround this. Here are the steps:

1. Run rustup-init until it begins to retry renaming
2. Kill rustup-init when it is retrying
   • rustup will be installed before the failure
   • do not let rustup-init do the cleanup after the final failure
3. Run rustup update to install all.
4. Run rustup-init again to setup others.

rustup update will report that rustc was not found:

C:\Users\jinqing01>rustup update
info: syncing channel updates for 'stable-x86_64-pc-windows-msvc'
...
info: removing previous version of component 'rustc'
warning: during uninstall component rustc was not found
...
info: installing component 'rustc'
...  
info: checking for self-updates
  stable-x86_64-pc-windows-msvc updated - rustc 1.59.0 (9d1b2106e 2022-02-23) (from (rustc does not exist))
info: cleaning up downloads & tmp directories

Rerun rustup-init to setup the toolchain:

C:\Users\jinqing01>cargo --version
error: no override and no default toolchain set
C:\Users\jinqing01>d:
D:\>cd tool
D:\Tool>rustup-init.exe
Welcome to Rust!
This will download and install the official compiler for the Rust
programming language, and its package manager, Cargo.
...
Rust is installed now. Great!
Press the Enter key to continue.
D:\Tool>cargo --version
cargo 1.59.0 (49d8809dc 2022-02-10)

(Jin Qing's Column, Mar., 2022)

It is best to let the function take a closure trait as the parameter instead of a function pointer.

      fn foo(f: fn()) {
    f()
}
fn main() {
    foo(|| println!("hello"));
    let a = 123;
    foo(move || println!("{}", a))
}

    

compiles error:

      error[E0308]: mismatched types
 --> src/main.rs:9:9
  |
9 |     foo(move || println!("{}", a))
  |         ^^^^^^^^^^^^^^^^^^^^^^^^^ expected fn pointer, found closure
  |
  = note: expected fn pointer `fn()`
                found closure `[closure@src/main.rs:9:9: 9:34]`
note: closures can only be coerced to `fn` types if they do not capture any variables
 --> src/main.rs:9:32
  |
9 |     foo(move || println!("{}", a))
  |                                ^ `a` captured here
For more information about this error, try `rustc --explain E0308`.

    

https://doc.rust-lang.org/book/ch19-05-advanced-functions-and-closures.html

Function pointers implement all three of the closure traits (Fn, FnMut, and FnOnce), so you can always pass a function pointer as an argument for a function that expects a closure. It’s best to write functions using a generic type and one of the closure traits so your functions can accept either functions or closures.

(Jin Qing's Column, Feb., 2022)

parking_lot has an experimental feature: deadlock_detection.

See: https://amanieu.github.io/parking_lot/parking_lot/deadlock/index.html

use std::thread;
use std::time::Duration;
use parking_lot::deadlock;
// Create a background thread which checks for deadlocks every 10s
thread::spawn(move || {
loop {
thread::sleep(Duration::from_secs(10));
let deadlocks = deadlock::check_deadlock();
if deadlocks.is_empty() {
continue;
}
println!("{} deadlocks detected", deadlocks.len());
for (i, threads) in deadlocks.iter().enumerate() {
println!("Deadlock #{}", i);
for t in threads {
println!("Thread Id {:#?}", t.thread_id());
println!("{:#?}", t.backtrace());
}
}
}
});

The output is like this:

1 deadlocks detected
Deadlock #0
Thread Id 16072
0: 0x7ff985cb659d - backtrace::backtrace::dbghelp::trace
at d:\Users\jinqing\.cargo\registry\src\github.com-1ecc6299db9ec823\backtrace-0.3.63\src\backtrace\dbghelp.rs:98
...
13: 0x7ff985ae92f3 - lock_api::rwlock::RwLock<parking_lot::raw_rwlock::RawRwLock,cgc::scene_template::SceneTemplate>::read<parking_lot::raw_rwlock::RawRwLock,cgc::scene_template::SceneTemplate>
at d:\Users\jinqing\.cargo\registry\src\github.com-1ecc6299db9ec823\lock_api-0.4.6\src\rwlock.rs:448
14: 0x7ff985aeadf3 - cgc::scene::SceneData::check_body_collide
at E:\gitlab\yserver\gc\src\scene.rs:99
...
81: 0x7ff9f29b7034 - BaseThreadInitThunk
82: 0x7ff9f2b02651 - RtlUserThreadStart

But the deadlock detection thread can not be changed to a tokio task, because if deadlock happens, all tasks may be blocked, including the deadlock detection, causing no deadlock error output.

In the following example, if the number of the deadlock tasks is larger than the thread number of tokio runtime, all tasks will be blocked.

use std::{thread, time::Duration};
use parking_lot::RwLock;
use tokio::time;
#[tokio::main]
async fn main() {
tokio::spawn(async move {
for i in 0..999999 {
println!("{}", i);
time::sleep(Duration::from_secs(1)).await;
}
});
const MAX: i32 = 100;
for _ in 0..MAX {
tokio::spawn(async move {
{
// DEADLOCK!
let a = RwLock::new(());
let _g1 = a.write();
let _g2 = a.write();
}
time::sleep(Duration::from_secs(9999)).await;
});
}
println!("Hello, world!");
thread::sleep(Duration::from_secs(10));
}

The output is:

0
Hello, world!
_

If no deadlock, or the number of deadlock tasks is small, the output should be:

0
Hello, world!
1
2
3
...

GitExtensions and Git fail:

      "git" pull --progress "origin"
git@github.com: Permission denied (publickey).
fatal: Could not read from remote repository.
Please make sure you have the correct access rights
and the repository exists.
Done
Press Enter or Esc to exit...

    

But TortoiseGit is OK.

      git.exe pull --progress -v --no-rebase "origin"
From github.com:jinq0123/recastnavigation
= [up to date]      master      -> origin/master
= [up to date]      release-2.0 -> origin/release-2.0
Already up to date.

    

ssh -T shows that the reason is there is no id files:

      PS d:\github> ssh -vT git@github.com
OpenSSH_for_Windows
debug1: Connecting to github.com [20.205.243.166] port 22.
debug1: Connection established.
debug1: identity file C:\\Users\\jinqing/.ssh/id_rsa type -1
debug1: identity file C:\\Users\\jinqing/.ssh/id_xmss-cert type -1
debug1: Authenticating to github.com:22 as 'git'
debug1: Host 'github.com' is known and matches the ED25519 host key.
debug1: Found key in C:\\Users\\jinqing/.ssh/known_hosts:2
debug1: Will attempt key: C:\\Users\\jinqing/.ssh/id_rsa
debug1: Will attempt key: C:\\Users\\jinqing/.ssh/id_xmss
debug1: SSH2_MSG_SERVICE_ACCEPT received
debug1: Authentications that can continue: publickey
debug1: Next authentication method: publickey
debug1: Trying private key: C:\\Users\\jinqing/.ssh/id_rsa
debug1: Trying private key: C:\\Users\\jinqing/.ssh/id_xmss
debug1: No more authentication methods to try.
git@github.com: Permission denied (publickey).
PS d:\github>

    

Copy my RSA key file rsa.ppk that TortoiseGit uses as ~/.ssh/id_rsa:

      PS D:\jinqing\github_jinq\recastnavigation> ssh -T git@github.com
Load key "C:\\Users\\jinqing/.ssh/id_rsa": invalid format
git@github.com: Permission denied (publickey).
PS D:\jinqing\github_jinq\recastnavigation>

    

Open TortoiseGit/bin/puttygen.exe, load rsa.ppk, then Convensionis->Export OpenSSH key as ~/.ssh/id_rsa:

      PS D:\jinqing\github_jinq\recastnavigation> ssh -T git@github.com
Hi jinq0123! You've successfully authenticated, ...

    

id_rsa begins with:

      -----BEGIN RSA PRIVATE KEY-----

    

(Jin Qing's Column, Jan., 2022)

Tracing is Rust log crate: https://github.com/tokio-rs/tracing

This example code outputs log to stdout and a log file, using a log filter config file, which can be automatically reloaded on change.

https://gitee.com/jinq0123/tracing-example

Dependencies

Add these dependencies to Cargo.toml:

      [dependencies]
anyhow = "1.0.52"
hotwatch = "0.4.6"
tracing = "0.1.29"
tracing-appender = "0.2.0"
tracing-subscriber = { version = "0.3.5", features = [ "env-filter", "json" ] }

    

main.rs

      mod log;
use anyhow::Result;
use std::{thread, time::Duration};
use tracing::info;
fn main() -> Result<()> {
    let _guard = log::init("./log", "example.log", "config/log_filter.txt")?;
    for i in 0..999 {
        info!(i, "Hello, world!");
        thread::sleep(Duration::from_secs(1));
    }
    Ok(())
}

    

log.rs

      //! Init log.
//!
use anyhow::{anyhow, Context as _, Result};
use hotwatch::{Event, Hotwatch};
use std::fs;
use std::path::Path;
use tracing::{debug, warn, Subscriber};
use tracing_appender::{non_blocking::WorkerGuard, rolling};
use tracing_subscriber::{fmt, layer::SubscriberExt, reload::Handle, EnvFilter};
/// Inits log.
/// Returns a WorkerGuard to ensure buffered logs are flushed,
///  and a Hotwatch to watch the log filter file.
pub fn init(
    directory: impl AsRef<Path>,
    file_name_prefix: impl AsRef<Path>,
    log_filter_file: impl AsRef<Path>,
) -> Result<(WorkerGuard, Hotwatch)> {
    let file_appender = rolling::daily(directory, file_name_prefix);
    let (non_blocking, worker_guard) = tracing_appender::non_blocking(file_appender);
    let file_layer = fmt::Layer::default()
        .with_writer(non_blocking)
        .json()
        .flatten_event(true)
        .with_ansi(false);
    let builder = tracing_subscriber::fmt()
        .pretty()
        .with_env_filter(EnvFilter::from_default_env())
        .with_filter_reloading();
    let handle = builder.reload_handle();
    let subscriber = builder.finish();
    let subscriber = subscriber.with(file_layer);
    tracing::subscriber::set_global_default(subscriber).context("set global default subscriber")?;
    reload_filter(handle.clone(), log_filter_file.as_ref());
    let log_filter_path_buf = log_filter_file.as_ref().to_path_buf();
    let mut hotwatch = Hotwatch::new().context("hotwatch failed to initialize!")?;
    hotwatch
        .watch(log_filter_file.as_ref(), move |event: Event| {
            debug!("log filter file event: {:?}", event);
            if let Event::Write(_) = event {
                reload_filter(handle.clone(), log_filter_path_buf.clone());
            }
        })
        .with_context(|| format!("failed to watch file: {:?}", log_filter_file.as_ref()))?;
    Ok((worker_guard, hotwatch))
}
fn reload_filter<S: Subscriber + 'static>(
    handle: Handle<EnvFilter, S>,
    log_filter_file: impl AsRef<Path>,
) {
    let res = try_reload_filter(handle, log_filter_file);
    match res {
        Ok(_) => debug!("reload log filter OK"),
        Err(e) => warn!("reload log filter error: {:?}", e),
    }
}
fn try_reload_filter<S: Subscriber + 'static>(
    handle: Handle<EnvFilter, S>,
    log_filter_file: impl AsRef<Path>,
) -> Result<()> {
    let contents = fs::read_to_string(log_filter_file.as_ref()).with_context(|| {
        format!(
            "something went wrong reading the file: {:?}",
            log_filter_file.as_ref()
        )
    })?;
    let contents = contents.trim();
    debug!("reload log filter: {:?}", contents);
    let new_filter = contents
        .parse::<EnvFilter>()
        .map_err(|e| anyhow!(e))
        .context("failed to parse env filter")?;
    handle.reload(new_filter).context("handle reload error")
}

    

log_filter.txt

log_filter.txt is the configure file for log. The change of this file will trigger the reload.

The log filter file must exist, otherwise it will be error:

      Error: failed to watch file: "config/log_filter.txt"
Caused by:
    系统找不到指定的路径。 (os error 3)

    

The content of log_filter.txt is a single line of filter string. A filter string consists of one or more comma-separated directives. The directive syntax is similar to RUST_LOG env val of env_logger’s.

      target[span{field=value}]=level

    

See: https://docs.rs/tracing-subscriber/latest/tracing_subscriber/struct.EnvFilter.html

Example

• tracing_example enables logs that:
  • target is modules of tracing_example*
• info will enable logs that:
  • level is info
• tracing_ex=info enables logs that:
  • target is modules of tracing_ex*
  • level is info or above
• info,tracing_ex=debug enables logs that:
  • level is info or above
  • or target is tracing_ex* and level is debug
• [foo]=trace enables logs that:
  • within the span foo
  • level is trace or above
• [span_b{name=\"bob\"}] enables logs that:
  • have any target,
  • are inside a span named span_b,
  • which has a field named name with value bob,
  • at any level.

Note: span filter directive will keep effective until it exits the span.

(Jin Qing's Column, Dec., 2021)

https://github.com/tokio-rs/tracing

Usage on github

Switch to tag tracing-0.1.29 first. The master's examples can not build. Subscriber is renaming to collector on master.

tracingsubscriber in 0.1.29 has been renamed to tracingcollect on master.

• In Applications
• In Libraries
• In async

The example is using tracing_subscriber::fmt, which can be configured by RUST_LOG env val.

By default, no log is output. Set RUST_LOG=info before running, and the log is:

      Dec 25 10:23:11.200  INFO tracing_test: preparing to shave yaks number_of_yaks=3
Dec 25 10:23:11.203  INFO tracing_test: yak shaving completed. all_yaks_shaved=true

    

• span
• set_global_default()
• tracingcollectwith_default()

Usage of RUST_LOG.

RUST_LOG is defined in env_logger

• Default disabled except error
• RUST_LOG is comma-separated directives
  • Directive form: examplelogtarget=level
    • The log target is a prefix
      • If target is ommitted, then all modules are set
    • The level is "all" if ommitted
      • off, error, warn, info, debug, trace
  • Regex filter: error,hello=warn/[0-9]scopes
    • For all directives

Usage on crates.io

It is slightly different from the github.

• Uses set_global_default()
• Explains some concepts
  • span
  • event

Span filter? [my_span]=info

Document

https://docs.rs/tracing/0.1.29/tracing/

The document is much more detailed than github and crates.io.

Code examples

Run example:

      cargo run --example counters

    

Write to file

fmt-multiple-writers:

• Change to write to current dir
  • tracing_appender::rolling::hourly(".", ...
• Do not write ANSI color to file
  • .with(fmt::Layer::new().with_writer(non_blocking).with_ansi(false));

Dynamic level

tower-load

• with_filter_reloading() -> reload handl -> handle.reload(new_filter)
• new filter is send through http

https://github.com/tokio-rs/tracing/issues/1629 tracing_subscriber::reload

They use the same tracing_subscriber::reload::Handle::reload()

Filters and Layers

https://docs.rs/tracing-subscriber/0.3.4/tracing_subscriber/layer/index.html#filtering-with-layers

Reload from config file

It is desired to reconfigure the log filter in the runtime by SIGHUP, or watch configure file change. It can use notify crate to watch file.

      use anyhow::{anyhow, Context as _, Result};
use hotwatch::{Event, Hotwatch};
use std::{fs, thread, time::Duration};
use tracing::{debug, info, warn, Subscriber};
use tracing_subscriber::{reload::Handle, EnvFilter};
const CFG: &str = "cfg.txt";
fn main() -> Result<()> {
    let builder = tracing_subscriber::fmt()
        .with_env_filter(EnvFilter::from_default_env())
        .with_filter_reloading();
    let handle = builder.reload_handle();
    builder
        .try_init()
        .map_err(|e| anyhow!(e))
        .context("failed to init subscriber builder")?;
    tracing::info!("Before reload");
    reload_cfg(handle.clone());
    let mut hotwatch = Hotwatch::new().context("hotwatch failed to initialize!")?;
    hotwatch
        .watch(CFG, move |event: Event| {
            if let Event::Write(_) = event {
                reload_cfg(handle.clone());
            }
        })
        .context("failed to watch file")?;
    for i in 0..999 {
        info!(i);
        thread::sleep(Duration::from_secs(1));
    }
    Ok(())
}
fn reload_cfg<S: Subscriber + 'static>(handle: Handle<EnvFilter, S>) {
    let res = try_reload_cfg(handle);
    match res {
        Ok(_) => debug!("reload cfg OK"),
        Err(e) => warn!("reload cfg error: {:?}", e),
    }
}
fn try_reload_cfg<S: Subscriber + 'static>(handle: Handle<EnvFilter, S>) -> Result<()> {
    let contents = fs::read_to_string(CFG).context("something went wrong reading the file")?;
    let contents = contents.trim();
    debug!("reload cfg: {:?}", contents);
    let new_filter = contents
        .parse::<EnvFilter>()
        .map_err(|e| anyhow!(e))
        .context("failed to parse env filter")?;
    handle.reload(new_filter).context("handle reload error")
}

    

How to new a Subscriber with tracing-subscriber

• SubscriberBuilder:
  • fmt().init()
  • with_env_filter()
  • with_filter_reloading()
  • reload_handle()
  • finish() to get a Subscriber and then add a file Layer?
    • https://github.com/tokio-rs/tracing/issues/971
• Registry:
  • registry().with...()
  • Currently, the [Registry] type provided by this crate is the only [Subscriber] implementation capable of participating in per-layer filtering.
• FmtSubscriber
  • new it manually
  • need SubscriberBuilder to configure

By default a Box<dyn Trait> doesn't implement the trait of the object it contains. This means that trying to construct PeopleZoo<Box<dyn Person>> won't work out of the box and will give a type error.

Because of this, it's good practice to give a default implementation of your trait for it's boxed counterpart. This can be done by calling as_ref or as_mut on the Box and calling the references relevant method.

For just a small bit of effort you can help a bunch of people that may consume your struct.

struct PeopleZoo<P: Person> {
    people: Vec<P>,
}

(Jin Qing's Column, Dec., 2021)

My program is using K8s DNS SRV query to discovery service, and when it's deployed on minikube, I find DNS failure.

I can use nslookup to reproduce the failure.

Querying a FQDN is OK. But after querying a non-existing SRV short name, the ping fails.

root@web-0:/# ping google.com
PING google.com (142.250.66.110) 56(84) bytes of data.
64 bytes from hkg12s28-in-f14.1e100.net (142.250.66.110): icmp_seq=1 ttl=108 time=33.7 ms
64 bytes from hkg12s28-in-f14.1e100.net (142.250.66.110): icmp_seq=2 ttl=108 time=33.8 ms
^C
--- google.com ping statistics ---
2 packets transmitted, 2 received, 0% packet loss, time 1000ms
rtt min/avg/max/mdev = 33.779/33.834/33.889/0.055 ms
root@web-0:/# nslookup
> set type=srv
> nosuch-nosuch-nosuch-1234567890abcdefg.cn
Server:         10.96.0.10
Address:        10.96.0.10#53
** server can't find nosuch-nosuch-nosuch-1234567890abcdefg.cn: NXDOMAIN
> exit
root@web-0:/# ping google.com
PING google.com (142.250.66.110) 56(84) bytes of data.
64 bytes from hkg12s28-in-f14.1e100.net (142.250.66.110): icmp_seq=1 ttl=108 time=33.7 ms
64 bytes from hkg12s28-in-f14.1e100.net (142.250.66.110): icmp_seq=2 ttl=108 time=33.7 ms
^C
--- google.com ping statistics ---
2 packets transmitted, 2 received, 0% packet loss, time 1001ms
rtt min/avg/max/mdev = 33.730/33.735/33.741/0.183 ms
root@web-0:/# nslookup
> set type=srv
> nginx-wrong
Server:         10.96.0.10
Address:        10.96.0.10#53
** server can't find nginx-wrong: SERVFAIL
> exit
root@web-0:/# ping google.com
ping: unknown host google.com
root@web-0:/# 

The ping will recover to normal after about 1 minute.

If I query a existing internal service name, and nslookup returns correctly, then DNS is OK after I quit nslookup.

root@web-0:/# ping google.com
PING google.com (142.250.66.110) 56(84) bytes of data.
64 bytes from hkg12s28-in-f14.1e100.net (142.250.66.110): icmp_seq=1 ttl=108 time=33.6 ms
64 bytes from hkg12s28-in-f14.1e100.net (142.250.66.110): icmp_seq=2 ttl=108 time=34.8 ms
^C
--- google.com ping statistics ---
2 packets transmitted, 2 received, 0% packet loss, time 1001ms
rtt min/avg/max/mdev = 33.648/34.260/34.872/0.612 ms
root@web-0:/# nslookup
> set type=srv
> nginx
Server:         10.96.0.10
Address:        10.96.0.10#53
nginx.default.svc.cluster.local service = 0 25 80 web-1.nginx.default.svc.cluster.local.
nginx.default.svc.cluster.local service = 0 25 80 web-2.nginx.default.svc.cluster.local.
nginx.default.svc.cluster.local service = 0 25 80 web-0.nginx.default.svc.cluster.local.
nginx.default.svc.cluster.local service = 0 25 80 web-3.nginx.default.svc.cluster.local.
> exit
root@web-0:/# ping google.com
PING google.com (142.250.66.110) 56(84) bytes of data.
64 bytes from hkg12s28-in-f14.1e100.net (142.250.66.110): icmp_seq=1 ttl=108 time=33.5 ms
^C
--- google.com ping statistics ---
1 packets transmitted, 1 received, 0% packet loss, time 0ms
rtt min/avg/max/mdev = 33.529/33.529/33.529/0.000 ms
root@web-0:/# 

When DNS fails, the whole cluster can not query any domain name outside, but internal name is OK.

https://github.com/kubernetes/minikube/issues/13137

(Jin Qing's Column, Dec., 2021)

Try to find out why Orleans need a DeathVoteExpirationTimeout config.

https://dotnet.github.io/orleans/docs/implementation/cluster_management.html#extension-to-totally-order-membership-views

DeathVoteExpirationTimeout - Expiration time in seconds for death vote in the membership table. Default is 120 seconds

GetFreshVotes

DeathVoteExpirationTimeout is only used by GetFreshVotes(), which has 3 occurence:

    class ClusterHealthMonitor
    {
        ...
        private UpdateMonitoredSilos(...)
        {
            ...
            bool isSuspected = candidateEntry.GetFreshVotes(now, DeathVoteExpirationTimeout).Count > 0;
            ...
        }
    }

    class LocalSiloHealthMonitor
    {
        ...
        private int CheckSuspectingNodes(DateTime now, List<string> complaints)
        {
            ...
            var freshVotes = membershipEntry.GetFreshVotes(now, DeathVoteExpirationTimeout);
            ...
        }
        ...
    }

    class MembershipTableManager
    {
        ...
        public TryToSuspectOrKill(SiloAddress silo)
        {
            ...
            // get all valid (non-expired) votes
            var freshVotes = entry.GetFreshVotes(DateTime.UtcNow, DeathVoteExpirationTimeout);
            ...
        }
        ...
    }

GetFreshVotes() uses this expiration time to ignore old voter:

        internal GetFreshVotes(DateTime now, TimeSpan expiration)
        {
            ...
            foreach (var voter in this.SuspectTimes)
            {
                var otherVoterTime = voter.Item2;
                if (now.Subtract(otherVoterTime) < expiration)
                {
                    result.Add(voter);
                }
            }
            return result.ToImmutable();
        }

金庆 2021-12-08 09:43 发表评论

]]>

(Jin Qing's Column, Dec., 2021)

GitExtension is a good tool. After a long time of usage, my branch list finally reaches over a full screen, and it is hard to select the branch I want.

GitExtension always remembers all the branches of remote and local, even they have been deleted.

I tried to find a way to delete these branches which are already merged, but resulted in futile.

It has a plugin names "Delete obsolete branches", but I don't know how to use it.

Finally I renamed the work directory, and cloned a new one, which clears all the branches. It seems that these branches are stored in local .git directory. If let GitExt open the renamed directory, these branches reappears.

Reference:

• https://talk.plesk.com/threads/git-extension-doesnt-remove-deleted-branches.351838/
• https://plesk.uservoice.com/forums/184549-feature-suggestions/suggestions/39296707-git-extension-option-to-delete-branches

(金庆的专栏 2021.11)

• slog 不是立即写盘，最后的几行日志会丢失

  • tracing 不会丢日志

• slog 不支持运行中动态更改日志等级

  • tracing with_filter_reloading()

    • examples/tower-load

• slog 不支持不同包设置不同日志等级

  • tracing 可单独打开某个模块的日志

• 发现一次 slog panic: panicked at 'slog::Fuse Drain: Fatal(Custom { kind: BrokenPipe, error: "The logger thread terminated" })'

  • 搜到相同错误：https://github.com/mimblewimble/grin/issues/946

    • 别人的解决方法是: 不用slog了

• slog 主页10月添加推荐使用 tracing

• slog 按线程保存上下文，tracing 按协程保存上下文

• tracing github star 1.9K > slog 1.2K

• tracing crates 下载 21M > sloggers 0.4M, slog-scope 2.6M, slog-stdlog 1.9M

• tracing vs slog: https://www.reddit.com/r/rust/comments/kdo29n/slog_vs_tracing_which_one_do_you_prefer/

• Rust compiler 2020年已改用 tracing：https://github.com/rust-lang/rust/pull/74726

• tracing 更好用

  • 文档及示例更全
  • 支持库更多

(Jin Qing's Column, Nov. 18, 2021)

There is no "named function parameters" in Rust, but there is an idiom for this case. If a function needs many parameters, we can define a type with all these parameters as fields, and implement Default trait for this type. Then we can input this type as the function parameter, with some of the fields specified and others using default.

foo(Config {
    a: 123,
    b: bool,
    ...Default::default(),
});

(Jin Qing's Column, Nov. 18, 2021)

Rust traits are different from interfaces of C++/Java/Go.

See: https://stevedonovan.github.io/rustifications/2018/09/08/common-rust-traits.html

Rust traits are mechanism for adding behavior to types.

Traits have 2 modes. One is interface as Java.

Another is generic constraint. Generic functions are defined over types that implemented specific traits.

The "complie-time duck typing" in C++ templates is avoided in Rust. Rust will reject a type with quack() method as a Duck type. We must pass a type which implements Duck trait. But in Go, a type with quack() method is sufficient to be used as a Duck interface.

(Jin Qing's Column, Nov. 4, 2021)

My Rust program failed when running in docker:

root@a26b49c91efb:/myapp# ldd libmyapp_py.so
./libmyapp_py.so: /lib/x86_64-linux-gnu/libm.so.6: version `GLIBC_2.29' not found (required by ./libmyapp_py.so)

The problem is because I build in "rust:1.56", and run in "debian:buster-slim" which is quite old. Run dpkg -l libc-bin shows the libc version is 2.28:

C:\Users\jinqing01>docker run debian:buster-slim dpkg -l libc-bin
Unable to find image 'debian:buster-slim' locally
buster-slim: Pulling from library/debian
b380bbd43752: Already exists
Digest: sha256:544c93597c784cf68dbe492ef35c00de7f4f6a990955c7144a40b20d86a3475f
Status: Downloaded newer image for debian:buster-slim
Desired=Unknown/Install/Remove/Purge/Hold
| Status=Not/Inst/Conf-files/Unpacked/halF-conf/Half-inst/trig-aWait/Trig-pend
|/ Err?=(none)/Reinst-required (Status,Err: uppercase=bad)
||/ Name           Version      Architecture Description
+++-==============-============-============-=================================
ii  libc-bin       2.28-10      amd64        GNU C Library: Binaries

Using the latest "debian:bookworm-slim" solved the problem.

Dockerfile:

FROM rust:1.56 as chef
RUN cargo install cargo-chef
WORKDIR /myapp
FROM chef AS planner
COPY . .
RUN cargo chef prepare --recipe-path recipe.json
FROM chef AS builder
COPY --from=planner /myapp/recipe.json recipe.json
# Build dependencies
RUN cargo chef cook --release --recipe-path recipe.json
# Build application
COPY . .
RUN cargo build --release
FROM debian:bookworm-slim AS runtime
WORKDIR /myapp
RUN apt-get update && apt-get install -y python3 python3-pip && rm -rf /var/lib/apt/lists/*
RUN pip3 install protobuf
COPY --from=builder /myapp/target/release/*.so /myapp/
COPY --from=builder /myapp/target/release/myapp /myapp/
COPY --from=builder /myapp/tests /myapp/tests
CMD ["myapp"]

(Jin Qing's Column, Nov. 3, 2021)

When deployed to a cluster of nodes, Orleans internally implements a protocol to manage it's silos, including discovery, failure and reconfigure, which is called cluster membership management.

Orleans has clustering membership providers for: Azure, SQL server, Zookeeper.

Clustering provider is one of key aspects of silo configuration.

Orleans.Clustering.Kubernetes

OrleansContrib/Orleans.Clustering.Kubernetes is a clustering provider for running Orleans cluster on Kubernetes.

Tell silo to use Kubernetes as the Cluster Membership Provider:

var silo = new SiloBuilder()
        ...
        .UseKubeMembership()
        ...
        .Build();

Interface

UseKubeMembership() instantiates a KubeMembershipTable which implements IMembershipTable.

    public interface IMembershipTable
    {
        Task InitializeMembershipTable(bool tryInitTableVersion);
        Task DeleteMembershipTableEntries(string clusterId);
        Task CleanupDefunctSiloEntries(DateTimeOffset beforeDate);
        Task<MembershipTableData> ReadRow(SiloAddress key);
        Task<MembershipTableData> ReadAll();
        Task<bool> InsertRow(MembershipEntry entry, TableVersion tableVersion);
        Task<bool> UpdateRow(MembershipEntry entry, string etag, TableVersion tableVersion);
        Task UpdateIAmAlive(MembershipEntry entry);
    }

Implement

KubeMembershipTable access Kubernetes API server to read and write silo entry CRD.

• InitializeMembershipTable()

  • TryInitClusterVersion()

    • _kubeClient.GetNamespacedCustomObjectAsync
    • _kubeClient.CreateNamespacedCustomObjectAsync

• DeleteMembershipTableEntries(string clusterId)

  • _kubeClient.DeleteNamespacedCustomObjectAsync

• InsertRow(...)

  • _kubeClient.GetNamespacedCustomObjectAsync
  • _kubeClient.ReplaceNamespacedCustomObjectAsync
  • _kubeClient.CreateNamespacedCustomObjectAsync

• ReadAll()

  • GetClusterVersion()

    • _kubeClient.ListNamespacedCustomObjectAsync

  • GetSilos()

    • _kubeClient.ListNamespacedCustomObjectAsync

• ReadRow(SiloAddress key)

  • _kubeClient.GetNamespacedCustomObjectAsync

• UpdateIAmAlive(MembershipEntry entry)

  • _kubeClient.GetNamespacedCustomObjectAsync
  • _kubeClient.ReplaceNamespacedCustomObjectAsync

• UpdateRow(...)

  • _kubeClient.ReplaceNamespacedCustomObjectAsync

• CleanupDefunctSiloEntries(DateTimeOffset beforeDate)

  • _kubeClient.DeleteNamespacedCustomObjectAsync

The operators to NamespacedCustomObject are:

• Delete
• Get
• Create
• Replace
• List

CRD

Two CRDs, ClusterVersion and Silo are defined in files:

• ClusterVersionCRD.yaml
• SiloEntryCRD.yaml

Custom resource objects are stored in etcd of Kubernetes.

(Jin Qing's Column, Nov. 2, 2021)

Virtual Actor is a concept invented by Microsoft Orleans, which is a framework of distributed actor.

Orleans: Distributed Virtual Actors for Programmability and Scalability describes the virtual programming model.

The virtual actor is analogous to virtual memory. Virtual actors are mapped to physical arctors instances in the running servers. Virtualization of actors in Orleans has 4 facets:

1. Perpetual existence

   • Actors always exist, virtually
   • Actors can not be created or destroied explicitly
   • Server failure does not affect the actors' existence

2. Automatic instantiation

   • Activation: Orleans automatically create an actor
   • A request triggers an activation if the actor doesn't exist
   • Unused actors are automatically reclaimed

3. Location transparency

   • Applications don't know where the physical actor is
   • Similar to virtual memory's "paged out" and mapping

4. Automatic scale out

   • 2 activation modes:

     • Single activation (default): Only one simultaneous actor is allowed

     • Stateless worker: Many activations of an actor are created

       • to increase throughput

Actor viruliaztion greatly simplifes the programming, since it gets rid of the burden of actor lifecycle control.

(Jin Qing's Column, Oct. 25, 2021)

Reading "The Evolution of Distributed Systems on Kubernetes" from Bilgin Ibryam.

https://www.infoq.com/articles/distributed-systems-kubernetes/

What are the purpose of projects like Dapr, Istio, Knative? How can they change the world?

Modern distributed systems

The needs of distributed systems:

• Business logic

• Other

  • Lifecycle: deploy, rollback, upgrade, scale, stop, isolate, config
  • Network: connect, circuit break, retry, timeout, load balance, discover, security, trace
  • Resource binding: to API, protocol, message, data format
  • State: stateless, stateful, store

Monolithic architecture

enterprise service bus (ESB): not distributed

Cloud-native architecture

Kubernetes: Lifecycle

Service Mesh

Istio: Networking

Serverless

Knative: scale

Dapr

Networking, resource binding, state

Trends

• Lifecycle: Kubernetes + operator
• Networking: Envoy
• Binding: Apache Camel
• State: Cloudstate

Multi-runtime microservice

Write business logic as another runtime. Here runtime is a process?

What comes after microservice

Faas is not the best. Multi-runtime microservice maybe is.

Mecha architecture

Idioms for Rust libraries are still forming, but if your library needs to report custom errors, then you should probably define your own error type. It’s up to you whether or not to expose its representation (like ErrorKind) or keep it hidden (like ParseIntError). Regardless of how you do it, it’s usually good practice to at least provide some information about the error beyond just its String representation. But certainly, this will vary depending on use cases.

At a minimum, you should probably implement the Error trait. This will give users of your library some minimum flexibility for composing errors. Implementing the Error trait also means that users are guaranteed the ability to obtain a string representation of an error (because it requires impls for both fmt::Debug and fmt::Display).

Beyond that, it can also be useful to provide implementations of From on your error types. This allows you (the library author) and your users to compose more detailed errors. For example, csv::Error provides From impls for both io::Error and byteorder::Error.

Finally, depending on your tastes, you may also want to define a Result type alias, particularly if your library defines a single error type. This is used in the standard library for io::Result and fmt::Result.

From: Error Handling in Rust - Andrew Gallant's Blog (burntsushi.net)

• Never use unwrap on Result. If the type is Err, it will panic and crash the program. The only exception is if it has already been checked for error previously or in test code.
• Never use unwrap on Option for the same reason if the type is None as Result is Err.

pub(in path), pub(crate), pub(super), and pub(self)

In addition to public and private, Rust allows users to declare an item as visible only within a given scope. The rules for pub restrictions are as follows:

• pub(in path) makes an item visible within the provided path. path must be an ancestor module of the item whose visibility is being declared.
• pub(crate) makes an item visible within the current crate.
• pub(super) makes an item visible to the parent module. This is equivalent to pub(in super).
• pub(self) makes an item visible to the current module. This is equivalent to pub(in self) or not using pub at all.