-
Notifications
You must be signed in to change notification settings - Fork 3
Expand file tree
/
Copy pathdevbox-snapshots.ts
More file actions
221 lines (194 loc) · 7.3 KB
/
devbox-snapshots.ts
File metadata and controls
221 lines (194 loc) · 7.3 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
#!/usr/bin/env -S npm run tsn -T
/**
---
title: Devbox Snapshots (Suspend, Resume, Restore, Delete)
slug: devbox-snapshots
use_case: Upload a file to a devbox, preserve it across suspend and resume, create a disk snapshot, restore multiple devboxes from that snapshot, mutate each copy independently, and delete the snapshot when finished.
workflow:
- Create a source devbox
- Upload a file and mutate it into a shared baseline
- Suspend and resume the source devbox
- Create a disk snapshot from the resumed devbox
- Restore two additional devboxes from the same snapshot baseline
- Mutate the same file differently in each devbox to prove isolation
- Shutdown the devboxes and delete the snapshot
tags:
- devbox
- snapshot
- suspend
- resume
- files
- cleanup
prerequisites:
- RUNLOOP_API_KEY
run: yarn tsn -T examples/devbox-snapshots.ts
test: yarn test:examples
---
*/
import { RunloopSDK, toFile } from '@runloop/api-client';
import { wrapRecipe, runAsCli } from './_harness';
import type { Devbox, Snapshot } from '@runloop/api-client';
import type { RecipeContext, RecipeOutput } from './types';
function uniqueName(prefix: string): string {
return `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
}
const FILE_PATH = '/tmp/snapshot-demo.txt';
type FileReadableDevbox = {
file: {
read(params: { file_path: string }): Promise<string>;
};
};
async function readFileContents(devbox: FileReadableDevbox): Promise<string> {
return devbox.file.read({ file_path: FILE_PATH });
}
export async function recipe(ctx: RecipeContext): Promise<RecipeOutput> {
const { cleanup } = ctx;
const sdk = new RunloopSDK({
bearerToken: process.env['RUNLOOP_API_KEY'],
});
const resourcesCreated: string[] = [];
let sourceDevbox: Devbox | undefined;
let cloneA: Devbox | undefined;
let cloneB: Devbox | undefined;
let snapshot: Snapshot | undefined;
let sourceNeedsCleanup = false;
let cloneANeedsCleanup = false;
let cloneBNeedsCleanup = false;
let snapshotNeedsCleanup = false;
// The harness runs cleanup in LIFO order, so register snapshot cleanup first
// to ensure it runs after any live devboxes have been shut down.
cleanup.add('snapshot:baseline', async () => {
if (snapshotNeedsCleanup && snapshot) {
await snapshot.delete();
}
});
cleanup.add('devbox:source', async () => {
if (sourceNeedsCleanup && sourceDevbox) {
await sourceDevbox.shutdown();
}
});
cleanup.add('devbox:clone-a', async () => {
if (cloneANeedsCleanup && cloneA) {
await cloneA.shutdown();
}
});
cleanup.add('devbox:clone-b', async () => {
if (cloneBNeedsCleanup && cloneB) {
await cloneB.shutdown();
}
});
// Start from a single source devbox.
sourceDevbox = await sdk.devbox.create({
name: uniqueName('snapshot-source'),
launch_parameters: {
resource_size_request: 'X_SMALL',
},
});
sourceNeedsCleanup = true;
resourcesCreated.push(`devbox:${sourceDevbox.id}`);
const uploadedContents = 'uploaded-from-local-file';
const baselineContents = 'baseline-after-upload-and-mutation';
const sourceContents = 'source-devbox-after-isolated-mutation';
const cloneAContents = 'clone-a-after-isolated-mutation';
const cloneBContents = 'clone-b-after-isolated-mutation';
await sourceDevbox.file.upload({
path: FILE_PATH,
file: await toFile(Buffer.from(uploadedContents, 'utf8'), 'snapshot-demo.txt'),
});
const uploadedReadback = await readFileContents(sourceDevbox);
await sourceDevbox.file.write({
file_path: FILE_PATH,
contents: baselineContents,
});
// suspend & resume:
await sourceDevbox.suspend();
const suspendedInfo = await sourceDevbox.awaitSuspended();
const resumedInfo = await sourceDevbox.resume();
const resumedReadback = await readFileContents(sourceDevbox);
snapshot = await sourceDevbox.snapshotDisk({
name: uniqueName('snapshot-baseline'),
commit_message: 'Capture the shared baseline after suspend and resume.',
});
snapshotNeedsCleanup = true;
resourcesCreated.push(`snapshot:${snapshot.id}`);
// Restore two separate devboxes from the same baseline snapshot.
cloneA = await snapshot.createDevbox({
name: uniqueName('snapshot-clone-a'),
launch_parameters: {
resource_size_request: 'X_SMALL',
},
});
cloneANeedsCleanup = true;
resourcesCreated.push(`devbox:${cloneA.id}`);
cloneB = await sdk.devbox.createFromSnapshot(snapshot.id, {
name: uniqueName('snapshot-clone-b'),
launch_parameters: {
resource_size_request: 'X_SMALL',
},
});
cloneBNeedsCleanup = true;
resourcesCreated.push(`devbox:${cloneB.id}`);
const cloneABaselineReadback = await readFileContents(cloneA);
const cloneBBaselineReadback = await readFileContents(cloneB);
await sourceDevbox.file.write({ file_path: FILE_PATH, contents: sourceContents });
await cloneA.file.write({ file_path: FILE_PATH, contents: cloneAContents });
await cloneB.file.write({ file_path: FILE_PATH, contents: cloneBContents });
const sourceIsolatedReadback = await readFileContents(sourceDevbox);
const cloneAIsolatedReadback = await readFileContents(cloneA);
const cloneBIsolatedReadback = await readFileContents(cloneB);
await cloneB.shutdown();
cloneBNeedsCleanup = false;
await cloneA.shutdown();
cloneANeedsCleanup = false;
await sourceDevbox.shutdown();
sourceNeedsCleanup = false;
await snapshot.delete();
snapshotNeedsCleanup = false;
return {
resourcesCreated,
checks: [
{
name: 'uploaded file is readable on the source devbox',
passed: uploadedReadback === uploadedContents,
details: uploadedReadback,
},
{
name: 'suspend reaches the suspended state',
passed: suspendedInfo.status === 'suspended',
details: `status=${suspendedInfo.status}`,
},
{
name: 'resume preserves the baseline file contents',
passed: resumedInfo.status === 'running' && resumedReadback === baselineContents,
details: `status=${resumedInfo.status}, contents=${resumedReadback}`,
},
{
name: 'multiple devboxes can use the same snapshot baseline',
passed: cloneABaselineReadback === baselineContents && cloneBBaselineReadback === baselineContents,
details: `cloneA=${cloneABaselineReadback}, cloneB=${cloneBBaselineReadback}`,
},
{
name: 'devboxes diverge after isolated mutations',
passed:
sourceIsolatedReadback === sourceContents &&
cloneAIsolatedReadback === cloneAContents &&
cloneBIsolatedReadback === cloneBContents,
details: `source=${sourceIsolatedReadback}, cloneA=${cloneAIsolatedReadback}, cloneB=${cloneBIsolatedReadback}`,
},
{
name: 'snapshot-backed devboxes stay isolated from one another',
passed: new Set([sourceIsolatedReadback, cloneAIsolatedReadback, cloneBIsolatedReadback]).size === 3,
details: `values=${JSON.stringify([sourceIsolatedReadback, cloneAIsolatedReadback, cloneBIsolatedReadback])}`,
},
{
name: 'snapshot can be deleted after the demo finishes',
passed: !snapshotNeedsCleanup,
details: `deleted=${String(!snapshotNeedsCleanup)}`,
},
],
};
}
export const runDevboxSnapshotsExample = wrapRecipe({ recipe });
if (require.main === module) {
void runAsCli(runDevboxSnapshotsExample);
}