@mark1russell7/service 0.5.20 → 0.6.1
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.
- package/README.md +22 -2
- package/build/{builder-CfbN_nDW.d.ts → builder-BNAkpeTT.d.ts} +2 -2
- package/build/{core-C8HD1stw.d.ts → core-CWsGgr9J.d.ts} +2 -2
- package/build/{dial-Bqx5jRXQ.d.ts → dial-JEJavY0U.d.ts} +2 -2
- package/build/grpc.d.ts +2 -2
- package/build/http-client.d.ts +2 -2
- package/build/index.d.ts +45 -136
- package/build/index.js +153 -69
- package/build/index.js.map +1 -1
- package/build/mongodb.d.ts +2 -2
- package/build/pg.d.ts +1 -1
- package/build/{queue-CQcMTKYX.d.ts → queue-eLs5IruM.d.ts} +2 -2
- package/build/rabbitmq.d.ts +3 -3
- package/build/redis.d.ts +1 -1
- package/build/redis.js.map +1 -1
- package/build/rules-BBRopO1e.d.ts +145 -0
- package/build/rules.d.ts +2 -0
- package/build/rules.js +128 -0
- package/build/rules.js.map +1 -0
- package/build/testing.d.ts +1 -1
- package/build/websocket.d.ts +2 -2
- package/package.json +6 -2
package/build/index.js
CHANGED
|
@@ -5,6 +5,7 @@ import { n as operationProblems, t as mayReissue } from "./operation-DL5RxFds.js
|
|
|
5
5
|
import { a as limiterProblems, i as limitRule, n as freeAt, o as longestRetryAfter, r as idleSpan, s as retryAfterSeconds, t as decide } from "./policy-CgS4y94U.js";
|
|
6
6
|
import { a as lateHolds, l as takeOutside, n as countOf, r as millisecondsOf, s as ownStream, t as boundedMillisecondsOf } from "./knobs-D2ClI68I.js";
|
|
7
7
|
import { backoffBand, backoffDelay, backoffProblems } from "./backoff.js";
|
|
8
|
+
import { DRAIN_RULES, O04, O09, O10, O16 } from "./rules.js";
|
|
8
9
|
import { a as keyedLimiter, i as limiterStateOf, n as TOKEN_BUCKET_MACHINE, o as memoryStore, r as limiterMachine, t as SLIDING_WINDOW_MACHINE } from "./limiter-pkBZUp-t.js";
|
|
9
10
|
import { convertExact, convertible, quantity, rationals, valueIn } from "@mark1russell7/quantity";
|
|
10
11
|
import { replay } from "@mark1russell7/algebra/replay";
|
|
@@ -1193,23 +1194,13 @@ const retryOf = (knobs, owner) => {
|
|
|
1193
1194
|
return backoff;
|
|
1194
1195
|
};
|
|
1195
1196
|
/**
|
|
1196
|
-
* This function gives the problems of
|
|
1197
|
-
*
|
|
1197
|
+
* This function gives the problems of a loop in a declaration: each phase that the loop needs and
|
|
1198
|
+
* that the declaration does not give. A loop closes in `close transports`, and it ends its units in
|
|
1199
|
+
* `drain`. `lint()` compares the bounds with the caps of the phases (`BOUND_RULES`, S6 A10).
|
|
1198
1200
|
*/
|
|
1199
|
-
const boundProblems = (owner,
|
|
1200
|
-
const
|
|
1201
|
-
|
|
1202
|
-
return phase === void 0 ? void 0 : valueIn(phase.cap, "ms");
|
|
1203
|
-
};
|
|
1204
|
-
const found = [];
|
|
1205
|
-
const close = capOf("close transports");
|
|
1206
|
-
if (close === void 0) found.push(`${owner} needs the phase "close transports" to close`);
|
|
1207
|
-
else if (closeBound >= close) found.push(`the close_bound of ${owner}, ${closeBound} ms, does not fit in the cap of "close transports", ${close} ms`);
|
|
1208
|
-
const drain = capOf("drain");
|
|
1209
|
-
if (drain === void 0) found.push(`${owner} needs the phase "drain" to end its units`);
|
|
1210
|
-
else if (!Number.isFinite(unitBound)) found.push(`the unit_processing_time of ${owner} has no bound, thus the drain can cut a unit at its cap of ${drain} ms`);
|
|
1211
|
-
else if (unitBound >= drain) found.push(`the unit_processing_time of ${owner}, ${unitBound} ms, does not fit in the cap of "drain", ${drain} ms`);
|
|
1212
|
-
return found;
|
|
1201
|
+
const boundProblems = (owner, description) => {
|
|
1202
|
+
const has = (name) => description.shutdown.phases.some((each) => each.name === name);
|
|
1203
|
+
return [...has("close transports") ? [] : [`${owner} needs the phase "close transports" to close`], ...has("drain") ? [] : [`${owner} needs the phase "drain" to end its units`]];
|
|
1213
1204
|
};
|
|
1214
1205
|
//#endregion
|
|
1215
1206
|
//#region src/requests.ts
|
|
@@ -2694,6 +2685,12 @@ const serviceBindings = (svc, scenario) => {
|
|
|
2694
2685
|
set("cooperative_window@process", boundOf(svc.shutdown.cooperativeWindow), "the declared cooperative window");
|
|
2695
2686
|
const hold = svc.shutdown.phases.find((phase) => phase.name === "fail readiness");
|
|
2696
2687
|
set("readiness_hold@process", hold === void 0 ? 0 : secondsOf(hold.cap), hold === void 0 ? "no fail readiness phase: the intake stops at once after the signal" : "the cap of the fail readiness phase, which holds while the endpoints update");
|
|
2688
|
+
const capOf = (name) => {
|
|
2689
|
+
const phase = svc.shutdown.phases.find((each) => each.name === name);
|
|
2690
|
+
return phase === void 0 ? void 0 : secondsOf(phase.cap);
|
|
2691
|
+
};
|
|
2692
|
+
set("drain_phase_cap@process", capOf("drain"), "the cap of the drain phase alone");
|
|
2693
|
+
set("close_phase_cap@process", capOf("close transports"), "the cap of the close transports phase alone");
|
|
2697
2694
|
bindScenario(scenario.platform, (symbol) => symbol, bind, epochs);
|
|
2698
2695
|
for (const [symbol, epoch] of Object.entries(epochs)) if (bind[symbol] === void 0) delete from[symbol];
|
|
2699
2696
|
else from[symbol] = epoch === null ? "the scenario" : `the scenario, for ${epoch}`;
|
|
@@ -2716,16 +2713,19 @@ const dependencyBindings = (dependency, scenario) => {
|
|
|
2716
2713
|
};
|
|
2717
2714
|
/**
|
|
2718
2715
|
* These are the hops of the law at which the knobs of a transport bind, by its kind. A worker does
|
|
2719
|
-
* its units as a consumer does, thus both bind at `consumer` (O20). A server binds at
|
|
2716
|
+
* its units as a consumer does, thus both bind at `consumer` (O20). A server binds at `server`, in a
|
|
2717
|
+
* scope of its own. In the scope of a dependency, `@server` is the server of that dependency. Thus
|
|
2718
|
+
* the knobs of a server of the service do not bind there, or O19 pairs the wrong two sides.
|
|
2720
2719
|
*/
|
|
2721
2720
|
const TRANSPORT_HOPS = {
|
|
2722
|
-
server:
|
|
2721
|
+
server: "server",
|
|
2723
2722
|
consumer: "consumer",
|
|
2724
2723
|
worker: "consumer"
|
|
2725
2724
|
};
|
|
2726
2725
|
/**
|
|
2727
2726
|
* This function gives the time knobs of a transport at the hop of its kind, and the values of the
|
|
2728
|
-
* scenario for
|
|
2727
|
+
* scenario for the transport. These values are of the source of a consumer, or of the clients of a
|
|
2728
|
+
* server. A knob with a hop in its name binds at that hop. A count binds no symbol.
|
|
2729
2729
|
*/
|
|
2730
2730
|
const transportBindings = (transport, hop, scenario) => {
|
|
2731
2731
|
const bind = {};
|
|
@@ -2760,6 +2760,7 @@ const limiterBindings = (limiter, scenario) => {
|
|
|
2760
2760
|
};
|
|
2761
2761
|
};
|
|
2762
2762
|
const SCOPED = /@(client|dependency|server)$/;
|
|
2763
|
+
const SERVER_SCOPED = /@server$/;
|
|
2763
2764
|
const TRANSPORT_SCOPED = /@consumer$/;
|
|
2764
2765
|
const LIMITER_SCOPED = /@(limiter|caller)$/;
|
|
2765
2766
|
/** This identifier is the rule of the findings about a field that the declaration does not give. */
|
|
@@ -2778,6 +2779,29 @@ const declarationFindings = (svc) => svc.shutdown.onRepeatSignal === void 0 ? [{
|
|
|
2778
2779
|
evaluated: [],
|
|
2779
2780
|
unbound: ["shutdown.onRepeatSignal"]
|
|
2780
2781
|
}] : [];
|
|
2782
|
+
/** This identifier is the rule of the findings for two parts that have one name in the scopes of a rule. */
|
|
2783
|
+
const NAME_RULE = "unique-names";
|
|
2784
|
+
/**
|
|
2785
|
+
* This function gives a finding for each name that two parts share in one set of scopes. A rule
|
|
2786
|
+
* about a client applies to each dependency and each server transport. A rule about a consumer
|
|
2787
|
+
* applies to each consumer and each worker, and a rule about a limiter to each limiter. Two parts
|
|
2788
|
+
* with one name in a set give findings with one scope, thus a reader cannot tell them apart.
|
|
2789
|
+
*/
|
|
2790
|
+
const nameFindings = (svc) => {
|
|
2791
|
+
return [
|
|
2792
|
+
["the dependencies and the server transports", [...svc.dependencies.map((each) => each.name), ...svc.transports.filter((each) => each.kind === "server").map((each) => each.name)]],
|
|
2793
|
+
["the consumers and the workers", svc.transports.filter((each) => each.kind !== "server").map((each) => each.name)],
|
|
2794
|
+
["the limiters", (svc.limiters ?? []).map((each) => each.name)]
|
|
2795
|
+
].flatMap(([set, names]) => [...new Set(names.filter((name, index) => names.indexOf(name) !== index))].map((name) => ({
|
|
2796
|
+
rule: NAME_RULE,
|
|
2797
|
+
scope: name,
|
|
2798
|
+
verdict: "violated",
|
|
2799
|
+
statement: `each of ${set} has a name of its own`,
|
|
2800
|
+
window: `two parts have the name ${name}, thus their findings have one scope`,
|
|
2801
|
+
evaluated: [],
|
|
2802
|
+
unbound: []
|
|
2803
|
+
})));
|
|
2804
|
+
};
|
|
2781
2805
|
/** This identifier is the rule of the findings about the stall time of a progress check (`Check.marks`). */
|
|
2782
2806
|
const PROGRESS_RULE = "progress";
|
|
2783
2807
|
/**
|
|
@@ -2907,7 +2931,65 @@ const progressFindings = (svc) => {
|
|
|
2907
2931
|
}
|
|
2908
2932
|
return findings;
|
|
2909
2933
|
};
|
|
2910
|
-
/** This
|
|
2934
|
+
/** This identifier is the rule of the findings about the bound of a unit against the cap of the `drain` phase. */
|
|
2935
|
+
const UNIT_BOUND_RULE = "unit-bound";
|
|
2936
|
+
/** This identifier is the rule of the findings about the close bound against the cap of the `close transports` phase. */
|
|
2937
|
+
const CLOSE_BOUND_RULE = "close-bound";
|
|
2938
|
+
/**
|
|
2939
|
+
* These are the rules of the bounds of a loop. Each one applies one time for each consumer and
|
|
2940
|
+
* each worker (S6 A10, A11). `lint()` gives them, as it gives `PROGRESS_RULE`.
|
|
2941
|
+
* - unit-bound: `unit_processing_time` is less than the cap of the `drain` phase. Otherwise the
|
|
2942
|
+
* drain can cut a unit that ends in its bound. A unit without a bound violates the rule.
|
|
2943
|
+
* - close-bound: `close_bound` is less than the cap of the `close transports` phase. Otherwise the
|
|
2944
|
+
* phase can end before the loop closes.
|
|
2945
|
+
*
|
|
2946
|
+
* The corpus of the law (R3) does not have these rules, thus they have identifiers of the service,
|
|
2947
|
+
* not O-numbers. The symbols `drain_phase_cap@process` and `close_phase_cap@process` are the caps of
|
|
2948
|
+
* one phase. `process_drain_time@process` is the sum of the caps of all the phases. A phase that the
|
|
2949
|
+
* declaration does not give binds no symbol, thus its finding is `depends`.
|
|
2950
|
+
*/
|
|
2951
|
+
const BOUND_RULES = [{
|
|
2952
|
+
id: UNIT_BOUND_RULE,
|
|
2953
|
+
rule: "the bound of one unit of a consumer or a worker is less than the cap of the drain phase",
|
|
2954
|
+
window: "the drain can cut a unit that ends in its bound",
|
|
2955
|
+
expr: {
|
|
2956
|
+
lhs: { terms: [{
|
|
2957
|
+
knob: "unit_processing_time",
|
|
2958
|
+
coef: 1,
|
|
2959
|
+
at: "consumer"
|
|
2960
|
+
}] },
|
|
2961
|
+
op: "<",
|
|
2962
|
+
rhs: { terms: [{
|
|
2963
|
+
knob: "drain_phase_cap",
|
|
2964
|
+
coef: 1,
|
|
2965
|
+
at: "process"
|
|
2966
|
+
}] },
|
|
2967
|
+
margin: 0
|
|
2968
|
+
}
|
|
2969
|
+
}, {
|
|
2970
|
+
id: CLOSE_BOUND_RULE,
|
|
2971
|
+
rule: "the close bound of a consumer or a worker is less than the cap of the close transports phase",
|
|
2972
|
+
window: "the phase can end before the loop closes",
|
|
2973
|
+
expr: {
|
|
2974
|
+
lhs: { terms: [{
|
|
2975
|
+
knob: "close_bound",
|
|
2976
|
+
coef: 1,
|
|
2977
|
+
at: "consumer"
|
|
2978
|
+
}] },
|
|
2979
|
+
op: "<",
|
|
2980
|
+
rhs: { terms: [{
|
|
2981
|
+
knob: "close_phase_cap",
|
|
2982
|
+
coef: 1,
|
|
2983
|
+
at: "process"
|
|
2984
|
+
}] },
|
|
2985
|
+
margin: 0
|
|
2986
|
+
}
|
|
2987
|
+
}];
|
|
2988
|
+
/**
|
|
2989
|
+
* This function gives the scopes of a rule that reads these symbols: the service, each client, each
|
|
2990
|
+
* consumer and worker, or each limiter. A rule that reads a symbol at `server` applies to each client
|
|
2991
|
+
* and to each server transport. In the scope of a server, the scenario gives the client side.
|
|
2992
|
+
*/
|
|
2911
2993
|
const scopesOf = (svc, scenario, service, symbols) => {
|
|
2912
2994
|
const within = (name, scoped) => {
|
|
2913
2995
|
const bind = {
|
|
@@ -2924,10 +3006,8 @@ const scopesOf = (svc, scenario, service, symbols) => {
|
|
|
2924
3006
|
}
|
|
2925
3007
|
];
|
|
2926
3008
|
};
|
|
2927
|
-
|
|
2928
|
-
|
|
2929
|
-
return hop === null ? [] : [within(transport.name, transportBindings(transport, hop, scenario))];
|
|
2930
|
-
}) : symbols.some((symbol) => SCOPED.test(symbol)) ? svc.dependencies.map((dependency) => within(dependency.name, dependencyBindings(dependency, scenario))) : [[
|
|
3009
|
+
const transports = (hop) => svc.transports.filter((transport) => TRANSPORT_HOPS[transport.kind] === hop).map((transport) => within(transport.name, transportBindings(transport, hop, scenario)));
|
|
3010
|
+
return symbols.some((symbol) => LIMITER_SCOPED.test(symbol)) ? (svc.limiters ?? []).map((limiter) => within(limiter.name, limiterBindings(limiter, scenario))) : symbols.some((symbol) => TRANSPORT_SCOPED.test(symbol)) ? transports("consumer") : symbols.some((symbol) => SCOPED.test(symbol)) ? [...svc.dependencies.map((dependency) => within(dependency.name, dependencyBindings(dependency, scenario))), ...symbols.some((symbol) => SERVER_SCOPED.test(symbol)) ? transports("server") : []] : [[
|
|
2931
3011
|
svc.name,
|
|
2932
3012
|
service.bind,
|
|
2933
3013
|
service.epochs
|
|
@@ -2959,65 +3039,68 @@ const PLATFORM_MARKS = {
|
|
|
2959
3039
|
* This function tells which findings of `lint` a compression by k changes (E10). It scales the
|
|
2960
3040
|
* bindings of each scope by the marks. Thus a harness that runs the service k times faster learns
|
|
2961
3041
|
* the orderings that its run breaks. The unmarked symbols are the symbols of the rules with no mark.
|
|
3042
|
+
* It reads the rules that `lint` applies with their bindings: the service rules and `BOUND_RULES`.
|
|
2962
3043
|
*/
|
|
2963
3044
|
const compressionOf = (svc, scenario, rules, k, marks) => {
|
|
2964
3045
|
const service = serviceBindings(svc, scenario);
|
|
2965
3046
|
const changed = [];
|
|
2966
3047
|
const unmarked = /* @__PURE__ */ new Set();
|
|
2967
|
-
for (const rule of rules) {
|
|
2968
|
-
|
|
2969
|
-
for (const
|
|
2970
|
-
|
|
2971
|
-
|
|
2972
|
-
|
|
2973
|
-
|
|
2974
|
-
});
|
|
2975
|
-
for (const symbol of result.unmarked) unmarked.add(symbol);
|
|
2976
|
-
}
|
|
3048
|
+
for (const rule of [...rules.filter((each) => SERVICE_RULES.includes(each.id)), ...BOUND_RULES]) for (const [scope, bind] of scopesOf(svc, scenario, service, symbolsOf(rule))) {
|
|
3049
|
+
const result = compression([rule], bind, k, marks);
|
|
3050
|
+
for (const change of result.changed) changed.push({
|
|
3051
|
+
...change,
|
|
3052
|
+
scope
|
|
3053
|
+
});
|
|
3054
|
+
for (const symbol of result.unmarked) unmarked.add(symbol);
|
|
2977
3055
|
}
|
|
2978
3056
|
return {
|
|
2979
3057
|
changed,
|
|
2980
3058
|
unmarked: [...unmarked]
|
|
2981
3059
|
};
|
|
2982
3060
|
};
|
|
3061
|
+
/** This function gives the findings of one rule, one for each scope of the rule. */
|
|
3062
|
+
const findingsOf = (svc, scenario, service, rule) => {
|
|
3063
|
+
const symbols = symbolsOf(rule);
|
|
3064
|
+
return scopesOf(svc, scenario, service, symbols).map(([scope, bind, all]) => {
|
|
3065
|
+
const evaluated = evaluate(rule, bind);
|
|
3066
|
+
const epochs = epochsOf(symbols, all);
|
|
3067
|
+
return {
|
|
3068
|
+
rule: rule.id,
|
|
3069
|
+
scope,
|
|
3070
|
+
verdict: verdictOf(rule, bind, evaluated),
|
|
3071
|
+
statement: rule.rule,
|
|
3072
|
+
...rule.window !== void 0 ? { window: rule.window } : {},
|
|
3073
|
+
evaluated,
|
|
3074
|
+
unbound: symbols.filter((symbol) => bind[symbol] === void 0),
|
|
3075
|
+
...Object.values(epochs).some((epoch) => epoch !== null) ? { epochs } : {}
|
|
3076
|
+
};
|
|
3077
|
+
});
|
|
3078
|
+
};
|
|
2983
3079
|
/**
|
|
2984
3080
|
* This function applies each service rule to a declaration and a scenario. A rule applies one time
|
|
2985
|
-
* for the service, for each client, for each consumer and worker, or for each limiter.
|
|
2986
|
-
*
|
|
2987
|
-
*
|
|
3081
|
+
* for the service, for each client, for each consumer and worker, or for each limiter. It also
|
|
3082
|
+
* gives a finding for each necessary field that the description does not give (`DECLARATION_RULE`).
|
|
3083
|
+
* It gives a finding for each name that two parts share in the scopes of a rule (`NAME_RULE`). Each progress check
|
|
3084
|
+
* that names its loops also gets its findings (`PROGRESS_RULE`). The findings of the bounds of each
|
|
3085
|
+
* consumer and each worker come last (`BOUND_RULES`).
|
|
2988
3086
|
*/
|
|
2989
3087
|
const lint = (svc, scenario, rules) => {
|
|
2990
3088
|
const service = serviceBindings(svc, scenario);
|
|
2991
|
-
|
|
2992
|
-
|
|
2993
|
-
|
|
2994
|
-
|
|
2995
|
-
|
|
2996
|
-
|
|
2997
|
-
|
|
2998
|
-
findings.push({
|
|
2999
|
-
rule: rule.id,
|
|
3000
|
-
scope,
|
|
3001
|
-
verdict: verdictOf(rule, bind, evaluated),
|
|
3002
|
-
statement: rule.rule,
|
|
3003
|
-
...rule.window !== void 0 ? { window: rule.window } : {},
|
|
3004
|
-
evaluated,
|
|
3005
|
-
unbound: symbols.filter((symbol) => bind[symbol] === void 0),
|
|
3006
|
-
...Object.values(epochs).some((epoch) => epoch !== null) ? { epochs } : {}
|
|
3007
|
-
});
|
|
3008
|
-
}
|
|
3009
|
-
}
|
|
3010
|
-
return findings;
|
|
3089
|
+
return [
|
|
3090
|
+
...declarationFindings(svc),
|
|
3091
|
+
...nameFindings(svc),
|
|
3092
|
+
...progressFindings(svc),
|
|
3093
|
+
...rules.filter((rule) => SERVICE_RULES.includes(rule.id)).flatMap((rule) => findingsOf(svc, scenario, service, rule)),
|
|
3094
|
+
...BOUND_RULES.flatMap((rule) => findingsOf(svc, scenario, service, rule))
|
|
3095
|
+
];
|
|
3011
3096
|
};
|
|
3012
3097
|
//#endregion
|
|
3013
3098
|
//#region src/stops.ts
|
|
3014
|
-
/**
|
|
3015
|
-
|
|
3016
|
-
|
|
3017
|
-
|
|
3018
|
-
|
|
3019
|
-
"O16"
|
|
3020
|
-
];
|
|
3099
|
+
/**
|
|
3100
|
+
* These are the identifiers of the rules of the drain, from the data of the entry `./rules`. Each
|
|
3101
|
+
* way that a pod stops applies only its own rules of this set.
|
|
3102
|
+
*/
|
|
3103
|
+
const DRAIN_RULE_IDS = DRAIN_RULES.map((rule) => rule.id);
|
|
3021
3104
|
/**
|
|
3022
3105
|
* These are the four ways that a pod stops.
|
|
3023
3106
|
* - A deletion runs the preStop hook, then SIGTERM. The endpoints drop the pod at its deletion,
|
|
@@ -3075,14 +3158,15 @@ const STOP_RULE = "stop";
|
|
|
3075
3158
|
* This function applies the rules to a declaration for one way of stopping. A rule of the drain
|
|
3076
3159
|
* applies only when it guards that way. The other rules apply as `lint()` applies them. A way with
|
|
3077
3160
|
* no drain also gets a finding of `STOP_RULE` that depends. No rule bounds the time until the
|
|
3078
|
-
* kubelet finds the exit, and the work in flight is lost.
|
|
3161
|
+
* kubelet finds the exit, and the work in flight is lost. Such a way starts no phase, thus it gets no
|
|
3162
|
+
* finding of `BOUND_RULES`.
|
|
3079
3163
|
*/
|
|
3080
3164
|
const lintStop = (svc, scenario, rules, way) => {
|
|
3081
3165
|
const stop = STOPS[way];
|
|
3082
3166
|
const applies = rules.filter((rule) => !DRAIN_RULE_IDS.includes(rule.id) || stop.rules.includes(rule.id));
|
|
3083
3167
|
const findings = lint(svc, scenario, applies);
|
|
3084
3168
|
if (stop.drain) return findings;
|
|
3085
|
-
return [...findings, {
|
|
3169
|
+
return [...findings.filter((finding) => !BOUND_RULES.some((rule) => rule.id === finding.rule)), {
|
|
3086
3170
|
rule: STOP_RULE,
|
|
3087
3171
|
scope: svc.name,
|
|
3088
3172
|
verdict: "depends",
|
|
@@ -3352,7 +3436,7 @@ const workerLoop = (knobs, options) => {
|
|
|
3352
3436
|
return closing;
|
|
3353
3437
|
},
|
|
3354
3438
|
problems(description) {
|
|
3355
|
-
return boundProblems(OWNER$1,
|
|
3439
|
+
return boundProblems(OWNER$1, description);
|
|
3356
3440
|
}
|
|
3357
3441
|
};
|
|
3358
3442
|
};
|
|
@@ -3625,7 +3709,7 @@ const queueDrain = (knobs, options) => {
|
|
|
3625
3709
|
return closing;
|
|
3626
3710
|
},
|
|
3627
3711
|
problems(description) {
|
|
3628
|
-
return boundProblems(OWNER,
|
|
3712
|
+
return boundProblems(OWNER, description);
|
|
3629
3713
|
}
|
|
3630
3714
|
};
|
|
3631
3715
|
};
|
|
@@ -4079,6 +4163,6 @@ const MACHINES = {
|
|
|
4079
4163
|
watchdog: WATCHDOG_MACHINE
|
|
4080
4164
|
};
|
|
4081
4165
|
//#endregion
|
|
4082
|
-
export { DECLARATION_RULE, DRAIN_RULE_IDS, DURATION_FRACTIONS, EPISODES_KEPT, EXIT_MACHINE, EXIT_SIGNALS, FORMAT, GATE_MACHINE, LATCH_MACHINE, LAW_STATISTIC, LIMITER_RULES, LOG_LEVELS, MACHINES, PLATFORM_MARKS, POLLER_MACHINE, PROCESS_TRIGGERS, PROGRESS_RULE, SERVICE_RULES, SLIDING_WINDOW_MACHINE, STAGES, STOPS, STOP_RULE, TOKEN_BUCKET_MACHINE, WATCHDOG_MACHINE, WINDOW_MACHINE, asDebounce, asWindow, atLeast, backoffBand, backoffDelay, backoffProblems, capKnob, compress, compression, compressionOf, consoleLogger, cooperativeAbortAt, daemon, decide, detectionTime, drainMachine, embeddedProcess, ephemeral, evaluate, failSpan, freeAt, heartbeat, heartbeatDetection, idleSpan, inequalities, isExitCode, isExitSignal, isMessageShape, keyedLimiter, kubernetes, limitRule, limiterMachine, limiterProblems, limiterStateOf, lint, lintStop, localDev, logEvents, longestRetryAfter, matchesMessage, mayReissue, memoryStore, nodeProcess, platformClock, processPortOf, queueDrain, realClock, recoverSpan, redact, redeliverOnce, replay, retryAfterSeconds, service, serviceBindings, stageRank, symbolsOf, verdictOf, watchdog, workerLoop };
|
|
4166
|
+
export { BOUND_RULES, CLOSE_BOUND_RULE, DECLARATION_RULE, DRAIN_RULES, DRAIN_RULE_IDS, DURATION_FRACTIONS, EPISODES_KEPT, EXIT_MACHINE, EXIT_SIGNALS, FORMAT, GATE_MACHINE, LATCH_MACHINE, LAW_STATISTIC, LIMITER_RULES, LOG_LEVELS, MACHINES, NAME_RULE, O04, O09, O10, O16, PLATFORM_MARKS, POLLER_MACHINE, PROCESS_TRIGGERS, PROGRESS_RULE, SERVICE_RULES, SLIDING_WINDOW_MACHINE, STAGES, STOPS, STOP_RULE, TOKEN_BUCKET_MACHINE, UNIT_BOUND_RULE, WATCHDOG_MACHINE, WINDOW_MACHINE, asDebounce, asWindow, atLeast, backoffBand, backoffDelay, backoffProblems, capKnob, compress, compression, compressionOf, consoleLogger, cooperativeAbortAt, daemon, decide, detectionTime, drainMachine, embeddedProcess, ephemeral, evaluate, failSpan, freeAt, heartbeat, heartbeatDetection, idleSpan, inequalities, isExitCode, isExitSignal, isMessageShape, keyedLimiter, kubernetes, limitRule, limiterMachine, limiterProblems, limiterStateOf, lint, lintStop, localDev, logEvents, longestRetryAfter, matchesMessage, mayReissue, memoryStore, nodeProcess, platformClock, processPortOf, queueDrain, realClock, recoverSpan, redact, redeliverOnce, replay, retryAfterSeconds, service, serviceBindings, stageRank, symbolsOf, verdictOf, watchdog, workerLoop };
|
|
4083
4167
|
|
|
4084
4168
|
//# sourceMappingURL=index.js.map
|