1
- use std:: collections:: { BTreeSet , HashMap , HashSet } ;
1
+ use std:: collections:: { BTreeSet , HashMap } ;
2
2
use std:: fs:: { self , File } ;
3
3
use std:: io:: prelude:: * ;
4
4
use std:: io:: SeekFrom ;
@@ -16,7 +16,7 @@ use crate::core::{Package, PackageId, PackageSet, Resolve, SourceId};
16
16
use crate :: ops:: lockfile:: LOCKFILE_NAME ;
17
17
use crate :: ops:: registry:: { infer_registry, RegistryOrIndex } ;
18
18
use crate :: sources:: registry:: index:: { IndexPackage , RegistryDependency } ;
19
- use crate :: sources:: { PathSource , SourceConfigMap , CRATES_IO_REGISTRY } ;
19
+ use crate :: sources:: { PathSource , CRATES_IO_REGISTRY } ;
20
20
use crate :: util:: cache_lock:: CacheLockMode ;
21
21
use crate :: util:: context:: JobsConfig ;
22
22
use crate :: util:: errors:: CargoResult ;
@@ -202,19 +202,34 @@ pub fn package(ws: &Workspace<'_>, opts: &PackageOpts<'_>) -> CargoResult<Vec<Fi
202
202
// below, and will be validated during the verification step.
203
203
}
204
204
205
+ let deps = local_deps ( pkgs. iter ( ) . map ( |( p, f) | ( ( * p) . clone ( ) , f. clone ( ) ) ) ) ;
205
206
let just_pkgs: Vec < _ > = pkgs. iter ( ) . map ( |p| p. 0 ) . collect ( ) ;
206
- let publish_reg = get_registry ( ws. gctx ( ) , & just_pkgs, opts. reg_or_index . clone ( ) ) ?;
207
- debug ! ( "packaging for registry {publish_reg}" ) ;
207
+
208
+ let sid = match get_registry ( ws. gctx ( ) , & just_pkgs, opts. reg_or_index . clone ( ) ) {
209
+ Ok ( sid) => {
210
+ debug ! ( "packaging for registry {}" , sid) ;
211
+ Some ( sid)
212
+ }
213
+ Err ( e) => {
214
+ if deps. has_no_dependencies ( ) && opts. reg_or_index . is_none ( ) {
215
+ // The publish registry doesn't matter unless there are local dependencies,
216
+ // so ignore any errors if we don't need it. If they explicitly passed a registry
217
+ // on the CLI, we check it no matter what.
218
+ None
219
+ } else {
220
+ return Err ( e) ;
221
+ }
222
+ }
223
+ } ;
208
224
209
225
let mut local_reg = if ws. gctx ( ) . cli_unstable ( ) . package_workspace {
210
226
let reg_dir = ws. target_dir ( ) . join ( "package" ) . join ( "tmp-registry" ) ;
211
- Some ( TmpRegistry :: new ( ws. gctx ( ) , reg_dir, publish_reg) ?)
227
+ sid. map ( |sid| TmpRegistry :: new ( ws. gctx ( ) , reg_dir, sid) )
228
+ . transpose ( ) ?
212
229
} else {
213
230
None
214
231
} ;
215
232
216
- let deps = local_deps ( pkgs. iter ( ) . map ( |( p, f) | ( ( * p) . clone ( ) , f. clone ( ) ) ) ) ;
217
-
218
233
// Packages need to be created in dependency order, because dependencies must
219
234
// be added to our local overlay before we can create lockfiles that depend on them.
220
235
let sorted_pkgs = deps. sort ( ) ;
@@ -258,52 +273,35 @@ pub fn package(ws: &Workspace<'_>, opts: &PackageOpts<'_>) -> CargoResult<Vec<Fi
258
273
/// packages that we're packaging: if we're packaging foo-bin and foo-lib, and foo-bin
259
274
/// depends on foo-lib, then the foo-lib entry in foo-bin's lockfile will depend on the
260
275
/// registry that we're building packages for.
261
- pub ( crate ) fn get_registry (
276
+ fn get_registry (
262
277
gctx : & GlobalContext ,
263
278
pkgs : & [ & Package ] ,
264
279
reg_or_index : Option < RegistryOrIndex > ,
265
280
) -> CargoResult < SourceId > {
266
- let reg_or_index = match reg_or_index {
281
+ let reg_or_index = match reg_or_index. clone ( ) {
267
282
Some ( r) => Some ( r) ,
268
283
None => infer_registry ( pkgs) ?,
269
284
} ;
270
285
286
+ // Validate the registry against the packages' allow-lists.
271
287
let reg = reg_or_index
272
288
. clone ( )
273
289
. unwrap_or_else ( || RegistryOrIndex :: Registry ( CRATES_IO_REGISTRY . to_owned ( ) ) ) ;
274
-
275
- // Validate the registry against the packages' allow-lists. For backwards compatibility, we
276
- // skip this if only a single package is being published (because in that case the registry
277
- // doesn't affect the packaging step).
278
- if pkgs. len ( ) > 1 {
279
- if let RegistryOrIndex :: Registry ( reg_name) = & reg {
280
- for pkg in pkgs {
281
- if let Some ( allowed) = pkg. publish ( ) . as_ref ( ) {
282
- if !allowed. iter ( ) . any ( |a| a == reg_name) {
283
- bail ! (
290
+ if let RegistryOrIndex :: Registry ( reg_name) = reg {
291
+ for pkg in pkgs {
292
+ if let Some ( allowed) = pkg. publish ( ) . as_ref ( ) {
293
+ if !allowed. iter ( ) . any ( |a| a == & reg_name) {
294
+ bail ! (
284
295
"`{}` cannot be packaged.\n \
285
296
The registry `{}` is not listed in the `package.publish` value in Cargo.toml.",
286
297
pkg. name( ) ,
287
298
reg_name
288
299
) ;
289
- }
290
300
}
291
301
}
292
302
}
293
303
}
294
-
295
- let sid = match reg {
296
- RegistryOrIndex :: Index ( url) => SourceId :: for_registry ( & url) ?,
297
- RegistryOrIndex :: Registry ( reg) if reg == CRATES_IO_REGISTRY => SourceId :: crates_io ( gctx) ?,
298
- RegistryOrIndex :: Registry ( reg) => SourceId :: alt_registry ( gctx, & reg) ?,
299
- } ;
300
-
301
- // Load source replacements that are built-in to Cargo.
302
- let sid = SourceConfigMap :: empty ( gctx) ?
303
- . load ( sid, & HashSet :: new ( ) ) ?
304
- . replaced_source_id ( ) ;
305
-
306
- Ok ( sid)
304
+ Ok ( ops:: registry:: get_source_id ( gctx, reg_or_index. as_ref ( ) ) ?. replacement )
307
305
}
308
306
309
307
/// Just the part of the dependency graph that's between the packages we're packaging.
@@ -322,6 +320,12 @@ impl LocalDependencies {
322
320
. map ( |name| self . packages [ & name] . clone ( ) )
323
321
. collect ( )
324
322
}
323
+
324
+ pub fn has_no_dependencies ( & self ) -> bool {
325
+ self . graph
326
+ . iter ( )
327
+ . all ( |node| self . graph . edges ( node) . next ( ) . is_none ( ) )
328
+ }
325
329
}
326
330
327
331
/// Build just the part of the dependency graph that's between the given packages,
0 commit comments