|
| 1 | +//! An implementation of `now_utc` which calls out to an externally defined function. |
| 2 | +use crate::common::Timestamp; |
| 3 | + |
| 4 | +/// Register a function to be invoked by `identity_core` in order to get a [Timestamp] representing |
| 5 | +/// "now". |
| 6 | +/// |
| 7 | +/// ## Writing a custom `now_utc` implementation |
| 8 | +/// |
| 9 | +/// The function to register must have the same signature as |
| 10 | +/// [`Timestamp::now_utc`](Timestamp::now_utc). The function can be defined |
| 11 | +/// wherever you want, either in root crate or a dependent crate. |
| 12 | +/// |
| 13 | +/// For example, if we wanted a `static_now_utc` crate containing an |
| 14 | +/// implementation that always returns the same timestamp, we would first depend on `identity_core` |
| 15 | +/// (for the [`Timestamp`] type) in `static_now_utc/Cargo.toml`: |
| 16 | +/// ```toml |
| 17 | +/// [dependencies] |
| 18 | +/// identity_core = "1" |
| 19 | +/// ``` |
| 20 | +/// Note that the crate containing this function does **not** need to enable the |
| 21 | +/// `"custom_time"` Cargo feature. |
| 22 | +/// |
| 23 | +/// Next, in `static_now_utc/src/lib.rs`, we define our function: |
| 24 | +/// ```rust |
| 25 | +/// use identity_core::common::Timestamp; |
| 26 | +/// |
| 27 | +/// // Some fixed timestamp |
| 28 | +/// const MY_FIXED_TIMESTAMP: i64 = 1724402964; |
| 29 | +/// pub fn static_now_utc() -> Timestamp { |
| 30 | +/// Timestamp::from_unix(MY_FIXED_TIMESTAMP).unwrap() |
| 31 | +/// } |
| 32 | +/// ``` |
| 33 | +/// |
| 34 | +/// ## Registering a custom `now_utc` implementation |
| 35 | +/// |
| 36 | +/// Functions can only be registered in the root binary crate. Attempting to |
| 37 | +/// register a function in a non-root crate will result in a linker error. |
| 38 | +/// This is similar to |
| 39 | +/// [`#[panic_handler]`](https://doc.rust-lang.org/nomicon/panic-handler.html) or |
| 40 | +/// [`#[global_allocator]`](https://doc.rust-lang.org/edition-guide/rust-2018/platform-and-target-support/global-allocators.html), |
| 41 | +/// where helper crates define handlers/allocators but only the binary crate |
| 42 | +/// actually _uses_ the functionality. |
| 43 | +/// |
| 44 | +/// To register the function, we first depend on `static_now_utc` _and_ |
| 45 | +/// `identity_core` in `Cargo.toml`: |
| 46 | +/// ```toml |
| 47 | +/// [dependencies] |
| 48 | +/// static_now_utc = "0.1" |
| 49 | +/// identity_core = { version = "1", features = ["custom_time"] } |
| 50 | +/// ``` |
| 51 | +/// |
| 52 | +/// Then, we register the function in `src/main.rs`: |
| 53 | +/// ```rust |
| 54 | +/// # mod static_now_utc { pub fn static_now_utc() -> Timestamp { unimplemented!() } } |
| 55 | +/// |
| 56 | +/// use static_now_utc::static_now_utc; |
| 57 | +/// use identity_core::register_custom_now_utc; |
| 58 | +/// |
| 59 | +/// register_custom_now_utc!(static_now_utc); |
| 60 | +/// ``` |
| 61 | +/// |
| 62 | +/// Now any user of `now_utc` (direct or indirect) on this target will use the |
| 63 | +/// registered function. |
| 64 | +#[macro_export] |
| 65 | +macro_rules! register_custom_now_utc { |
| 66 | + ($path:path) => { |
| 67 | + const __GET_TIME_INTERNAL: () = { |
| 68 | + // We use Rust ABI to be safe against potential panics in the passed function. |
| 69 | + #[no_mangle] |
| 70 | + unsafe fn __now_utc_custom() -> Timestamp { |
| 71 | + // Make sure the passed function has the type of getrandom::getrandom |
| 72 | + type F = fn() -> Timestamp; |
| 73 | + let f: F = $path; |
| 74 | + f() |
| 75 | + } |
| 76 | + }; |
| 77 | + }; |
| 78 | +} |
| 79 | + |
| 80 | +pub(crate) fn now_utc_custom() -> Timestamp { |
| 81 | + extern "Rust" { |
| 82 | + fn __now_utc_custom() -> Timestamp; |
| 83 | + } |
| 84 | + unsafe { __now_utc_custom() } |
| 85 | +} |
0 commit comments