Repository navigation
Expand file tree
/
Copy pathrollback_cli.rs
More file actions
223 lines (207 loc) · 10.6 KB
/
Copy pathrollback_cli.rs
File metadata and controls
223 lines (207 loc) · 10.6 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
//! `obc data rollback TARGET`: make a target serve its rollback release again. The release that
//! served becomes the rollback, so a second rollback undoes the first. It bakes, uploads and
//! deletes nothing: the next update collects.
use std::path::Path;
use clap::Args;
use schemars::JsonSchema;
use serde::Serialize;
use super::{print_json, update_cli, Code, Error};
use crate::engine::runs::{Event, Phase, Run};
use crate::fetch::http::Http;
use crate::lock::Held;
use crate::store::Store;
use crate::target::Target;
use crate::{ready, release};
#[derive(Args)]
pub struct RollbackArgs {
/// The target, as `data/targets.toml` names it.
target: String,
/// Roll back only when the rollback release has this id, or an id that starts with these 12 or
/// more hex digits, so a release published since it was read is not the one that goes.
#[arg(long, value_name = "ID")]
expect: Option<String>,
/// Do not ask before the rollback of an R2 target. Required without a terminal.
#[arg(long)]
yes: bool,
}
/// What a rollback did.
#[derive(Debug, Serialize, JsonSchema)]
pub struct RolledBack {
pub run: String,
pub target: String,
/// The release that the target serves now: its rollback before.
pub serving: String,
/// The release that it served before.
pub rollback: String,
}
pub fn command(root: &Path, args: RollbackArgs, json: bool) -> Result<(), Error> {
let store = Store::open()?;
let target = crate::target::find(root, &args.target, &store).map_err(|e| Code::Usage.error(e))?;
super::api::writable(&args.target, &target, true)?;
if let Target::R2(remote) = &target {
let question = format!("Serve the rollback release of `{}` ({}) to riders again?", args.target, remote.url(""));
super::confirm(&question, args.yes)?;
}
let mut run = super::api::start_run(&store, &["rollback", &args.target])?;
let follower = matches!(target, Target::R2(_));
let result = rollback(&store, (&args.target, &target), args.expect.as_deref(), &mut run, follower);
let rolled = super::api::finish_run(run, result)?;
if json {
return print_json(&rolled);
}
println!("{} serves release {}; rollback {}", rolled.target, &rolled.serving[..12], &rolled.rollback[..12]);
Ok(())
}
/// Switch `target` to its rollback release, after a check that the target has each of its keys
/// and, with `follower`, as for an R2 target, that the follower of the target serves its planner
/// release, while the run holds the lock of the target.
pub(super) fn rollback(
store: &Store,
(name, target): (&str, &Target),
expect: Option<&str>,
run: &mut Run,
follower: bool,
) -> Result<RolledBack, Error> {
update_cli::locked(store, (name, target), run, |run, held| {
let rolled = switch((name, target, store), expect, (run, held), follower)?;
Ok(RolledBack { run: run.id().into(), target: name.into(), serving: rolled.0, rollback: rolled.1 })
})
}
/// The switch of a rollback: the release that the target serves now, and its rollback.
fn switch(
(name, target, store): (&str, &Target, &Store),
expect: Option<&str>,
(run, held): (&mut Run, &Held),
follower: bool,
) -> Result<(String, String), Error> {
let base = release::serving(target)?.ok_or_else(|| {
Code::Usage
.error(format!("target `{name}` serves no release"))
.fix(format!("Run `obc data update {name} --region ID` first."))
})?;
let Some(rollback) = base.0.rollback.clone() else {
return Err(Code::Usage.error(format!("target `{name}` has no rollback release")).fix(format!(
"An update of `{name}` that publishes a new release keeps the release before as the rollback."
)));
};
if let Some(expect) = expect.filter(|expect| expect.len() < 12 || !rollback.id.starts_with(expect)) {
return Err(Code::Blocked
.error(format!("the rollback release of `{name}` is {}, not {expect}; nothing changed", &rollback.id[..12]))
.fix(format!("Run `obc data` to see what `{name}` serves now.")));
}
update_cli::enter((run, held), name, Phase::Verify)?;
let release = update_cli::read(name, target, &rollback.id)?;
let short = &rollback.id[..12];
let lacks = |e: String| {
let fix = format!("Run `obc data update {name}` to publish again.");
Code::VerifyFailed.error(format!("release {short}: {e}; nothing changed")).fix(fix)
};
let files = release.load(release::in_store(&store.reading(target))).map_err(lacks)?;
let files: Vec<(String, u64)> = files.files().into_iter().map(|file| (file.key, file.size)).collect();
let missing = target.missing(&files)?;
if let Some(key) = missing.first() {
return Err(Code::VerifyFailed
.error(format!(
"the target lacks {} keys of release {short}, such as {key}; nothing changed",
missing.len()
))
.fix(format!("Run `obc data update {name}` to publish again.")));
}
// The follower keeps the planner release of the rollback running, so one answer says enough.
if follower {
let url =
ready::url(target, &rollback.id).map_err(|e| Code::Failed.error(format!("the rollback release: {e}")))?;
if let Some(reason) = ready::ask(&Http::new(), &url) {
let short = &rollback.id[..12];
return Err(Code::Blocked
.error(format!("the follower of `{name}` does not serve release {short}: {reason}; nothing changed"))
.fix(format!("Read the log of `obc data serve {name}` where it runs, then run the rollback again.")));
}
}
update_cli::enter((run, held), name, Phase::Switch)?;
if !release::switch(target, Some(&base), &rollback.id)? {
return Err(Code::Failed
.error(format!("release.json of `{name}` changed during the rollback; nothing switched"))
.fix(format!("Run `obc data` to see what `{name}` serves now.")));
}
run.record(&Event::Switched { release: rollback.id.clone() })?;
run.sync()?;
Ok((rollback.id, base.0.serving.id))
}
#[cfg(test)]
mod tests {
use super::*;
use crate::cli::update_cli::tests::{region, update};
use crate::engine::tests::fixture;
use crate::release::Release;
fn rollback(
fixture: &crate::engine::tests::Fixture,
target: &Target,
expect: Option<&str>,
) -> Result<RolledBack, Error> {
let mut run = Run::create(&fixture.store, ["rollback", "local"]).unwrap();
let rolled = super::rollback(&fixture.store, ("local", target), expect, &mut run, false);
crate::cli::api::finish_run(run, rolled)
}
#[test]
fn a_rollback_swaps_the_serving_and_the_rollback_release_and_deletes_nothing() {
let fixture = fixture("rollback");
fixture.with_sources(&[]);
let target = Target::Dir(fixture.scratch.0.join("local"));
let a = update(&fixture, &target, region).unwrap().serving;
let refused = rollback(&fixture, &target, None).unwrap_err();
assert_eq!((refused.code, refused.message.as_str()), (Code::Usage, "target `local` has no rollback release"));
fixture.fetched_version("head", "2", "head.txt", b"newer\n");
let b = update(&fixture, &target, |_| Ok(())).unwrap().serving;
let keys = || target.list().unwrap().into_iter().map(|listed| listed.key).collect::<Vec<_>>();
let before = keys();
// A rollback that expects another release than the rollback changes nothing.
let json = || target.get(release::SERVING).unwrap().unwrap();
let read = json();
let refused = rollback(&fixture, &target, Some(&b[..12])).unwrap_err();
assert_eq!(refused.code, Code::Blocked, "{}", refused.message);
assert_eq!(json(), read);
for (serving, rollback_id, expect) in [(&a, &b, &a[..]), (&b, &a, &b[..12])] {
let rolled = rollback(&fixture, &target, Some(expect)).unwrap();
assert_eq!((&rolled.serving, &rolled.rollback), (serving, rollback_id));
let now = release::serving(&target).unwrap().unwrap().0;
assert_eq!((&now.serving.id, now.rollback.map(|role| role.id).as_ref()), (serving, Some(rollback_id)));
assert!(release::drift(&target, &Release::read(&target, serving).unwrap()).unwrap().is_empty());
assert_eq!(keys(), before, "a rollback deletes nothing");
}
// The rollback release lacks a key: nothing switches.
let files = |id: &str| {
let store = fixture.store.reading(&target);
let files = Release::read(&target, id).unwrap().load(release::in_store(&store)).unwrap();
files.files().into_iter().map(|file| file.key)
};
let only_a = files(&a).find(|key| !files(&b).any(|other| other == *key)).unwrap();
target.remove(&only_a).unwrap();
let refused = rollback(&fixture, &target, None).unwrap_err();
assert_eq!(refused.code, Code::VerifyFailed, "{}", refused.message);
assert_eq!(release::serving(&target).unwrap().unwrap().0.serving.id, b);
}
#[test]
fn an_r2_rollback_whose_planner_release_the_follower_does_not_serve_is_refused() {
let fixture = fixture("rollback-ready");
let dir = fixture.scratch.0.join("local");
let target = Target::Dir(dir.clone());
let runtime = tokio::runtime::Runtime::new().unwrap();
let failed = r#"{"state":"failed","reason":"not ready: the search service stopped: exit status 1"}"#;
let (api, asked) = crate::cli::update_cli::tests::follower(&runtime, &dir, &[(503, failed)]);
let (a, _) = crate::serve::tests::release_at(&target, "device a", b"routing a", 1, &api);
let (b, _) = crate::serve::tests::release_at(&target, "device b", b"routing b", 1, &api);
for id in [&a, &b] {
assert!(release::switch(&target, release::serving(&target).unwrap().as_ref(), id).unwrap());
}
let before = std::fs::read(dir.join(release::SERVING)).unwrap();
let mut run = Run::create(&fixture.store, ["rollback", "local"]).unwrap();
let refused = super::rollback(&fixture.store, ("local", &target), None, &mut run, true);
let refused = crate::cli::api::finish_run(run, refused).unwrap_err();
assert_eq!(refused.code, Code::Blocked);
let reason = "not ready: the search service stopped: exit status 1; nothing changed";
assert!(refused.message.ends_with(reason), "{}", refused.message);
assert_eq!(asked.lock().unwrap().len(), 1, "one answer, for the rollback release {a}");
assert_eq!(std::fs::read(dir.join(release::SERVING)).unwrap(), before);
}
}