Skip to content

Commit 2a3e14c

Browse files
committed
fix(ssh): bind legacy cleanup to prepared targets
1 parent 5617e27 commit 2a3e14c

2 files changed

Lines changed: 395 additions & 64 deletions

File tree

‎packages/ssh/src/tunnel.test.ts‎

Lines changed: 295 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -875,9 +875,19 @@ describe("ssh tunnel scripts", () => {
875875
}).pipe(Effect.provide(NodeServices.layer), Effect.scoped),
876876
);
877877

878-
it.effect.each(["disconnect first", "resolve before disconnect", "failed stop"] as const)(
879-
"keeps cleanup bound to the connected host after alias routing changes: %s",
880-
(mode) => {
878+
it.effect.each([
879+
{ mode: "disconnect first", cleanup: "bootstrap" },
880+
{ mode: "resolve before disconnect", cleanup: "bootstrap" },
881+
{ mode: "failed stop", cleanup: "bootstrap" },
882+
{ mode: "disconnect first", cleanup: "legacy" },
883+
{ mode: "resolve before disconnect", cleanup: "legacy" },
884+
{ mode: "failed stop", cleanup: "legacy" },
885+
{ mode: "disconnect first", cleanup: "stale" },
886+
{ mode: "resolve before disconnect", cleanup: "stale" },
887+
{ mode: "failed stop", cleanup: "stale" },
888+
] as const)(
889+
"keeps cleanup bound to the connected host after alias routing changes: $mode / $cleanup",
890+
({ mode, cleanup }) => {
881891
let recovered = false;
882892
let resolutions = 0;
883893
let kills = 0;
@@ -915,21 +925,23 @@ describe("ssh tunnel scripts", () => {
915925
);
916926
return Effect.gen(function* () {
917927
const manager = yield* SshTunnel.SshEnvironmentManager;
918-
const connected = yield* manager.ensureEnvironment({
928+
const request = {
919929
alias: "devbox",
920-
hostname: "devbox",
930+
hostname: cleanup === "stale" ? "previous.example.com" : "devbox",
921931
username: null,
922932
port: null,
923-
});
933+
};
934+
const connected = yield* manager.ensureEnvironment(request);
935+
const cleanupTarget = cleanup === "bootstrap" ? connected.target : request;
924936
assert.equal(connected.target.hostname, "connected.example.com");
925937
recovered = true;
926938
if (mode === "resolve before disconnect") {
927939
assert.equal((yield* resolveSshTarget("devbox")).hostname, "other.example.com");
928940
}
929-
const result = yield* Effect.result(manager.disconnectEnvironment(connected.target));
941+
const result = yield* Effect.result(manager.disconnectEnvironment(cleanupTarget));
930942
if (mode === "failed stop") {
931943
assert.isTrue(Result.isFailure(result));
932-
yield* manager.disconnectEnvironment(connected.target);
944+
yield* manager.disconnectEnvironment(cleanupTarget);
933945
} else {
934946
assert.isTrue(Result.isSuccess(result));
935947
}
@@ -945,13 +957,276 @@ describe("ssh tunnel scripts", () => {
945957
},
946958
);
947959

960+
it.effect.each(["resolution", "pairing", "failed pairing", "failed launch"] as const)(
961+
"keeps cleanup bound while preparation is pending at %s",
962+
(stage) =>
963+
Effect.gen(function* () {
964+
const paused = yield* Deferred.make<void>();
965+
const resume = yield* Deferred.make<void>();
966+
const pause = Deferred.succeed(paused, undefined).pipe(
967+
Effect.andThen(Deferred.await(resume)),
968+
);
969+
let kills = 0;
970+
let resolutions = 0;
971+
const stops: Array<ReadonlyArray<string>> = [];
972+
const spawner = ChildProcessSpawner.make((command) =>
973+
Effect.sync(() => {
974+
const args = commandArgs(command);
975+
if (args.includes("-G")) {
976+
resolutions += 1;
977+
const result = makeSuccessfulProcess(
978+
`hostname ${resolutions === 1 ? "connected.example.com" : "other.example.com"}\nuser alice\nport 2222\n`,
979+
);
980+
return stage === "resolution"
981+
? { ...result, exitCode: pause.pipe(Effect.andThen(result.exitCode)) }
982+
: result;
983+
}
984+
if (args.includes("-N"))
985+
return makeRunningProcess(() => {
986+
kills += 1;
987+
});
988+
if (args.some((arg, index) => arg === "-s" && args[index + 1] === "--")) {
989+
const result = makeSuccessfulProcess('{"remotePort":3773}\n');
990+
return stage === "failed launch"
991+
? { ...result, exitCode: pause.pipe(Effect.as(ChildProcessSpawner.ExitCode(1))) }
992+
: result;
993+
}
994+
if (args.some((arg) => arg.startsWith("HostName="))) {
995+
stops.push(args);
996+
return makeSuccessfulProcess('{"stopped":true}\n');
997+
}
998+
const result = makeSuccessfulProcess('{"credential":"pairing-token"}\n');
999+
return {
1000+
...result,
1001+
exitCode: pause.pipe(
1002+
Effect.as(ChildProcessSpawner.ExitCode(stage === "failed pairing" ? 1 : 0)),
1003+
),
1004+
};
1005+
}),
1006+
);
1007+
const layer = Layer.mergeAll(
1008+
NodeServices.layer,
1009+
Layer.succeed(ChildProcessSpawner.ChildProcessSpawner, spawner),
1010+
Layer.succeed(HttpClient.HttpClient, testHttpClient),
1011+
Layer.succeed(NetService.NetService, testNetService),
1012+
SshAuth.SshPasswordPrompt.disabledLayer,
1013+
SshTunnel.SshEnvironmentManager.layer({ resolveCliRunner: Effect.succeed(ARCHIVE) }),
1014+
);
1015+
yield* Effect.gen(function* () {
1016+
const manager = yield* SshTunnel.SshEnvironmentManager;
1017+
const request = { alias: "devbox", hostname: "devbox", username: null, port: null };
1018+
const preparing = yield* Effect.forkChild(
1019+
Effect.result(
1020+
manager.ensureEnvironment(request, {
1021+
issuePairingToken: stage !== "resolution",
1022+
}),
1023+
),
1024+
);
1025+
yield* Deferred.await(paused);
1026+
const stopping = yield* Effect.forkChild(manager.disconnectEnvironment(request), {
1027+
startImmediately: true,
1028+
});
1029+
yield* TestClock.adjust(Duration.zero);
1030+
const stopsWhilePreparing = stops.length;
1031+
yield* Deferred.succeed(resume, undefined);
1032+
const prepared = yield* Fiber.join(preparing);
1033+
yield* Fiber.join(stopping);
1034+
assert.equal(stopsWhilePreparing, 0);
1035+
assert.equal(
1036+
prepared._tag,
1037+
stage === "failed pairing" || stage === "failed launch" ? "Failure" : "Success",
1038+
);
1039+
assert.equal(kills, stage === "failed launch" ? 0 : 1);
1040+
assert.equal(resolutions, 1);
1041+
assert.equal(stops.length, 1);
1042+
assert.include(stops[0]!, "HostName=connected.example.com");
1043+
assert.include(stops[0]!, "alice@devbox");
1044+
}).pipe(
1045+
Effect.ensuring(Deferred.succeed(resume, undefined)),
1046+
Effect.provide(layer),
1047+
Effect.scoped,
1048+
);
1049+
}),
1050+
);
1051+
1052+
it.effect.each([
1053+
"original request",
1054+
"persisted bootstrap",
1055+
"failed first stop",
1056+
"canonical before legacy",
1057+
] as const)(
1058+
"keeps cleanup bound to every host prepared for a request, not another alias: %s",
1059+
(nextRequest) =>
1060+
Effect.gen(function* () {
1061+
let recovered = nextRequest === "canonical before legacy";
1062+
const killed: string[] = [];
1063+
const stops: Array<ReadonlyArray<string>> = [];
1064+
const spawner = ChildProcessSpawner.make((command) =>
1065+
Effect.sync(() => {
1066+
const args = commandArgs(command);
1067+
if (args.includes("-G"))
1068+
return makeSuccessfulProcess(
1069+
`hostname ${recovered ? "second.example.com" : "first.example.com"}\nuser alice\nport 2222\n`,
1070+
);
1071+
if (args.includes("-N"))
1072+
return makeRunningProcess(() => {
1073+
killed.push(args.at(-1) ?? "");
1074+
});
1075+
if (args.some((arg, index) => arg === "-s" && args[index + 1] === "--")) {
1076+
return makeSuccessfulProcess('{"remotePort":3773}\n');
1077+
}
1078+
stops.push(args);
1079+
const result = makeSuccessfulProcess('{"stopped":true}\n');
1080+
return nextRequest === "failed first stop" && stops.length === 1
1081+
? { ...result, exitCode: Effect.succeed(ChildProcessSpawner.ExitCode(1)) }
1082+
: result;
1083+
}),
1084+
);
1085+
const layer = Layer.mergeAll(
1086+
NodeServices.layer,
1087+
Layer.succeed(ChildProcessSpawner.ChildProcessSpawner, spawner),
1088+
Layer.succeed(HttpClient.HttpClient, testHttpClient),
1089+
Layer.succeed(NetService.NetService, testNetService),
1090+
SshAuth.SshPasswordPrompt.disabledLayer,
1091+
SshTunnel.SshEnvironmentManager.layer({ resolveCliRunner: Effect.succeed(ARCHIVE) }),
1092+
);
1093+
yield* Effect.gen(function* () {
1094+
const manager = yield* SshTunnel.SshEnvironmentManager;
1095+
const request = { alias: "devbox", hostname: "devbox", username: null, port: null };
1096+
const initialRequest =
1097+
nextRequest === "canonical before legacy"
1098+
? { ...request, hostname: "first.example.com", username: "alice", port: 2222 }
1099+
: request;
1100+
const first = yield* manager.ensureEnvironment(initialRequest);
1101+
recovered = nextRequest !== "canonical before legacy";
1102+
const cleanupTarget =
1103+
nextRequest === "persisted bootstrap" ? first.target : initialRequest;
1104+
const second = yield* manager.ensureEnvironment(
1105+
nextRequest === "canonical before legacy" ? request : cleanupTarget,
1106+
);
1107+
recovered = true;
1108+
const other = yield* manager.ensureEnvironment({
1109+
...request,
1110+
alias: "other",
1111+
hostname: "other",
1112+
});
1113+
assert.equal(
1114+
first.target.hostname,
1115+
nextRequest === "canonical before legacy" ? "second.example.com" : "first.example.com",
1116+
);
1117+
assert.equal(
1118+
second.target.hostname,
1119+
nextRequest === "canonical before legacy" ? "first.example.com" : "second.example.com",
1120+
);
1121+
assert.equal(other.target.hostname, "second.example.com");
1122+
const anotherUser = yield* manager.ensureEnvironment({
1123+
...request,
1124+
username: "bob",
1125+
port: 3333,
1126+
});
1127+
assert.equal(anotherUser.target.username, "bob");
1128+
assert.equal(anotherUser.target.port, 3333);
1129+
const result = yield* Effect.result(manager.disconnectEnvironment(cleanupTarget));
1130+
assert.equal(result._tag, nextRequest === "failed first stop" ? "Failure" : "Success");
1131+
assert.deepEqual(killed, ["alice@devbox", "alice@devbox"]);
1132+
assert.equal(stops.length, 2);
1133+
assert.deepEqual(
1134+
stops.flatMap((args) => args.filter((arg) => arg.startsWith("HostName="))).toSorted(),
1135+
["HostName=first.example.com", "HostName=second.example.com"],
1136+
);
1137+
assert.include(stops[0]!, "alice@devbox");
1138+
assert.include(stops[1]!, "alice@devbox");
1139+
if (nextRequest === "failed first stop") {
1140+
yield* manager.disconnectEnvironment(cleanupTarget);
1141+
assert.equal(stops.length, 3);
1142+
assert.include(stops[2]!, "HostName=first.example.com");
1143+
assert.deepEqual(killed, ["alice@devbox", "alice@devbox"]);
1144+
}
1145+
}).pipe(Effect.provide(layer), Effect.scoped);
1146+
}),
1147+
);
1148+
1149+
it.effect.each([
1150+
"legacy",
1151+
"legacy failed stop",
1152+
"legacy failed resolution",
1153+
"canonical",
1154+
"canonical same name",
1155+
] as const)("cleans a cold %s profile without redirecting canonical targets", (profile) => {
1156+
const legacy = profile.startsWith("legacy");
1157+
let resolutions = 0;
1158+
const stops: Array<ReadonlyArray<string>> = [];
1159+
const spawner = ChildProcessSpawner.make((command) =>
1160+
Effect.sync(() => {
1161+
const args = commandArgs(command);
1162+
if (args.includes("-G")) {
1163+
resolutions += 1;
1164+
const result = makeSuccessfulProcess(
1165+
"hostname connected.example.com\nuser alice\nport 2222\n",
1166+
);
1167+
return profile === "legacy failed resolution" && resolutions === 1
1168+
? { ...result, exitCode: Effect.succeed(ChildProcessSpawner.ExitCode(1)) }
1169+
: result;
1170+
}
1171+
stops.push(args);
1172+
const result = makeSuccessfulProcess('{"stopped":true}\n');
1173+
return (profile === "legacy failed stop" || profile === "legacy failed resolution") &&
1174+
stops.length === 1
1175+
? { ...result, exitCode: Effect.succeed(ChildProcessSpawner.ExitCode(1)) }
1176+
: result;
1177+
}),
1178+
);
1179+
const layer = Layer.mergeAll(
1180+
NodeServices.layer,
1181+
Layer.succeed(ChildProcessSpawner.ChildProcessSpawner, spawner),
1182+
Layer.succeed(HttpClient.HttpClient, testHttpClient),
1183+
Layer.succeed(NetService.NetService, testNetService),
1184+
SshAuth.SshPasswordPrompt.disabledLayer,
1185+
SshTunnel.SshEnvironmentManager.layer(),
1186+
);
1187+
return Effect.gen(function* () {
1188+
const manager = yield* SshTunnel.SshEnvironmentManager;
1189+
const target = legacy
1190+
? { alias: "devbox", hostname: "devbox", username: null, port: null }
1191+
: {
1192+
alias: "devbox",
1193+
hostname: profile === "canonical same name" ? "devbox" : "saved.example.com",
1194+
username: "bob",
1195+
port: 3333,
1196+
};
1197+
const first = yield* Effect.result(manager.disconnectEnvironment(target));
1198+
assert.equal(
1199+
first._tag,
1200+
profile === "legacy failed stop" || profile === "legacy failed resolution"
1201+
? "Failure"
1202+
: "Success",
1203+
);
1204+
if (legacy) yield* manager.disconnectEnvironment(target);
1205+
assert.equal(resolutions, profile === "legacy failed resolution" ? 2 : legacy ? 1 : 0);
1206+
assert.equal(stops.length, legacy ? 2 : 1);
1207+
for (const args of profile === "legacy failed resolution" ? stops.slice(1) : stops)
1208+
assert.include(
1209+
args,
1210+
legacy
1211+
? "HostName=connected.example.com"
1212+
: profile === "canonical same name"
1213+
? "HostName=devbox"
1214+
: "HostName=saved.example.com",
1215+
);
1216+
assert.include(stops.at(-1)!, legacy ? "alice@devbox" : "bob@devbox");
1217+
assert.deepEqual(
1218+
stops.at(-1)!.slice(stops.at(-1)!.indexOf("-p"), stops.at(-1)!.indexOf("-p") + 2),
1219+
["-p", legacy ? "2222" : "3333"],
1220+
);
1221+
}).pipe(Effect.provide(layer), Effect.scoped);
1222+
});
1223+
9481224
it.effect.each(["local tunnel", "remote server"] as const)(
9491225
"waits for %s shutdown before reconnecting the same target",
9501226
(stalledStep) =>
9511227
Effect.gen(function* () {
9521228
const shutdownStarted = yield* Deferred.make<void>();
9531229
const finishShutdown = yield* Deferred.make<void>();
954-
const reconnectsStarted = yield* Deferred.make<void>();
9551230
const pauseShutdown = Deferred.succeed(shutdownStarted, undefined).pipe(
9561231
Effect.andThen(Deferred.await(finishShutdown)),
9571232
);
@@ -962,13 +1237,11 @@ describe("ssh tunnel scripts", () => {
9621237
let remoteRunning = false;
9631238
const target = { alias: "devbox", hostname: "devbox", username: null, port: null };
9641239
const spawner = ChildProcessSpawner.make((command) =>
965-
Effect.gen(function* () {
1240+
Effect.sync(() => {
9661241
const args = commandArgs(command);
9671242
const isTarget = args.includes(target.alias);
9681243
if (args.includes("-G")) {
969-
if (isTarget && ++resolutions === 3) {
970-
yield* Deferred.succeed(reconnectsStarted, undefined);
971-
}
1244+
if (isTarget) resolutions += 1;
9721245
return makeSuccessfulProcess("");
9731246
}
9741247
if (args.includes("-N")) {
@@ -1018,9 +1291,12 @@ describe("ssh tunnel scripts", () => {
10181291
yield* manager.ensureEnvironment(target);
10191292
const disconnect = yield* Effect.forkChild(manager.disconnectEnvironment(target));
10201293
yield* Deferred.await(shutdownStarted);
1021-
const firstReconnect = yield* Effect.forkChild(manager.ensureEnvironment(target));
1022-
const secondReconnect = yield* Effect.forkChild(manager.ensureEnvironment(target));
1023-
yield* Deferred.await(reconnectsStarted);
1294+
const firstReconnect = yield* Effect.forkChild(manager.ensureEnvironment(target), {
1295+
startImmediately: true,
1296+
});
1297+
const secondReconnect = yield* Effect.forkChild(manager.ensureEnvironment(target), {
1298+
startImmediately: true,
1299+
});
10241300

10251301
yield* manager.ensureEnvironment({
10261302
alias: "other",
@@ -1030,12 +1306,15 @@ describe("ssh tunnel scripts", () => {
10301306
});
10311307
yield* TestClock.adjust(Duration.zero);
10321308
const launchesBeforeShutdown = launches;
1309+
const resolutionsBeforeShutdown = resolutions;
10331310
yield* Deferred.succeed(finishShutdown, undefined);
10341311
yield* Fiber.join(disconnect);
10351312
const first = yield* Fiber.join(firstReconnect);
10361313
const second = yield* Fiber.join(secondReconnect);
10371314

10381315
assert.equal(launchesBeforeShutdown, 1);
1316+
assert.equal(resolutionsBeforeShutdown, 1);
1317+
assert.equal(resolutions, 3);
10391318
assert.equal(launches, 2);
10401319
assert.equal(tunnels, 2);
10411320
assert.isTrue(remoteRunning);

0 commit comments

Comments
 (0)