@git.zone/cli 9.2.2 → 11.0.0
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/.smartconfig.json +5 -3
- package/assets/templates/asset_binary_installer/install.sh +109 -34
- package/assets/templates/asset_binary_release_gitea/.gitea/workflows/release.yml +17 -4
- package/assets/templates/ci_rust/.gitea/workflows/rust_nottags.yaml +29 -0
- package/assets/templates/ci_rust/.gitea/workflows/rust_tags.yaml +32 -0
- package/assets/templates/cli/cli.ts.js +1 -1
- package/assets/templates/gitignore/_gitignore +1 -1
- package/assets/templates/gitignore_rust/_gitignore +31 -0
- package/assets/templates/license_mit/license +4 -1
- package/assets/templates/npm/.package.json +4 -6
- package/assets/templates/npm/test/test.ts +1 -1
- package/assets/templates/rust/.smartscaf.yml +16 -0
- package/assets/templates/rust/_Cargo.toml +12 -0
- package/assets/templates/rust/_crate_Cargo.toml +10 -0
- package/assets/templates/rust/_crate_lib.rs +19 -0
- package/assets/templates/rust/_smartconfig.json +27 -0
- package/assets/templates/rust/readme.md +23 -0
- package/assets/templates/service/.package.json +3 -6
- package/assets/templates/wcc/.package.json +3 -6
- package/assets/templates/wcc_update/html/index.html +2 -2
- package/assets/templates/website/.package.json +3 -6
- package/assets/templates/website/npmextra.json +3 -1
- package/assets/templates/website_update/html/index.html +4 -4
- package/dist_ts/00_commitinfo_data.js +2 -2
- package/dist_ts/classes.gitzoneconfig.d.ts +3 -1
- package/dist_ts/classes.gitzoneconfig.js +9 -1
- package/dist_ts/helpers.managedassets.d.ts +1 -1
- package/dist_ts/helpers.managedassets.js +58 -14
- package/dist_ts/helpers.packagefiles.js +2 -2
- package/dist_ts/helpers.releasetargets.d.ts +6 -0
- package/dist_ts/helpers.releasetargets.js +13 -0
- package/dist_ts/helpers.smartconfigmigrations.js +42 -1
- package/dist_ts/helpers.toolconfig.d.ts +50 -0
- package/dist_ts/helpers.toolconfig.js +212 -0
- package/dist_ts/helpers.tssea.d.ts +11 -4
- package/dist_ts/helpers.tssea.js +47 -17
- package/dist_ts/helpers.tstest.d.ts +27 -8
- package/dist_ts/helpers.tstest.js +64 -26
- package/dist_ts/helpers.versionsource.d.ts +37 -0
- package/dist_ts/helpers.versionsource.js +112 -0
- package/dist_ts/helpers.workflow.d.ts +45 -1
- package/dist_ts/helpers.workflow.js +120 -5
- package/dist_ts/mod_commit/mod.helpers.d.ts +0 -24
- package/dist_ts/mod_commit/mod.helpers.js +1 -94
- package/dist_ts/mod_commit/mod.plugins.d.ts +1 -1
- package/dist_ts/mod_commit/mod.plugins.js +2 -2
- package/dist_ts/mod_config/index.js +131 -18
- package/dist_ts/mod_format/formatters/assets.formatter.js +30 -28
- package/dist_ts/mod_format/formatters/gitignore.formatter.d.ts +4 -2
- package/dist_ts/mod_format/formatters/gitignore.formatter.js +10 -7
- package/dist_ts/mod_format/formatters/license.formatter.d.ts +8 -0
- package/dist_ts/mod_format/formatters/license.formatter.js +25 -2
- package/dist_ts/mod_format/formatters/packagejson.formatter.js +14 -3
- package/dist_ts/mod_format/formatters/rustfmt.formatter.d.ts +19 -0
- package/dist_ts/mod_format/formatters/rustfmt.formatter.js +97 -0
- package/dist_ts/mod_format/formatters/smartconfig.formatter.js +5 -2
- package/dist_ts/mod_format/formatters/templates.formatter.d.ts +3 -2
- package/dist_ts/mod_format/formatters/templates.formatter.js +61 -14
- package/dist_ts/mod_format/formatters/tsconfig.formatter.js +2 -2
- package/dist_ts/mod_format/index.js +3 -1
- package/dist_ts/mod_format/interfaces.format.js +2 -1
- package/dist_ts/mod_release/classes.releasejournal.d.ts +38 -2
- package/dist_ts/mod_release/classes.releasejournal.js +238 -66
- package/dist_ts/mod_release/helpers.cargorelease.d.ts +52 -0
- package/dist_ts/mod_release/helpers.cargorelease.js +195 -0
- package/dist_ts/mod_release/helpers.npmpackages.d.ts +18 -0
- package/dist_ts/mod_release/helpers.npmpackages.js +40 -2
- package/dist_ts/mod_release/helpers.releasecheck.d.ts +73 -0
- package/dist_ts/mod_release/helpers.releasecheck.js +269 -0
- package/dist_ts/mod_release/helpers.releasepreparation.d.ts +22 -8
- package/dist_ts/mod_release/helpers.releasepreparation.js +74 -26
- package/dist_ts/mod_release/helpers.releasepublication.d.ts +21 -1
- package/dist_ts/mod_release/helpers.releasepublication.js +249 -4
- package/dist_ts/mod_release/helpers.releaseversionsource.d.ts +10 -0
- package/dist_ts/mod_release/helpers.releaseversionsource.js +18 -0
- package/dist_ts/mod_release/helpers.rsrepoengine.d.ts +192 -0
- package/dist_ts/mod_release/helpers.rsrepoengine.js +457 -0
- package/dist_ts/mod_release/index.d.ts +3 -0
- package/dist_ts/mod_release/index.js +177 -65
- package/dist_ts/mod_template/index.js +6 -2
- package/dist_ts/mod_tools/index.js +3 -8
- package/dist_ts/plugins.d.ts +1 -1
- package/dist_ts/plugins.js +2 -2
- package/package.json +6 -11
- package/readme.md +244 -26
- package/ts/00_commitinfo_data.ts +1 -1
- package/ts/classes.gitzoneconfig.ts +10 -1
- package/ts/helpers.managedassets.ts +64 -14
- package/ts/helpers.packagefiles.ts +1 -1
- package/ts/helpers.releasetargets.ts +13 -0
- package/ts/helpers.smartconfigmigrations.ts +48 -0
- package/ts/helpers.toolconfig.ts +280 -0
- package/ts/helpers.tssea.ts +62 -19
- package/ts/helpers.tstest.ts +105 -35
- package/ts/helpers.versionsource.ts +169 -0
- package/ts/helpers.workflow.ts +197 -5
- package/ts/mod_commit/mod.helpers.ts +0 -119
- package/ts/mod_commit/mod.plugins.ts +1 -1
- package/ts/mod_config/index.ts +169 -19
- package/ts/mod_format/formatters/assets.formatter.ts +29 -28
- package/ts/mod_format/formatters/gitignore.formatter.ts +10 -6
- package/ts/mod_format/formatters/license.formatter.ts +26 -1
- package/ts/mod_format/formatters/packagejson.formatter.ts +14 -2
- package/ts/mod_format/formatters/rustfmt.formatter.ts +107 -0
- package/ts/mod_format/formatters/smartconfig.formatter.ts +8 -1
- package/ts/mod_format/formatters/templates.formatter.ts +80 -14
- package/ts/mod_format/formatters/tsconfig.formatter.ts +1 -1
- package/ts/mod_format/index.ts +2 -0
- package/ts/mod_format/interfaces.format.ts +1 -0
- package/ts/mod_release/classes.releasejournal.ts +312 -39
- package/ts/mod_release/helpers.cargorelease.ts +289 -0
- package/ts/mod_release/helpers.npmpackages.ts +76 -1
- package/ts/mod_release/helpers.releasecheck.ts +409 -0
- package/ts/mod_release/helpers.releasepreparation.ts +116 -36
- package/ts/mod_release/helpers.releasepublication.ts +462 -1
- package/ts/mod_release/helpers.releaseversionsource.ts +29 -0
- package/ts/mod_release/helpers.rsrepoengine.ts +790 -0
- package/ts/mod_release/index.ts +277 -84
- package/ts/mod_template/index.ts +5 -1
- package/ts/mod_tools/index.ts +2 -7
- package/ts/plugins.ts +1 -1
|
@@ -7,7 +7,10 @@ import {
|
|
|
7
7
|
getReleaseDockerPromotionContext,
|
|
8
8
|
getReleaseArtifacts,
|
|
9
9
|
getReleaseNpmArtifact,
|
|
10
|
+
getReleaseCargo,
|
|
11
|
+
getReleaseCargoRegistries,
|
|
10
12
|
hasReleasePackages,
|
|
13
|
+
type IReleaseCrateArtifact,
|
|
11
14
|
type TReleaseJournal,
|
|
12
15
|
type IReleaseJournalV2,
|
|
13
16
|
type IReleaseJournalV4,
|
|
@@ -31,11 +34,19 @@ import {
|
|
|
31
34
|
formatReleaseDuration,
|
|
32
35
|
printReleasePhase,
|
|
33
36
|
} from "./helpers.releasephase.js";
|
|
34
|
-
import {
|
|
37
|
+
import {
|
|
38
|
+
assertGiteaAssetsGitDestination,
|
|
39
|
+
defaultCargoVerificationWindowMinutes,
|
|
40
|
+
} from "../helpers.workflow.js";
|
|
41
|
+
import {
|
|
42
|
+
RsrepoEngineCommandError,
|
|
43
|
+
type IRsrepoEngineClient,
|
|
44
|
+
} from "./helpers.rsrepoengine.js";
|
|
35
45
|
import {
|
|
36
46
|
defaultNpmVerificationWindowMinutes,
|
|
37
47
|
npmPublishWasAccepted,
|
|
38
48
|
planNpmAvailabilityProbes,
|
|
49
|
+
probeDelayForAttempt,
|
|
39
50
|
probeAnonymousNpmArtifact,
|
|
40
51
|
probeAuthenticatedNpmArtifact,
|
|
41
52
|
publishNpmArtifact,
|
|
@@ -116,6 +127,7 @@ type TReleaseTargetSelector =
|
|
|
116
127
|
| { kind: "gitea-release" }
|
|
117
128
|
| { kind: "gitea-asset"; name: string }
|
|
118
129
|
| { kind: "npm"; registry: string; packageName?: string }
|
|
130
|
+
| { kind: "cargo"; registry: string; crate: string }
|
|
119
131
|
| { kind: "docker-qualification" }
|
|
120
132
|
| { kind: "docker-promotion"; promotionId: string }
|
|
121
133
|
| { kind: "docker-cleanup" };
|
|
@@ -153,6 +165,19 @@ export interface IReleasePublicationOptions {
|
|
|
153
165
|
giteaAssetConcurrency?: number;
|
|
154
166
|
/** Bound and retries of the Git target's remote commands. */
|
|
155
167
|
gitRemotePolicy?: IReleaseGitRemotePolicy;
|
|
168
|
+
/** The rsrepo engine that publishes and probes the journal's crates. */
|
|
169
|
+
cargoEngine?: IRsrepoEngineClient;
|
|
170
|
+
/** Waiting budget for one accepted crate before resume takes over. */
|
|
171
|
+
cargoVerificationWindowMs?: number;
|
|
172
|
+
/** Replaces the probe schedule derived from the window; tests only shorten it. */
|
|
173
|
+
cargoProbeSchedule?: ICargoProbeSchedule;
|
|
174
|
+
/**
|
|
175
|
+
* Opens a checkout of the release commit for `cargo publish`, runs the
|
|
176
|
+
* publication in it and removes it again.
|
|
177
|
+
*/
|
|
178
|
+
withCargoPublishCheckout?: <T>(
|
|
179
|
+
useArg: (checkoutCwdArg: string) => Promise<T>,
|
|
180
|
+
) => Promise<T>;
|
|
156
181
|
giteaAssets?: Pick<
|
|
157
182
|
GiteaAssetsClient,
|
|
158
183
|
| "preflight"
|
|
@@ -213,6 +238,19 @@ const getTargetStatus = (
|
|
|
213
238
|
}
|
|
214
239
|
return promotion;
|
|
215
240
|
}
|
|
241
|
+
if (selectorArg.kind === "cargo") {
|
|
242
|
+
const cell = getReleaseCargo(journalArg)?.registries.find(
|
|
243
|
+
(cellArg) =>
|
|
244
|
+
cellArg.registry === selectorArg.registry &&
|
|
245
|
+
cellArg.crate === selectorArg.crate,
|
|
246
|
+
);
|
|
247
|
+
if (!cell) {
|
|
248
|
+
throw new Error(
|
|
249
|
+
`Release journal does not contain crate ${selectorArg.crate} in cargo registry ${selectorArg.registry}.`,
|
|
250
|
+
);
|
|
251
|
+
}
|
|
252
|
+
return cell;
|
|
253
|
+
}
|
|
216
254
|
const registry = journalArg.npm.registries.find(
|
|
217
255
|
(registryArg) =>
|
|
218
256
|
registryArg.registry === selectorArg.registry &&
|
|
@@ -2184,6 +2222,420 @@ const executeGiteaAssets = async (
|
|
|
2184
2222
|
return requireGiteaJournal(writer.current());
|
|
2185
2223
|
};
|
|
2186
2224
|
|
|
2225
|
+
// ---------------------------------------------------------------------------
|
|
2226
|
+
// Cargo: crates in dependency order, through the rsrepo engine
|
|
2227
|
+
// ---------------------------------------------------------------------------
|
|
2228
|
+
|
|
2229
|
+
const cargoIndexDelayMs = 2_000;
|
|
2230
|
+
const cargoIndexMaxDelayMs = 20_000;
|
|
2231
|
+
|
|
2232
|
+
/** The probes one waiting verification of an accepted crate makes. */
|
|
2233
|
+
export interface ICargoProbeSchedule {
|
|
2234
|
+
attempts: number;
|
|
2235
|
+
delayMs: number;
|
|
2236
|
+
maxDelayMs: number;
|
|
2237
|
+
}
|
|
2238
|
+
|
|
2239
|
+
type TCargoProbeStatus = "absent" | "exact" | "conflict";
|
|
2240
|
+
|
|
2241
|
+
type TCargoSelector = Extract<TReleaseTargetSelector, { kind: "cargo" }>;
|
|
2242
|
+
|
|
2243
|
+
const requireCargoEngine = (
|
|
2244
|
+
optionsArg: IReleasePublicationOptions,
|
|
2245
|
+
): IRsrepoEngineClient => {
|
|
2246
|
+
if (!optionsArg.cargoEngine) {
|
|
2247
|
+
throw new Error("A Cargo release journal requires the rsrepo engine.");
|
|
2248
|
+
}
|
|
2249
|
+
return optionsArg.cargoEngine;
|
|
2250
|
+
};
|
|
2251
|
+
|
|
2252
|
+
const describeCargoCell = (
|
|
2253
|
+
crateArg: IReleaseCrateArtifact,
|
|
2254
|
+
registryArg: string,
|
|
2255
|
+
): string => `${crateArg.crateName}@${crateArg.version} in cargo registry ${registryArg}`;
|
|
2256
|
+
|
|
2257
|
+
/**
|
|
2258
|
+
* Doubling probes from 2 s, capped at 20 s, across the verification window.
|
|
2259
|
+
* Tests replace the schedule.
|
|
2260
|
+
*/
|
|
2261
|
+
const cargoProbeSchedule = (
|
|
2262
|
+
optionsArg: IReleasePublicationOptions,
|
|
2263
|
+
): ICargoProbeSchedule =>
|
|
2264
|
+
optionsArg.cargoProbeSchedule ??
|
|
2265
|
+
planNpmAvailabilityProbes(
|
|
2266
|
+
optionsArg.cargoVerificationWindowMs ??
|
|
2267
|
+
defaultCargoVerificationWindowMinutes * 60_000,
|
|
2268
|
+
cargoIndexDelayMs,
|
|
2269
|
+
cargoIndexMaxDelayMs,
|
|
2270
|
+
);
|
|
2271
|
+
|
|
2272
|
+
/** What the sparse index serves for the crate: nothing, its bytes, or others. */
|
|
2273
|
+
const probeCargoCell = async (
|
|
2274
|
+
optionsArg: IReleasePublicationOptions,
|
|
2275
|
+
crateArg: IReleaseCrateArtifact,
|
|
2276
|
+
registryArg: string,
|
|
2277
|
+
): Promise<TCargoProbeStatus> => {
|
|
2278
|
+
const probe = await requireCargoEngine(optionsArg).probe({
|
|
2279
|
+
cwd: optionsArg.cwd,
|
|
2280
|
+
registry: registryArg,
|
|
2281
|
+
name: crateArg.crateName,
|
|
2282
|
+
version: crateArg.version,
|
|
2283
|
+
});
|
|
2284
|
+
if (!probe.present) return "absent";
|
|
2285
|
+
return probe.cksum === crateArg.sha256 ? "exact" : "conflict";
|
|
2286
|
+
};
|
|
2287
|
+
|
|
2288
|
+
const waitForCargoIndex = async (
|
|
2289
|
+
optionsArg: IReleasePublicationOptions,
|
|
2290
|
+
crateArg: IReleaseCrateArtifact,
|
|
2291
|
+
registryArg: string,
|
|
2292
|
+
): Promise<TCargoProbeStatus> => {
|
|
2293
|
+
const schedule = cargoProbeSchedule(optionsArg);
|
|
2294
|
+
for (let attempt = 0; attempt < schedule.attempts; attempt++) {
|
|
2295
|
+
if (attempt > 0)
|
|
2296
|
+
await plugins.smartpromise.delayFor(
|
|
2297
|
+
probeDelayForAttempt(attempt - 1, schedule.delayMs, schedule.maxDelayMs),
|
|
2298
|
+
);
|
|
2299
|
+
const status = await probeCargoCell(optionsArg, crateArg, registryArg);
|
|
2300
|
+
if (status !== "absent") return status;
|
|
2301
|
+
}
|
|
2302
|
+
return "absent";
|
|
2303
|
+
};
|
|
2304
|
+
|
|
2305
|
+
const cargoConflictError = (
|
|
2306
|
+
crateArg: IReleaseCrateArtifact,
|
|
2307
|
+
registryArg: string,
|
|
2308
|
+
): Error =>
|
|
2309
|
+
new Error(
|
|
2310
|
+
`${describeCargoCell(crateArg, registryArg)} carries other bytes than the release packed (sha256 ${crateArg.sha256}). A published crate version is immutable: inspect the registry, then release a new version.`,
|
|
2311
|
+
);
|
|
2312
|
+
|
|
2313
|
+
const getReleaseCrate = (
|
|
2314
|
+
journalArg: TReleaseJournal,
|
|
2315
|
+
crateNameArg: string,
|
|
2316
|
+
): IReleaseCrateArtifact => {
|
|
2317
|
+
const crate = getReleaseCargo(journalArg)?.crates.find(
|
|
2318
|
+
(entryArg) => entryArg.crateName === crateNameArg,
|
|
2319
|
+
);
|
|
2320
|
+
if (!crate) throw new Error(`Release journal has no crate ${crateNameArg}.`);
|
|
2321
|
+
return crate;
|
|
2322
|
+
};
|
|
2323
|
+
|
|
2324
|
+
/**
|
|
2325
|
+
* An accepted crate is never uploaded again; only the index promotes it, or
|
|
2326
|
+
* shows other bytes.
|
|
2327
|
+
*/
|
|
2328
|
+
const settleAcceptedCargoCell = async (
|
|
2329
|
+
optionsArg: IReleasePublicationOptions,
|
|
2330
|
+
journalArg: TReleaseJournal,
|
|
2331
|
+
selectorArg: TCargoSelector,
|
|
2332
|
+
waitArg: boolean,
|
|
2333
|
+
): Promise<TReleaseJournal> => {
|
|
2334
|
+
const crate = getReleaseCrate(journalArg, selectorArg.crate);
|
|
2335
|
+
const status = waitArg
|
|
2336
|
+
? await waitForCargoIndex(optionsArg, crate, selectorArg.registry)
|
|
2337
|
+
: await probeCargoCell(optionsArg, crate, selectorArg.registry);
|
|
2338
|
+
if (status === "exact") {
|
|
2339
|
+
return markUnclaimedTarget(
|
|
2340
|
+
optionsArg.store,
|
|
2341
|
+
journalArg,
|
|
2342
|
+
selectorArg,
|
|
2343
|
+
["accepted"],
|
|
2344
|
+
"verified",
|
|
2345
|
+
null,
|
|
2346
|
+
);
|
|
2347
|
+
}
|
|
2348
|
+
if (status === "conflict") {
|
|
2349
|
+
await markUnclaimedTarget(
|
|
2350
|
+
optionsArg.store,
|
|
2351
|
+
journalArg,
|
|
2352
|
+
selectorArg,
|
|
2353
|
+
["accepted"],
|
|
2354
|
+
"conflict",
|
|
2355
|
+
"artifact-conflict",
|
|
2356
|
+
);
|
|
2357
|
+
throw cargoConflictError(crate, selectorArg.registry);
|
|
2358
|
+
}
|
|
2359
|
+
return journalArg;
|
|
2360
|
+
};
|
|
2361
|
+
|
|
2362
|
+
/** Stored crate bytes must still be the packed ones before anything is published. */
|
|
2363
|
+
export const verifyStoredCrateArtifact = async (
|
|
2364
|
+
artifactPathArg: string,
|
|
2365
|
+
crateArg: IReleaseCrateArtifact,
|
|
2366
|
+
): Promise<void> => {
|
|
2367
|
+
const stat = await plugins.fs.lstat(artifactPathArg);
|
|
2368
|
+
const bytes = stat.isFile() ? await plugins.fs.readFile(artifactPathArg) : undefined;
|
|
2369
|
+
if (
|
|
2370
|
+
!bytes ||
|
|
2371
|
+
bytes.byteLength !== crateArg.size ||
|
|
2372
|
+
plugins.crypto.createHash("sha256").update(bytes).digest("hex") !==
|
|
2373
|
+
crateArg.sha256
|
|
2374
|
+
) {
|
|
2375
|
+
throw new Error(
|
|
2376
|
+
`Stored crate ${crateArg.crateName} no longer matches its release journal identity.`,
|
|
2377
|
+
);
|
|
2378
|
+
}
|
|
2379
|
+
};
|
|
2380
|
+
|
|
2381
|
+
interface ICargoCellOutcome {
|
|
2382
|
+
journal: TReleaseJournal;
|
|
2383
|
+
/** A dependency still accepted after its window: nothing later may publish. */
|
|
2384
|
+
blockedBy?: string;
|
|
2385
|
+
}
|
|
2386
|
+
|
|
2387
|
+
const executeCargoCell = async (
|
|
2388
|
+
optionsArg: IReleasePublicationOptions,
|
|
2389
|
+
journalArg: TReleaseJournal,
|
|
2390
|
+
crateArg: IReleaseCrateArtifact,
|
|
2391
|
+
registryArg: string,
|
|
2392
|
+
publishCwdArg: string | undefined,
|
|
2393
|
+
): Promise<ICargoCellOutcome> => {
|
|
2394
|
+
const selector: TCargoSelector = {
|
|
2395
|
+
kind: "cargo",
|
|
2396
|
+
registry: registryArg,
|
|
2397
|
+
crate: crateArg.crateName,
|
|
2398
|
+
};
|
|
2399
|
+
let journal = journalArg;
|
|
2400
|
+
let status = getTargetStatus(journal, selector);
|
|
2401
|
+
// Verified cells are done; accepted ones wait for the index below.
|
|
2402
|
+
if (status.state === "verified" || status.state === "accepted") return { journal };
|
|
2403
|
+
if (status.state === "conflict") {
|
|
2404
|
+
throw new Error(
|
|
2405
|
+
`${describeCargoCell(crateArg, registryArg)} is in conflict and cannot resume automatically.`,
|
|
2406
|
+
);
|
|
2407
|
+
}
|
|
2408
|
+
if (status.state === "publishing") {
|
|
2409
|
+
const probe = await probeCargoCell(optionsArg, crateArg, registryArg);
|
|
2410
|
+
if (probe === "exact") {
|
|
2411
|
+
return {
|
|
2412
|
+
journal: await finishPublishingTarget(
|
|
2413
|
+
optionsArg.store,
|
|
2414
|
+
journal,
|
|
2415
|
+
selector,
|
|
2416
|
+
"verified",
|
|
2417
|
+
null,
|
|
2418
|
+
),
|
|
2419
|
+
};
|
|
2420
|
+
}
|
|
2421
|
+
if (probe === "conflict") {
|
|
2422
|
+
await finishPublishingTarget(
|
|
2423
|
+
optionsArg.store,
|
|
2424
|
+
journal,
|
|
2425
|
+
selector,
|
|
2426
|
+
"conflict",
|
|
2427
|
+
"artifact-conflict",
|
|
2428
|
+
);
|
|
2429
|
+
throw cargoConflictError(crateArg, registryArg);
|
|
2430
|
+
}
|
|
2431
|
+
journal = await recoverPublishingTarget(
|
|
2432
|
+
optionsArg.store,
|
|
2433
|
+
journal,
|
|
2434
|
+
selector,
|
|
2435
|
+
optionsArg.recoveryAttemptId,
|
|
2436
|
+
);
|
|
2437
|
+
status = getTargetStatus(journal, selector);
|
|
2438
|
+
}
|
|
2439
|
+
// crates.io refuses a crate whose dependency version is not indexed yet.
|
|
2440
|
+
for (const dependency of crateArg.dependencies) {
|
|
2441
|
+
const dependencySelector: TCargoSelector = {
|
|
2442
|
+
kind: "cargo",
|
|
2443
|
+
registry: registryArg,
|
|
2444
|
+
crate: dependency,
|
|
2445
|
+
};
|
|
2446
|
+
if (getTargetStatus(journal, dependencySelector).state === "accepted") {
|
|
2447
|
+
printReleasePhase(
|
|
2448
|
+
`cargo ${dependency} in ${registryArg}: waiting until the index serves it`,
|
|
2449
|
+
);
|
|
2450
|
+
journal = await settleAcceptedCargoCell(
|
|
2451
|
+
optionsArg,
|
|
2452
|
+
journal,
|
|
2453
|
+
dependencySelector,
|
|
2454
|
+
true,
|
|
2455
|
+
);
|
|
2456
|
+
}
|
|
2457
|
+
const dependencyState = getTargetStatus(journal, dependencySelector).state;
|
|
2458
|
+
if (dependencyState === "accepted") return { journal, blockedBy: dependency };
|
|
2459
|
+
if (dependencyState !== "verified") {
|
|
2460
|
+
throw new Error(
|
|
2461
|
+
`${describeCargoCell(crateArg, registryArg)} needs its dependency ${dependency} verified first; it is ${dependencyState}.`,
|
|
2462
|
+
);
|
|
2463
|
+
}
|
|
2464
|
+
}
|
|
2465
|
+
const probe = await probeCargoCell(optionsArg, crateArg, registryArg);
|
|
2466
|
+
if (probe === "exact") {
|
|
2467
|
+
return {
|
|
2468
|
+
journal: await markUnclaimedTarget(
|
|
2469
|
+
optionsArg.store,
|
|
2470
|
+
journal,
|
|
2471
|
+
selector,
|
|
2472
|
+
["pending", "failed"],
|
|
2473
|
+
"verified",
|
|
2474
|
+
null,
|
|
2475
|
+
),
|
|
2476
|
+
};
|
|
2477
|
+
}
|
|
2478
|
+
if (probe === "conflict") {
|
|
2479
|
+
await markUnclaimedTarget(
|
|
2480
|
+
optionsArg.store,
|
|
2481
|
+
journal,
|
|
2482
|
+
selector,
|
|
2483
|
+
["pending", "failed"],
|
|
2484
|
+
"conflict",
|
|
2485
|
+
"artifact-conflict",
|
|
2486
|
+
);
|
|
2487
|
+
throw cargoConflictError(crateArg, registryArg);
|
|
2488
|
+
}
|
|
2489
|
+
if (!publishCwdArg) {
|
|
2490
|
+
throw new Error(
|
|
2491
|
+
`${describeCargoCell(crateArg, registryArg)} needs a checkout of the release commit to publish from.`,
|
|
2492
|
+
);
|
|
2493
|
+
}
|
|
2494
|
+
await verifyStoredCrateArtifact(
|
|
2495
|
+
optionsArg.store.getArtifactPath(journal.release.version, crateArg.file),
|
|
2496
|
+
crateArg,
|
|
2497
|
+
);
|
|
2498
|
+
await optionsArg.ensurePublicationState(
|
|
2499
|
+
journal.git.state === "verified"
|
|
2500
|
+
? journal.release.mainOid
|
|
2501
|
+
: journal.git.expectedRemoteMainOid || undefined,
|
|
2502
|
+
);
|
|
2503
|
+
journal = await claimTarget(optionsArg.store, journal, selector);
|
|
2504
|
+
let accepted = false;
|
|
2505
|
+
let rejection: RsrepoEngineCommandError | undefined;
|
|
2506
|
+
try {
|
|
2507
|
+
await requireCargoEngine(optionsArg).publish({
|
|
2508
|
+
cwd: publishCwdArg,
|
|
2509
|
+
registry: registryArg,
|
|
2510
|
+
member: crateArg.crateName,
|
|
2511
|
+
});
|
|
2512
|
+
accepted = true;
|
|
2513
|
+
} catch (error) {
|
|
2514
|
+
if (!(error instanceof RsrepoEngineCommandError)) throw error;
|
|
2515
|
+
// A definite refusal; every other outcome is settled by the index.
|
|
2516
|
+
if (
|
|
2517
|
+
["bad-request", "publish-rejected", "cargo-failed", "not-found"].includes(
|
|
2518
|
+
error.code,
|
|
2519
|
+
)
|
|
2520
|
+
)
|
|
2521
|
+
rejection = error;
|
|
2522
|
+
}
|
|
2523
|
+
if (accepted) {
|
|
2524
|
+
journal = await finishPublishingTarget(
|
|
2525
|
+
optionsArg.store,
|
|
2526
|
+
journal,
|
|
2527
|
+
selector,
|
|
2528
|
+
"accepted",
|
|
2529
|
+
null,
|
|
2530
|
+
);
|
|
2531
|
+
return {
|
|
2532
|
+
journal: await settleAcceptedCargoCell(optionsArg, journal, selector, false),
|
|
2533
|
+
};
|
|
2534
|
+
}
|
|
2535
|
+
const after = await probeCargoCell(optionsArg, crateArg, registryArg);
|
|
2536
|
+
if (after === "exact") {
|
|
2537
|
+
return {
|
|
2538
|
+
journal: await finishPublishingTarget(
|
|
2539
|
+
optionsArg.store,
|
|
2540
|
+
journal,
|
|
2541
|
+
selector,
|
|
2542
|
+
"verified",
|
|
2543
|
+
null,
|
|
2544
|
+
),
|
|
2545
|
+
};
|
|
2546
|
+
}
|
|
2547
|
+
if (after === "conflict") {
|
|
2548
|
+
await finishPublishingTarget(
|
|
2549
|
+
optionsArg.store,
|
|
2550
|
+
journal,
|
|
2551
|
+
selector,
|
|
2552
|
+
"conflict",
|
|
2553
|
+
"artifact-conflict",
|
|
2554
|
+
);
|
|
2555
|
+
throw cargoConflictError(crateArg, registryArg);
|
|
2556
|
+
}
|
|
2557
|
+
await finishPublishingTarget(
|
|
2558
|
+
optionsArg.store,
|
|
2559
|
+
journal,
|
|
2560
|
+
selector,
|
|
2561
|
+
"failed",
|
|
2562
|
+
rejection ? "command-failed" : "verification-inconclusive",
|
|
2563
|
+
);
|
|
2564
|
+
throw new Error(
|
|
2565
|
+
rejection
|
|
2566
|
+
? `cargo publication of ${describeCargoCell(crateArg, registryArg)} was rejected: ${rejection.message}`
|
|
2567
|
+
: `cargo publication of ${describeCargoCell(crateArg, registryArg)} has no verifiable outcome; run \`gitzone release resume ${journal.release.version} -y\` to probe and publish it again.`,
|
|
2568
|
+
);
|
|
2569
|
+
};
|
|
2570
|
+
|
|
2571
|
+
/**
|
|
2572
|
+
* Publishes every crate to every registry in dependency order. A crate waits
|
|
2573
|
+
* until its dependencies are verified in the same registry; one still
|
|
2574
|
+
* accepted after its window stops the run, and resume continues. Publication
|
|
2575
|
+
* runs `cargo publish` in a checkout of the release commit, which opens only
|
|
2576
|
+
* when a crate still needs an upload.
|
|
2577
|
+
*/
|
|
2578
|
+
const executeCargoPublication = async (
|
|
2579
|
+
optionsArg: IReleasePublicationOptions,
|
|
2580
|
+
journalArg: TReleaseJournal,
|
|
2581
|
+
): Promise<TReleaseJournal> => {
|
|
2582
|
+
const cargo = getReleaseCargo(journalArg);
|
|
2583
|
+
if (!cargo) return journalArg;
|
|
2584
|
+
let journal = journalArg;
|
|
2585
|
+
const registries = getReleaseCargoRegistries(cargo);
|
|
2586
|
+
const publishAll = async (publishCwdArg?: string): Promise<void> => {
|
|
2587
|
+
for (const crate of cargo.crates) {
|
|
2588
|
+
for (const registry of registries) {
|
|
2589
|
+
printReleasePhase(`cargo ${describeCargoCell(crate, registry)}`);
|
|
2590
|
+
const outcome = await executeCargoCell(
|
|
2591
|
+
optionsArg,
|
|
2592
|
+
journal,
|
|
2593
|
+
crate,
|
|
2594
|
+
registry,
|
|
2595
|
+
publishCwdArg,
|
|
2596
|
+
);
|
|
2597
|
+
journal = outcome.journal;
|
|
2598
|
+
if (outcome.blockedBy) {
|
|
2599
|
+
console.log(
|
|
2600
|
+
`cargo registry ${registry} does not index ${outcome.blockedBy}@${crate.version} yet, so ${crate.crateName} and the crates after it wait. Nothing is republished: run \`gitzone release resume ${journal.release.version} -y\` later.`,
|
|
2601
|
+
);
|
|
2602
|
+
return;
|
|
2603
|
+
}
|
|
2604
|
+
}
|
|
2605
|
+
}
|
|
2606
|
+
for (const cell of getReleaseCargo(journal)!.registries) {
|
|
2607
|
+
if (cell.state !== "accepted") continue;
|
|
2608
|
+
const selector: TCargoSelector = {
|
|
2609
|
+
kind: "cargo",
|
|
2610
|
+
registry: cell.registry,
|
|
2611
|
+
crate: cell.crate,
|
|
2612
|
+
};
|
|
2613
|
+
printReleasePhase(
|
|
2614
|
+
`cargo index of ${cell.crate} in ${cell.registry}: waiting until it serves the crate`,
|
|
2615
|
+
);
|
|
2616
|
+
journal = await settleAcceptedCargoCell(optionsArg, journal, selector, true);
|
|
2617
|
+
if (getTargetStatus(journal, selector).state === "accepted")
|
|
2618
|
+
console.log(
|
|
2619
|
+
`cargo registry ${cell.registry} accepted ${cell.crate} but does not index it yet. Nothing is republished: run \`gitzone release resume ${journal.release.version} -y\` later to verify it.`,
|
|
2620
|
+
);
|
|
2621
|
+
}
|
|
2622
|
+
};
|
|
2623
|
+
const needsUpload = cargo.registries.some((cell) =>
|
|
2624
|
+
["pending", "failed", "publishing"].includes(cell.state),
|
|
2625
|
+
);
|
|
2626
|
+
if (!needsUpload) {
|
|
2627
|
+
await publishAll();
|
|
2628
|
+
return journal;
|
|
2629
|
+
}
|
|
2630
|
+
if (!optionsArg.withCargoPublishCheckout) {
|
|
2631
|
+
throw new Error(
|
|
2632
|
+
"Cargo publication requires a checkout of the release commit to publish from.",
|
|
2633
|
+
);
|
|
2634
|
+
}
|
|
2635
|
+
await optionsArg.withCargoPublishCheckout(publishAll);
|
|
2636
|
+
return journal;
|
|
2637
|
+
};
|
|
2638
|
+
|
|
2187
2639
|
export const executeReleasePublication = async (
|
|
2188
2640
|
optionsArg: IReleasePublicationOptions,
|
|
2189
2641
|
): Promise<TReleaseJournal> => {
|
|
@@ -2195,6 +2647,12 @@ export const executeReleasePublication = async (
|
|
|
2195
2647
|
artifact,
|
|
2196
2648
|
);
|
|
2197
2649
|
}
|
|
2650
|
+
for (const crate of getReleaseCargo(journal)?.crates ?? []) {
|
|
2651
|
+
await verifyStoredCrateArtifact(
|
|
2652
|
+
optionsArg.store.getArtifactPath(journal.release.version, crate.file),
|
|
2653
|
+
crate,
|
|
2654
|
+
);
|
|
2655
|
+
}
|
|
2198
2656
|
let giteaClient = optionsArg.giteaAssets;
|
|
2199
2657
|
if (journal.schemaVersion === 4) {
|
|
2200
2658
|
const { destination, tokenEnv, manifestPath, assets } = journal.giteaAssets;
|
|
@@ -2270,6 +2728,9 @@ export const executeReleasePublication = async (
|
|
|
2270
2728
|
);
|
|
2271
2729
|
}
|
|
2272
2730
|
}
|
|
2731
|
+
if (getReleaseCargo(journal)) {
|
|
2732
|
+
journal = await executeCargoPublication(optionsArg, journal);
|
|
2733
|
+
}
|
|
2273
2734
|
const npmAwaitingAvailability = journal.npm.registries.some(
|
|
2274
2735
|
(registryArg) => registryArg.state === "accepted",
|
|
2275
2736
|
);
|
|
@@ -0,0 +1,29 @@
|
|
|
1
|
+
import * as plugins from "./mod.plugins.js";
|
|
2
|
+
import type { IResolvedReleaseWorkflow } from "../helpers.workflow.js";
|
|
3
|
+
import {
|
|
4
|
+
detectVersionSourceKind,
|
|
5
|
+
openVersionSource,
|
|
6
|
+
type IVersionSource,
|
|
7
|
+
} from "../helpers.versionsource.js";
|
|
8
|
+
import { RsrepoEngineClient } from "./helpers.rsrepoengine.js";
|
|
9
|
+
|
|
10
|
+
/**
|
|
11
|
+
* The version source of the release in `cwdArg`: package.json, or the Cargo
|
|
12
|
+
* workspace of projectType "rust" through the project's rsrepo engine.
|
|
13
|
+
* `gitzone release`, its plan and `gitzone release check` all open it here, so
|
|
14
|
+
* they refuse the same projects with the same message.
|
|
15
|
+
*/
|
|
16
|
+
export const openReleaseVersionSource = async (
|
|
17
|
+
smartshellArg: plugins.smartshell.Smartshell,
|
|
18
|
+
workflowArg: Pick<IResolvedReleaseWorkflow, "cargoVersioned">,
|
|
19
|
+
cwdArg: string,
|
|
20
|
+
): Promise<IVersionSource> => {
|
|
21
|
+
const kind = await detectVersionSourceKind(
|
|
22
|
+
cwdArg,
|
|
23
|
+
workflowArg.cargoVersioned ? "rust" : undefined,
|
|
24
|
+
);
|
|
25
|
+
if (kind !== "cargo") return openVersionSource(kind, cwdArg);
|
|
26
|
+
const engine = await RsrepoEngineClient.forProject(smartshellArg, cwdArg);
|
|
27
|
+
await engine.assertCapabilities(["plan", "set-version"]);
|
|
28
|
+
return openVersionSource(kind, cwdArg, engine);
|
|
29
|
+
};
|