refresh_machines 0.7.3
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- checksums.yaml +7 -0
- data/CHANGELOG.md +109 -0
- data/Cargo.lock +325 -0
- data/Cargo.toml +29 -0
- data/LICENSE.txt +21 -0
- data/README.md +352 -0
- data/ext/refresh_machines_native/core/CHANGELOG.md +77 -0
- data/ext/refresh_machines_native/core/Cargo.toml +21 -0
- data/ext/refresh_machines_native/core/README.md +175 -0
- data/ext/refresh_machines_native/core/src/decision.rs +83 -0
- data/ext/refresh_machines_native/core/src/lead.rs +123 -0
- data/ext/refresh_machines_native/core/src/lease.rs +42 -0
- data/ext/refresh_machines_native/core/src/lib.rs +564 -0
- data/ext/refresh_machines_native/core/src/policy.rs +79 -0
- data/ext/refresh_machines_native/core/src/refusal.rs +47 -0
- data/ext/refresh_machines_native/extconf.rb +2 -0
- data/ext/refresh_machines_native/ffi/Cargo.toml +22 -0
- data/ext/refresh_machines_native/ffi/extconf.rb +14 -0
- data/ext/refresh_machines_native/ffi/src/answers.rs +117 -0
- data/ext/refresh_machines_native/ffi/src/init.rs +66 -0
- data/ext/refresh_machines_native/ffi/src/lib.rs +389 -0
- data/ext/refresh_machines_native/ffi/src/values.rs +124 -0
- data/lib/refresh_machines/version.rb +5 -0
- data/lib/refresh_machines.rb +113 -0
- data/sig/refresh_machines.rbs +179 -0
- metadata +90 -0
|
@@ -0,0 +1,22 @@
|
|
|
1
|
+
[package]
|
|
2
|
+
name = "refresh_machines_native"
|
|
3
|
+
version = "0.1.8"
|
|
4
|
+
edition.workspace = true
|
|
5
|
+
rust-version.workspace = true
|
|
6
|
+
license.workspace = true
|
|
7
|
+
publish = false
|
|
8
|
+
|
|
9
|
+
[lib]
|
|
10
|
+
crate-type = ["cdylib"]
|
|
11
|
+
test = false
|
|
12
|
+
doctest = false
|
|
13
|
+
|
|
14
|
+
[dependencies]
|
|
15
|
+
refresh-machines.workspace = true
|
|
16
|
+
periscope-machines.workspace = true
|
|
17
|
+
magnus.workspace = true
|
|
18
|
+
rb-sys.workspace = true
|
|
19
|
+
matryona-machines = { workspace = true, features = ["ruby"] }
|
|
20
|
+
|
|
21
|
+
[lints]
|
|
22
|
+
workspace = true
|
|
@@ -0,0 +1,14 @@
|
|
|
1
|
+
# frozen_string_literal: true
|
|
2
|
+
require 'mkmf'
|
|
3
|
+
require 'pathname'
|
|
4
|
+
require 'rb_sys/mkmf'
|
|
5
|
+
|
|
6
|
+
create_rust_makefile('refresh_machines_native/refresh_machines_native') do |e|
|
|
7
|
+
e.ext_dir = Pathname(__dir__).relative_path_from(Pathname(Dir.pwd)).to_s
|
|
8
|
+
e.profile = ENV.fetch('RB_SYS_CARGO_PROFILE', :release).to_sym
|
|
9
|
+
end
|
|
10
|
+
makefile = File.join(Dir.pwd, 'Makefile')
|
|
11
|
+
File.write(makefile, File.read(makefile).gsub(
|
|
12
|
+
/^RB_SYS_CARGO_MANIFEST_DIR \?=.*$/,
|
|
13
|
+
"RB_SYS_CARGO_MANIFEST_DIR ?= #{File.expand_path(__dir__)}"
|
|
14
|
+
))
|
|
@@ -0,0 +1,117 @@
|
|
|
1
|
+
//! The gem's `Data` classes, resolved once at init and pinned, and the values
|
|
2
|
+
//! built from what the core answered.
|
|
3
|
+
//!
|
|
4
|
+
//! `lib/refresh_machines.rb` defines every class before this extension loads.
|
|
5
|
+
//! An answer is built natively (allocate, fill the members in order, freeze),
|
|
6
|
+
//! which is all `Data#initialize` does past the check, and the core's own
|
|
7
|
+
//! answers need no check, so no Ruby code runs while one is built. Mutating
|
|
8
|
+
//! calls build on a copy of the refresher kept only once the answer exists.
|
|
9
|
+
|
|
10
|
+
use magnus::{Error, IntoValue, RClass, RModule, RStruct, Ruby, TryConvert, Value, prelude::*};
|
|
11
|
+
use matryona_machines::ruby::{Class, SymbolNames, Symbols, nanoseconds};
|
|
12
|
+
use refresh_machines::{Decision, Notification, Outcome, Revalidation};
|
|
13
|
+
|
|
14
|
+
use crate::refusal;
|
|
15
|
+
|
|
16
|
+
/// Every `Data` class of the gem, as resolved at init.
|
|
17
|
+
pub struct Classes {
|
|
18
|
+
pub policy: Class,
|
|
19
|
+
pub fresh: Class,
|
|
20
|
+
pub stale: Class,
|
|
21
|
+
pub fetch: Class,
|
|
22
|
+
pub wait: Class,
|
|
23
|
+
pub lead: Class,
|
|
24
|
+
pub backoff: Class,
|
|
25
|
+
pub unavailable: Class,
|
|
26
|
+
pub notification: Class,
|
|
27
|
+
}
|
|
28
|
+
|
|
29
|
+
matryona_machines::registry! {
|
|
30
|
+
static CLASSES: Classes = "refresh_machines";
|
|
31
|
+
pub fn classes;
|
|
32
|
+
}
|
|
33
|
+
|
|
34
|
+
pub fn resolve(ruby: &Ruby, module: RModule) -> Result<(), Error> {
|
|
35
|
+
let class = |name| Class::resolve(ruby, module, name);
|
|
36
|
+
let classes = Classes {
|
|
37
|
+
policy: class("Policy")?,
|
|
38
|
+
fresh: class("Fresh")?,
|
|
39
|
+
stale: class("Stale")?,
|
|
40
|
+
fetch: class("Fetch")?,
|
|
41
|
+
wait: class("Wait")?,
|
|
42
|
+
lead: class("Lead")?,
|
|
43
|
+
backoff: class("Backoff")?,
|
|
44
|
+
unavailable: class("Unavailable")?,
|
|
45
|
+
notification: class("Notification")?,
|
|
46
|
+
};
|
|
47
|
+
CLASSES.set(ruby, classes).map(drop)
|
|
48
|
+
}
|
|
49
|
+
|
|
50
|
+
/// A frozen instance of `class` holding `members`, in order.
|
|
51
|
+
fn build<const N: usize>(class: RClass, members: [Value; N]) -> Result<Value, Error> {
|
|
52
|
+
let instance = RStruct::try_convert(class.obj_alloc()?)?;
|
|
53
|
+
for (index, member) in members.into_iter().enumerate() {
|
|
54
|
+
instance.aset(index, member)?;
|
|
55
|
+
}
|
|
56
|
+
instance.freeze();
|
|
57
|
+
Ok(instance.as_value())
|
|
58
|
+
}
|
|
59
|
+
|
|
60
|
+
impl Classes {
|
|
61
|
+
pub fn notification(&self, ruby: &Ruby, note: Notification) -> Result<Value, Error> {
|
|
62
|
+
let outcome = Outcomes::symbol(ruby, note.outcome());
|
|
63
|
+
let members = [
|
|
64
|
+
note.waiter().raw().into_value_with(ruby),
|
|
65
|
+
note.flight().raw().into_value_with(ruby),
|
|
66
|
+
note.key().into_value_with(ruby),
|
|
67
|
+
outcome.as_value(),
|
|
68
|
+
];
|
|
69
|
+
build(self.notification.get(ruby), members)
|
|
70
|
+
}
|
|
71
|
+
|
|
72
|
+
pub fn decision(&self, ruby: &Ruby, decision: Decision) -> Result<Value, Error> {
|
|
73
|
+
let id = |raw: u64| raw.into_value_with(ruby);
|
|
74
|
+
let span = |duration| nanoseconds(ruby, duration).as_value();
|
|
75
|
+
match decision {
|
|
76
|
+
Decision::Fresh { age } => build(self.fresh.get(ruby), [span(age)]),
|
|
77
|
+
Decision::Stale { age, revalidation } => {
|
|
78
|
+
let revalidation = match revalidation {
|
|
79
|
+
Revalidation::Lead(lease) => build(self.lead.get(ruby), [id(lease.raw())])?,
|
|
80
|
+
Revalidation::InFlight => {
|
|
81
|
+
Revalidations::symbol(ruby, &Revalidation::InFlight).as_value()
|
|
82
|
+
}
|
|
83
|
+
Revalidation::Backoff { until } => {
|
|
84
|
+
build(self.backoff.get(ruby), [span(until)])?
|
|
85
|
+
}
|
|
86
|
+
Revalidation::Unavailable(refused) => {
|
|
87
|
+
build(self.unavailable.get(ruby), [refusal(ruby, refused)])?
|
|
88
|
+
}
|
|
89
|
+
};
|
|
90
|
+
build(self.stale.get(ruby), [span(age), revalidation])
|
|
91
|
+
}
|
|
92
|
+
Decision::Fetch { lease } => build(self.fetch.get(ruby), [id(lease.raw())]),
|
|
93
|
+
Decision::Wait { waiter, flight } => {
|
|
94
|
+
build(self.wait.get(ruby), [id(waiter.raw()), id(flight.raw())])
|
|
95
|
+
}
|
|
96
|
+
}
|
|
97
|
+
}
|
|
98
|
+
}
|
|
99
|
+
|
|
100
|
+
matryona_machines::symbols! {
|
|
101
|
+
/// A `Stale#revalidation`'s kind. `:in_flight` is the one unit variant,
|
|
102
|
+
/// the only one that crosses as a Symbol; the others are `Data` values.
|
|
103
|
+
pub Revalidations for Revalidation as "revalidation" => names_only {
|
|
104
|
+
Lead(..) => "lead",
|
|
105
|
+
InFlight => "in_flight",
|
|
106
|
+
Backoff { .. } => "backoff",
|
|
107
|
+
Unavailable(..) => "unavailable",
|
|
108
|
+
}
|
|
109
|
+
}
|
|
110
|
+
|
|
111
|
+
matryona_machines::symbols! {
|
|
112
|
+
/// How a flight settled, as the Symbol a `Notification#outcome` holds.
|
|
113
|
+
pub Outcomes for Outcome as "outcome" {
|
|
114
|
+
Completed => "completed",
|
|
115
|
+
Abandoned => "abandoned",
|
|
116
|
+
}
|
|
117
|
+
}
|
|
@@ -0,0 +1,66 @@
|
|
|
1
|
+
//! Private native entry point.
|
|
2
|
+
use crate::{
|
|
3
|
+
FLIGHT_CAPACITY, KEY_CAPACITY, Refresher, WAITER_CAPACITY, policy_if_error, policy_state,
|
|
4
|
+
policy_while_revalidate, scope_of_id, values,
|
|
5
|
+
};
|
|
6
|
+
use magnus::{Error, Ruby, function, method, prelude::*};
|
|
7
|
+
use matryona_machines::ruby::Class;
|
|
8
|
+
|
|
9
|
+
#[magnus::init]
|
|
10
|
+
fn init(ruby: &Ruby) -> Result<(), Error> {
|
|
11
|
+
let module = ruby.define_module("RefreshMachines")?;
|
|
12
|
+
crate::answers::resolve(ruby, module)?;
|
|
13
|
+
module.define_singleton_method("scope_of", function!(scope_of_id, 1))?;
|
|
14
|
+
// Validation hooks for the Data values; lib/ makes them private.
|
|
15
|
+
module.define_singleton_method("__policy", function!(values::policy, 3))?;
|
|
16
|
+
module.define_singleton_method("__age", function!(values::age, 1))?;
|
|
17
|
+
module.define_singleton_method("__until", function!(values::until, 1))?;
|
|
18
|
+
module.define_singleton_method("__lease", function!(values::lease, 1))?;
|
|
19
|
+
module.define_singleton_method("__wait", function!(values::wait, 2))?;
|
|
20
|
+
module.define_singleton_method("__notification", function!(values::notification, 4))?;
|
|
21
|
+
module.define_singleton_method("__refusal", function!(values::refusal, 1))?;
|
|
22
|
+
module.define_singleton_method("__revalidation", function!(values::revalidation, 1))?;
|
|
23
|
+
// Policy is a Data class defined in Ruby; its arithmetic lives here.
|
|
24
|
+
let policy = crate::answers::classes(ruby)?.policy.get(ruby);
|
|
25
|
+
policy.define_method("state", method!(policy_state, 1))?;
|
|
26
|
+
policy.define_method("while_revalidate?", method!(policy_while_revalidate, 1))?;
|
|
27
|
+
policy.define_method("if_error?", method!(policy_if_error, 1))?;
|
|
28
|
+
let class = module.define_class("Refresher", ruby.class_object())?;
|
|
29
|
+
class.undef_default_alloc_func();
|
|
30
|
+
class.const_set("CAPACITY", KEY_CAPACITY)?;
|
|
31
|
+
class.const_set("FLIGHT_CAPACITY", FLIGHT_CAPACITY)?;
|
|
32
|
+
class.const_set("WAITER_CAPACITY", WAITER_CAPACITY)?;
|
|
33
|
+
class.define_singleton_method("new", function!(Refresher::new, 0))?;
|
|
34
|
+
class.define_singleton_method("with_scope", function!(Refresher::with_scope, 1))?;
|
|
35
|
+
class.define_singleton_method("resumed", function!(Refresher::resumed, 2))?;
|
|
36
|
+
class.define_method("scope", method!(Refresher::scope, 0))?;
|
|
37
|
+
class.define_method("issued", method!(Refresher::issued, 0))?;
|
|
38
|
+
class.define_method("decide", method!(Refresher::decide, 3))?;
|
|
39
|
+
class.define_method("store", method!(Refresher::store, 4))?;
|
|
40
|
+
class.define_method("fail", method!(Refresher::fail, 3))?;
|
|
41
|
+
class.define_method("abandon", method!(Refresher::abandon, 1))?;
|
|
42
|
+
class.define_method("reap", method!(Refresher::reap, 1))?;
|
|
43
|
+
class.define_method("put", method!(Refresher::put, 4))?;
|
|
44
|
+
class.define_method("forget", method!(Refresher::forget, 1))?;
|
|
45
|
+
class.define_method("sweep", method!(Refresher::sweep, 2))?;
|
|
46
|
+
class.define_method("cancel", method!(Refresher::cancel, 1))?;
|
|
47
|
+
class.define_method("poll", method!(Refresher::poll, 0))?;
|
|
48
|
+
class.define_method("drain", method!(Refresher::drain, 1))?;
|
|
49
|
+
class.define_method("age", method!(Refresher::age, 2))?;
|
|
50
|
+
class.define_method("state", method!(Refresher::state, 2))?;
|
|
51
|
+
class.define_method("stale_if_error", method!(Refresher::stale_if_error, 2))?;
|
|
52
|
+
class.define_method("leading", method!(Refresher::leading, 1))?;
|
|
53
|
+
class.define_method("flight", method!(Refresher::flight, 1))?;
|
|
54
|
+
class.define_method("now", method!(Refresher::now, 0))?;
|
|
55
|
+
class.define_method("size", method!(Refresher::size, 0))?;
|
|
56
|
+
class.define_method("empty?", method!(Refresher::is_empty, 0))?;
|
|
57
|
+
class.define_method("in_flight", method!(Refresher::in_flight, 0))?;
|
|
58
|
+
class.define_method("waiting", method!(Refresher::waiting, 0))?;
|
|
59
|
+
class.define_method("pending", method!(Refresher::pending, 0))?;
|
|
60
|
+
class.define_method("capacity", function!(Refresher::capacity, 0))?;
|
|
61
|
+
class.define_method("flight_capacity", function!(Refresher::flight_capacity, 0))?;
|
|
62
|
+
class.define_method("waiter_capacity", function!(Refresher::waiter_capacity, 0))?;
|
|
63
|
+
// `new`, `with_scope` and `resumed` answer a Refresher: its class is
|
|
64
|
+
// fixed now, so building one never runs `Object.const_get`.
|
|
65
|
+
Class::pin_wrapped::<Refresher>(ruby, class).map(drop)
|
|
66
|
+
}
|
|
@@ -0,0 +1,389 @@
|
|
|
1
|
+
//! Thin binding to the bounded freshness and refresh-lease policy.
|
|
2
|
+
mod answers;
|
|
3
|
+
mod init;
|
|
4
|
+
mod values;
|
|
5
|
+
|
|
6
|
+
use std::cell::RefCell;
|
|
7
|
+
|
|
8
|
+
use magnus::{
|
|
9
|
+
Error, Integer, RArray, Ruby, Symbol, TryConvert, Value, prelude::*, typed_data::Obj,
|
|
10
|
+
};
|
|
11
|
+
use matryona_machines::ruby::{
|
|
12
|
+
Symbols, duration, exact_fields, instant, integer, keep, nanoseconds, symbol,
|
|
13
|
+
};
|
|
14
|
+
use periscope_machines::scope_of;
|
|
15
|
+
use refresh_machines::{
|
|
16
|
+
FlightId, Forgetting, Lease, Notification, Policy, Refresher as Core, Refusal, State,
|
|
17
|
+
};
|
|
18
|
+
use values::{lease_id, waiter_id};
|
|
19
|
+
|
|
20
|
+
/// `RefreshMachines.scope_of(id)`: the scope a lease, waiter or flight id was issued under.
|
|
21
|
+
fn scope_of_id(id: Value) -> Result<u16, Error> {
|
|
22
|
+
integer(id, "id").map(scope_of)
|
|
23
|
+
}
|
|
24
|
+
|
|
25
|
+
const KEY_CAPACITY: usize = 256;
|
|
26
|
+
const FLIGHT_CAPACITY: usize = 64;
|
|
27
|
+
const WAITER_CAPACITY: usize = 256;
|
|
28
|
+
|
|
29
|
+
/// How much of a `capacity`-long buffer a `max` asks for: past the capacity
|
|
30
|
+
/// there is never more to take, so it is the whole buffer.
|
|
31
|
+
fn room(max: u64, capacity: usize) -> usize {
|
|
32
|
+
usize::try_from(max).map_or(capacity, |max| max.min(capacity))
|
|
33
|
+
}
|
|
34
|
+
|
|
35
|
+
/// A `RefreshMachines::Policy`: exactly that class, its windows read from
|
|
36
|
+
/// the struct (no reader runs) and converted again, since `Marshal.load`
|
|
37
|
+
/// skips `initialize`.
|
|
38
|
+
#[derive(Clone, Copy)]
|
|
39
|
+
struct Rules(Policy);
|
|
40
|
+
|
|
41
|
+
impl TryConvert for Rules {
|
|
42
|
+
fn try_convert(value: Value) -> Result<Self, Error> {
|
|
43
|
+
let ruby = Ruby::get_with(value);
|
|
44
|
+
let class = answers::classes(&ruby)?.policy.get(&ruby);
|
|
45
|
+
let [fresh, revalidate, if_error] =
|
|
46
|
+
exact_fields(&ruby, value, class, "expected a RefreshMachines::Policy")?;
|
|
47
|
+
Ok(Self(Policy::new(
|
|
48
|
+
duration(fresh, "fresh_for")?,
|
|
49
|
+
duration(revalidate, "stale_while_revalidate")?,
|
|
50
|
+
duration(if_error, "stale_if_error")?,
|
|
51
|
+
)))
|
|
52
|
+
}
|
|
53
|
+
}
|
|
54
|
+
|
|
55
|
+
matryona_machines::symbols! {
|
|
56
|
+
/// A refusal as its Symbol: the snake case of the core variant.
|
|
57
|
+
Refusals for Refusal as "refusal" {
|
|
58
|
+
TimeRegressed => "time_regressed",
|
|
59
|
+
ZeroLead => "zero_lead",
|
|
60
|
+
EntriesFull => "entries_full",
|
|
61
|
+
FlightsFull => "flights_full",
|
|
62
|
+
WaitersFull => "waiters_full",
|
|
63
|
+
Exhausted => "exhausted",
|
|
64
|
+
Stale => "stale",
|
|
65
|
+
}
|
|
66
|
+
}
|
|
67
|
+
|
|
68
|
+
fn refusal(ruby: &Ruby, refused: Refusal) -> Value {
|
|
69
|
+
Refusals::symbol(ruby, refused).as_value()
|
|
70
|
+
}
|
|
71
|
+
|
|
72
|
+
fn done(ruby: &Ruby, outcome: Result<(), Refusal>, name: &str) -> Value {
|
|
73
|
+
match outcome {
|
|
74
|
+
Ok(()) => symbol(ruby, name).as_value(),
|
|
75
|
+
Err(refused) => refusal(ruby, refused),
|
|
76
|
+
}
|
|
77
|
+
}
|
|
78
|
+
|
|
79
|
+
fn state_name(ruby: &Ruby, state: State) -> Symbol {
|
|
80
|
+
symbol(
|
|
81
|
+
ruby,
|
|
82
|
+
match state {
|
|
83
|
+
State::Fresh => "fresh",
|
|
84
|
+
State::Stale => "stale",
|
|
85
|
+
State::Expired => "expired",
|
|
86
|
+
},
|
|
87
|
+
)
|
|
88
|
+
}
|
|
89
|
+
|
|
90
|
+
fn policy_state(ruby: &Ruby, this: Value, age: Value) -> Result<Symbol, Error> {
|
|
91
|
+
let age = duration(age, "age")?;
|
|
92
|
+
Ok(state_name(ruby, Rules::try_convert(this)?.0.state(age)))
|
|
93
|
+
}
|
|
94
|
+
|
|
95
|
+
fn policy_while_revalidate(this: Value, age: Value) -> Result<bool, Error> {
|
|
96
|
+
let age = duration(age, "age")?;
|
|
97
|
+
Ok(Rules::try_convert(this)?.0.while_revalidate(age))
|
|
98
|
+
}
|
|
99
|
+
|
|
100
|
+
fn policy_if_error(this: Value, age: Value) -> Result<bool, Error> {
|
|
101
|
+
let age = duration(age, "age")?;
|
|
102
|
+
Ok(Rules::try_convert(this)?.0.if_error(age))
|
|
103
|
+
}
|
|
104
|
+
|
|
105
|
+
type Held = Core<KEY_CAPACITY, FLIGHT_CAPACITY, WAITER_CAPACITY>;
|
|
106
|
+
|
|
107
|
+
#[magnus::wrap(class = "RefreshMachines::Refresher", free_immediately, size)]
|
|
108
|
+
struct Refresher {
|
|
109
|
+
core: RefCell<Held>,
|
|
110
|
+
}
|
|
111
|
+
|
|
112
|
+
impl Refresher {
|
|
113
|
+
const fn new() -> Self {
|
|
114
|
+
Self {
|
|
115
|
+
core: RefCell::new(Core::new()),
|
|
116
|
+
}
|
|
117
|
+
}
|
|
118
|
+
|
|
119
|
+
fn with_scope(scope: Value) -> Result<Self, Error> {
|
|
120
|
+
Ok(Self {
|
|
121
|
+
core: RefCell::new(Core::with_scope(integer(scope, "scope")?)),
|
|
122
|
+
})
|
|
123
|
+
}
|
|
124
|
+
|
|
125
|
+
/// Raises `RangeError` when `issued` is beyond the sequence (the core answers `None`).
|
|
126
|
+
fn resumed(ruby: &Ruby, scope: Value, issued: Value) -> Result<Self, Error> {
|
|
127
|
+
let (scope, issued) = (integer(scope, "scope")?, integer(issued, "issued")?);
|
|
128
|
+
Core::resumed(scope, issued)
|
|
129
|
+
.map(|core| Self {
|
|
130
|
+
core: RefCell::new(core),
|
|
131
|
+
})
|
|
132
|
+
.ok_or_else(|| {
|
|
133
|
+
Error::new(
|
|
134
|
+
ruby.exception_range_error(),
|
|
135
|
+
"issued is past the last sequence of a scope (2**48 - 1)",
|
|
136
|
+
)
|
|
137
|
+
})
|
|
138
|
+
}
|
|
139
|
+
|
|
140
|
+
fn scope(&self) -> u16 {
|
|
141
|
+
self.core.borrow().scope()
|
|
142
|
+
}
|
|
143
|
+
|
|
144
|
+
fn issued(&self) -> u64 {
|
|
145
|
+
self.core.borrow().issued()
|
|
146
|
+
}
|
|
147
|
+
|
|
148
|
+
fn decide(
|
|
149
|
+
ruby: &Ruby,
|
|
150
|
+
this: Obj<Self>,
|
|
151
|
+
key: Value,
|
|
152
|
+
now: Value,
|
|
153
|
+
lead_for: Value,
|
|
154
|
+
) -> Result<Value, Error> {
|
|
155
|
+
this.check_frozen()?;
|
|
156
|
+
let (key, now) = (integer(key, "key")?, instant(now, "now")?);
|
|
157
|
+
let lead_for = duration(lead_for, "lead_for")?;
|
|
158
|
+
let classes = answers::classes(ruby)?;
|
|
159
|
+
keep(
|
|
160
|
+
ruby,
|
|
161
|
+
this,
|
|
162
|
+
&this.core,
|
|
163
|
+
|core| core.decide(key, now, lead_for),
|
|
164
|
+
|decided| match decided {
|
|
165
|
+
Ok(decision) => classes.decision(ruby, decision),
|
|
166
|
+
Err(refused) => Ok(refusal(ruby, refused)),
|
|
167
|
+
},
|
|
168
|
+
)
|
|
169
|
+
}
|
|
170
|
+
|
|
171
|
+
fn store(
|
|
172
|
+
ruby: &Ruby,
|
|
173
|
+
this: Obj<Self>,
|
|
174
|
+
lease: Value,
|
|
175
|
+
now: Value,
|
|
176
|
+
age: Value,
|
|
177
|
+
policy: Value,
|
|
178
|
+
) -> Result<Value, Error> {
|
|
179
|
+
this.check_frozen()?;
|
|
180
|
+
let (lease, now) = (integer(lease, "lease")?, instant(now, "now")?);
|
|
181
|
+
let (age, policy) = (duration(age, "age")?, Rules::try_convert(policy)?.0);
|
|
182
|
+
let lease = lease_id(ruby, lease)?;
|
|
183
|
+
let outcome = this.core.borrow_mut().store(lease, now, age, policy);
|
|
184
|
+
Ok(done(ruby, outcome, "stored"))
|
|
185
|
+
}
|
|
186
|
+
|
|
187
|
+
fn fail(
|
|
188
|
+
ruby: &Ruby,
|
|
189
|
+
this: Obj<Self>,
|
|
190
|
+
lease: Value,
|
|
191
|
+
now: Value,
|
|
192
|
+
retry_after: Value,
|
|
193
|
+
) -> Result<Value, Error> {
|
|
194
|
+
this.check_frozen()?;
|
|
195
|
+
let (lease, now) = (integer(lease, "lease")?, instant(now, "now")?);
|
|
196
|
+
let retry_after = duration(retry_after, "retry_after")?;
|
|
197
|
+
let lease = lease_id(ruby, lease)?;
|
|
198
|
+
let outcome = this.core.borrow_mut().fail(lease, now, retry_after);
|
|
199
|
+
Ok(match outcome {
|
|
200
|
+
Ok(Some(age)) => nanoseconds(ruby, age).as_value(),
|
|
201
|
+
Ok(None) => ruby.qnil().as_value(),
|
|
202
|
+
Err(refused) => refusal(ruby, refused),
|
|
203
|
+
})
|
|
204
|
+
}
|
|
205
|
+
|
|
206
|
+
fn abandon(ruby: &Ruby, this: Obj<Self>, lease: Value) -> Result<Value, Error> {
|
|
207
|
+
this.check_frozen()?;
|
|
208
|
+
let lease = integer(lease, "lease")?;
|
|
209
|
+
let lease = lease_id(ruby, lease)?;
|
|
210
|
+
let outcome = this.core.borrow_mut().abandon(lease);
|
|
211
|
+
Ok(done(ruby, outcome, "abandoned"))
|
|
212
|
+
}
|
|
213
|
+
|
|
214
|
+
fn reap(ruby: &Ruby, this: Obj<Self>, now: Value) -> Result<Value, Error> {
|
|
215
|
+
this.check_frozen()?;
|
|
216
|
+
let now = instant(now, "now")?;
|
|
217
|
+
let outcome = this.core.borrow_mut().reap(now);
|
|
218
|
+
Ok(match outcome {
|
|
219
|
+
Ok(revoked) => ruby.integer_from_u64(revoked as u64).as_value(),
|
|
220
|
+
Err(refused) => refusal(ruby, refused),
|
|
221
|
+
})
|
|
222
|
+
}
|
|
223
|
+
|
|
224
|
+
fn put(
|
|
225
|
+
ruby: &Ruby,
|
|
226
|
+
this: Obj<Self>,
|
|
227
|
+
key: Value,
|
|
228
|
+
now: Value,
|
|
229
|
+
age: Value,
|
|
230
|
+
policy: Value,
|
|
231
|
+
) -> Result<Value, Error> {
|
|
232
|
+
this.check_frozen()?;
|
|
233
|
+
let (key, now) = (integer(key, "key")?, instant(now, "now")?);
|
|
234
|
+
let (age, policy) = (duration(age, "age")?, Rules::try_convert(policy)?.0);
|
|
235
|
+
let outcome = this.core.borrow_mut().put(key, now, age, policy);
|
|
236
|
+
Ok(done(ruby, outcome, "stored"))
|
|
237
|
+
}
|
|
238
|
+
|
|
239
|
+
fn forget(ruby: &Ruby, this: Obj<Self>, key: Value) -> Result<Symbol, Error> {
|
|
240
|
+
this.check_frozen()?;
|
|
241
|
+
let key = integer(key, "key")?;
|
|
242
|
+
let forgetting = this.core.borrow_mut().forget(key);
|
|
243
|
+
Ok(symbol(
|
|
244
|
+
ruby,
|
|
245
|
+
match forgetting {
|
|
246
|
+
Forgetting::Forgotten => "forgotten",
|
|
247
|
+
Forgetting::NotHeld => "not_held",
|
|
248
|
+
},
|
|
249
|
+
))
|
|
250
|
+
}
|
|
251
|
+
|
|
252
|
+
fn sweep(ruby: &Ruby, this: Obj<Self>, now: Value, max: Value) -> Result<Value, Error> {
|
|
253
|
+
this.check_frozen()?;
|
|
254
|
+
let (now, max) = (instant(now, "now")?, integer(max, "max")?);
|
|
255
|
+
let room = room(max, KEY_CAPACITY);
|
|
256
|
+
keep(
|
|
257
|
+
ruby,
|
|
258
|
+
this,
|
|
259
|
+
&this.core,
|
|
260
|
+
|core| {
|
|
261
|
+
let mut buffer = [0_u64; KEY_CAPACITY];
|
|
262
|
+
core.sweep(now, &mut buffer[..room])
|
|
263
|
+
.map(|written| (buffer, written))
|
|
264
|
+
},
|
|
265
|
+
|swept| {
|
|
266
|
+
let (buffer, written) = match swept {
|
|
267
|
+
Ok(swept) => swept,
|
|
268
|
+
Err(refused) => return Ok(refusal(ruby, refused)),
|
|
269
|
+
};
|
|
270
|
+
let keys = ruby.ary_new_capa(written);
|
|
271
|
+
for key in buffer.iter().take(written) {
|
|
272
|
+
keys.push(*key)?;
|
|
273
|
+
}
|
|
274
|
+
Ok(keys.as_value())
|
|
275
|
+
},
|
|
276
|
+
)
|
|
277
|
+
}
|
|
278
|
+
|
|
279
|
+
fn cancel(ruby: &Ruby, this: Obj<Self>, waiter: Value) -> Result<Value, Error> {
|
|
280
|
+
this.check_frozen()?;
|
|
281
|
+
let waiter = integer(waiter, "waiter")?;
|
|
282
|
+
let waiter = waiter_id(ruby, waiter)?;
|
|
283
|
+
let outcome = this.core.borrow_mut().cancel(waiter);
|
|
284
|
+
Ok(done(ruby, outcome, "cancelled"))
|
|
285
|
+
}
|
|
286
|
+
|
|
287
|
+
fn poll(ruby: &Ruby, this: Obj<Self>) -> Result<Option<Value>, Error> {
|
|
288
|
+
this.check_frozen()?;
|
|
289
|
+
let classes = answers::classes(ruby)?;
|
|
290
|
+
keep(ruby, this, &this.core, Held::poll, |note| {
|
|
291
|
+
note.map(|note| classes.notification(ruby, note))
|
|
292
|
+
.transpose()
|
|
293
|
+
})
|
|
294
|
+
}
|
|
295
|
+
|
|
296
|
+
/// Read into a buffer on the copy, then built, inside one [`keep`].
|
|
297
|
+
fn drain(ruby: &Ruby, this: Obj<Self>, max: Value) -> Result<RArray, Error> {
|
|
298
|
+
this.check_frozen()?;
|
|
299
|
+
let max = integer(max, "max")?;
|
|
300
|
+
let classes = answers::classes(ruby)?;
|
|
301
|
+
let room = room(max, WAITER_CAPACITY);
|
|
302
|
+
keep(
|
|
303
|
+
ruby,
|
|
304
|
+
this,
|
|
305
|
+
&this.core,
|
|
306
|
+
|core| {
|
|
307
|
+
let mut buffer = [Notification::default(); WAITER_CAPACITY];
|
|
308
|
+
let written = core.drain(&mut buffer[..room]);
|
|
309
|
+
(buffer, written)
|
|
310
|
+
},
|
|
311
|
+
|(buffer, written)| {
|
|
312
|
+
let notifications = ruby.ary_new_capa(written);
|
|
313
|
+
for note in buffer.iter().take(written) {
|
|
314
|
+
notifications.push(classes.notification(ruby, *note)?)?;
|
|
315
|
+
}
|
|
316
|
+
Ok(notifications)
|
|
317
|
+
},
|
|
318
|
+
)
|
|
319
|
+
}
|
|
320
|
+
|
|
321
|
+
fn age(ruby: &Ruby, this: &Self, key: Value, now: Value) -> Result<Option<Integer>, Error> {
|
|
322
|
+
let (key, now) = (integer(key, "key")?, instant(now, "now")?);
|
|
323
|
+
let age = this.core.borrow().age(key, now);
|
|
324
|
+
Ok(age.map(|age| nanoseconds(ruby, age)))
|
|
325
|
+
}
|
|
326
|
+
|
|
327
|
+
fn state(ruby: &Ruby, this: &Self, key: Value, now: Value) -> Result<Option<Symbol>, Error> {
|
|
328
|
+
let (key, now) = (integer(key, "key")?, instant(now, "now")?);
|
|
329
|
+
let state = this.core.borrow().state(key, now);
|
|
330
|
+
Ok(state.map(|state| state_name(ruby, state)))
|
|
331
|
+
}
|
|
332
|
+
|
|
333
|
+
fn stale_if_error(
|
|
334
|
+
ruby: &Ruby,
|
|
335
|
+
this: &Self,
|
|
336
|
+
key: Value,
|
|
337
|
+
now: Value,
|
|
338
|
+
) -> Result<Option<Integer>, Error> {
|
|
339
|
+
let (key, now) = (integer(key, "key")?, instant(now, "now")?);
|
|
340
|
+
let age = this.core.borrow().stale_if_error(key, now);
|
|
341
|
+
Ok(age.map(|age| nanoseconds(ruby, age)))
|
|
342
|
+
}
|
|
343
|
+
|
|
344
|
+
fn leading(&self, key: Value) -> Result<Option<u64>, Error> {
|
|
345
|
+
let key = integer(key, "key")?;
|
|
346
|
+
Ok(self.core.borrow().leading(key).map(Lease::raw))
|
|
347
|
+
}
|
|
348
|
+
|
|
349
|
+
fn flight(ruby: &Ruby, this: &Self, lease: Value) -> Result<Option<u64>, Error> {
|
|
350
|
+
let lease = lease_id(ruby, integer(lease, "lease")?)?;
|
|
351
|
+
Ok(this.core.borrow().flight(lease).map(FlightId::raw))
|
|
352
|
+
}
|
|
353
|
+
|
|
354
|
+
fn now(ruby: &Ruby, this: &Self) -> Integer {
|
|
355
|
+
nanoseconds(ruby, this.core.borrow().now())
|
|
356
|
+
}
|
|
357
|
+
|
|
358
|
+
fn size(&self) -> usize {
|
|
359
|
+
self.core.borrow().len()
|
|
360
|
+
}
|
|
361
|
+
|
|
362
|
+
fn is_empty(&self) -> bool {
|
|
363
|
+
self.core.borrow().is_empty()
|
|
364
|
+
}
|
|
365
|
+
|
|
366
|
+
fn in_flight(&self) -> usize {
|
|
367
|
+
self.core.borrow().in_flight()
|
|
368
|
+
}
|
|
369
|
+
|
|
370
|
+
fn waiting(&self) -> usize {
|
|
371
|
+
self.core.borrow().waiting()
|
|
372
|
+
}
|
|
373
|
+
|
|
374
|
+
fn pending(&self) -> usize {
|
|
375
|
+
self.core.borrow().pending()
|
|
376
|
+
}
|
|
377
|
+
|
|
378
|
+
const fn capacity() -> usize {
|
|
379
|
+
KEY_CAPACITY
|
|
380
|
+
}
|
|
381
|
+
|
|
382
|
+
const fn flight_capacity() -> usize {
|
|
383
|
+
FLIGHT_CAPACITY
|
|
384
|
+
}
|
|
385
|
+
|
|
386
|
+
const fn waiter_capacity() -> usize {
|
|
387
|
+
WAITER_CAPACITY
|
|
388
|
+
}
|
|
389
|
+
}
|