-
Notifications
You must be signed in to change notification settings - Fork 4k
/
Runfiles.java
1107 lines (989 loc) · 42.7 KB
/
Runfiles.java
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
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
// Copyright 2018 The Bazel Authors. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package com.google.devtools.build.lib.analysis;
import static com.google.devtools.build.lib.actions.ActionKeyContext.describeNestedSetFingerprint;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Function;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Iterables;
import com.google.common.collect.Maps;
import com.google.common.collect.Streams;
import com.google.devtools.build.lib.actions.ActionKeyContext;
import com.google.devtools.build.lib.actions.Artifact;
import com.google.devtools.build.lib.actions.CommandLineItem;
import com.google.devtools.build.lib.cmdline.LabelConstants;
import com.google.devtools.build.lib.collect.nestedset.Depset;
import com.google.devtools.build.lib.collect.nestedset.NestedSet;
import com.google.devtools.build.lib.collect.nestedset.NestedSetBuilder;
import com.google.devtools.build.lib.collect.nestedset.Order;
import com.google.devtools.build.lib.concurrent.ThreadSafety.Immutable;
import com.google.devtools.build.lib.events.Event;
import com.google.devtools.build.lib.events.EventHandler;
import com.google.devtools.build.lib.events.EventKind;
import com.google.devtools.build.lib.packages.BuildType;
import com.google.devtools.build.lib.packages.semantics.BuildLanguageOptions;
import com.google.devtools.build.lib.skyframe.serialization.VisibleForSerialization;
import com.google.devtools.build.lib.skyframe.serialization.autocodec.SerializationConstant;
import com.google.devtools.build.lib.starlarkbuildapi.RunfilesApi;
import com.google.devtools.build.lib.util.Fingerprint;
import com.google.devtools.build.lib.vfs.PathFragment;
import com.google.errorprone.annotations.CanIgnoreReturnValue;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.UUID;
import javax.annotation.Nullable;
import net.starlark.java.eval.EvalException;
import net.starlark.java.eval.Sequence;
import net.starlark.java.eval.Starlark;
import net.starlark.java.eval.StarlarkSemantics;
import net.starlark.java.eval.StarlarkThread;
import net.starlark.java.syntax.Location;
/**
* An object that encapsulates runfiles. Conceptually, the runfiles are a map of paths to files,
* forming a symlink tree.
*
* <p>In order to reduce memory consumption, this map is not explicitly stored here, but instead as
* a combination of three parts: artifacts placed at their output-dir-relative paths, source tree
* symlinks and root symlinks (outside of the source tree).
*/
@Immutable
public final class Runfiles implements RunfilesApi {
private static class DummyEmptyFilesSupplier implements EmptyFilesSupplier {
private static final UUID GUID = UUID.fromString("36437db7-820b-4386-85b4-f7205a2018ae");
private DummyEmptyFilesSupplier() {}
@Override
public Iterable<PathFragment> getExtraPaths(Set<PathFragment> manifestPaths) {
return ImmutableList.of();
}
@Override
public void fingerprint(Fingerprint fp) {
fp.addUUID(GUID);
}
}
@SerializationConstant @VisibleForSerialization
static final EmptyFilesSupplier DUMMY_EMPTY_FILES_SUPPLIER = new DummyEmptyFilesSupplier();
// It is important to declare this *after* the DUMMY_SYMLINK_EXPANDER to avoid NPEs
public static final Runfiles EMPTY = new Builder().build();
private static final PathFragment REPO_MAPPING_PATH_FRAGMENT =
PathFragment.create("_repo_mapping");
private static final CommandLineItem.ExceptionlessMapFn<SymlinkEntry> SYMLINK_ENTRY_MAP_FN =
(symlink, args) -> {
args.accept(symlink.getPathString());
args.accept(symlink.getArtifact().getExecPathString());
};
private static final CommandLineItem.ExceptionlessMapFn<Artifact>
RUNFILES_AND_ABSOLUTE_PATH_MAP_FN =
(artifact, args) -> {
args.accept(artifact.getRunfilesPathString());
args.accept(artifact.getPath().getPathString());
};
private static final CommandLineItem.ExceptionlessMapFn<Artifact> RUNFILES_AND_EXEC_PATH_MAP_FN =
(artifact, args) -> {
args.accept(artifact.getRunfilesPathString());
args.accept(artifact.getExecPathString());
};
/**
* The directory to put all runfiles under.
*
* <p>Using "foo" will put runfiles under <target>.runfiles/foo.
*
* <p>This is either set to the workspace name, or the empty string.
*/
private final String prefix;
/**
* The artifacts that should be present in the runfiles directory.
*
* <p>This collection may not include any middlemen. These artifacts will be placed at a location
* that corresponds to the output-dir-relative path of each artifact. It's possible for several
* artifacts to have the same output-dir-relative path, in which case the last one will win.
*/
private final NestedSet<Artifact> artifacts;
/**
* A map of symlinks that should be present in the runfiles directory. In general, the symlink can
* be determined from the artifact by using the output-dir-relative path, so this should only be
* used for cases where that isn't possible.
*
* <p>This may include runfiles symlinks from the root of the runfiles tree.
*/
private final NestedSet<SymlinkEntry> symlinks;
/**
* A map of symlinks that should be present above the runfiles directory. These are useful for
* certain rule types like AppEngine apps which have root level config files outside of the
* regular source tree.
*/
private final NestedSet<SymlinkEntry> rootSymlinks;
/**
* A nested set of all artifacts that this Runfiles entry contains symlinks to, including those at
* their non-canonical locations which are in {@code symlinks} and {@code rootSymlinks}.
*/
private NestedSet<Artifact> allArtifacts;
/**
* Interface used for adding empty files to the runfiles at the last minute. Mainly to support
* python-related rules adding __init__.py files.
*/
public interface EmptyFilesSupplier {
/** Calculate additional empty files to add based on the existing manifest paths. */
Iterable<PathFragment> getExtraPaths(Set<PathFragment> manifestPaths);
void fingerprint(Fingerprint fingerprint);
}
/** Generates extra (empty file) inputs. */
private final EmptyFilesSupplier emptyFilesSupplier;
/**
* Behavior upon finding a conflict between two runfile entries. A conflict means that two
* different artifacts have the same runfiles path specified. For example, adding artifact
* "a.foo" at path "bar" when there is already an artifact "b.foo" at path "bar". The policies
* are ordered from least strict to most strict.
*
* <p>Note that conflicts are found relatively late, when the manifest file is created, not when
* the symlinks are added to runfiles.
*
* <p>If no EventHandler is available, all values are treated as IGNORE.
*/
public enum ConflictPolicy {
IGNORE,
WARN,
ERROR,
}
/** Policy for this Runfiles tree */
private ConflictPolicy conflictPolicy;
/**
* If external runfiles should be created under .runfiles/wsname/external/repo as well as
* .runfiles/repo.
*/
private final boolean legacyExternalRunfiles;
private Runfiles(
String prefix,
NestedSet<Artifact> artifacts,
NestedSet<SymlinkEntry> symlinks,
NestedSet<SymlinkEntry> rootSymlinks,
EmptyFilesSupplier emptyFilesSupplier,
ConflictPolicy conflictPolicy,
boolean legacyExternalRunfiles) {
this.prefix = prefix;
this.artifacts = Preconditions.checkNotNull(artifacts);
this.symlinks = Preconditions.checkNotNull(symlinks);
this.rootSymlinks = Preconditions.checkNotNull(rootSymlinks);
this.emptyFilesSupplier = Preconditions.checkNotNull(emptyFilesSupplier);
this.conflictPolicy = conflictPolicy;
this.legacyExternalRunfiles = legacyExternalRunfiles;
}
@Override
public boolean isImmutable() {
return true; // immutable and Starlark-hashable
}
/** Returns the runfiles' prefix. This is the same as the workspace name. */
public String getPrefix() {
return prefix;
}
/** Returns the collection of runfiles as artifacts. */
@Override
public Depset /*<Artifact>*/ getArtifactsForStarlark() {
return Depset.of(Artifact.class, artifacts);
}
public NestedSet<Artifact> getArtifacts() {
return artifacts;
}
/** Returns the symlinks. */
@Override
public Depset /*<SymlinkEntry>*/ getSymlinksForStarlark() {
return Depset.of(SymlinkEntry.class, symlinks);
}
public NestedSet<SymlinkEntry> getSymlinks() {
return symlinks;
}
@Override
public Depset /*<String>*/ getEmptyFilenamesForStarlark() {
return Depset.of(
String.class,
NestedSetBuilder.wrap(
Order.STABLE_ORDER,
Iterables.transform(getEmptyFilenames(), PathFragment::getPathString)));
}
public Iterable<PathFragment> getEmptyFilenames() {
if (emptyFilesSupplier == DUMMY_EMPTY_FILES_SUPPLIER) {
return ImmutableList.of();
}
Set<PathFragment> manifestKeys =
Streams.concat(
symlinks.toList().stream().map(SymlinkEntry::getPath),
artifacts.toList().stream()
.map(
artifact ->
legacyExternalRunfiles
? artifact.getOutputDirRelativePath(false)
: artifact.getRunfilesPath()))
.collect(ImmutableSet.toImmutableSet());
return emptyFilesSupplier.getExtraPaths(manifestKeys);
}
/**
* Returns the symlinks as a map from path fragment to artifact.
*
* @param checker If not null, check for conflicts using this checker.
*/
Map<PathFragment, Artifact> getSymlinksAsMap(@Nullable ConflictChecker checker) {
return entriesToMap(symlinks, checker);
}
/**
* @param eventHandler Used for throwing an error if we have an obscuring runlink.
* May be null, in which case obscuring symlinks are silently discarded.
* @param location Location for reporter. Ignored if reporter is null.
* @param workingManifest Manifest to be checked for obscuring symlinks.
* @return map of source file names mapped to their location on disk.
*/
@VisibleForTesting
static Map<PathFragment, Artifact> filterListForObscuringSymlinks(
EventHandler eventHandler, Location location, Map<PathFragment, Artifact> workingManifest) {
Map<PathFragment, Artifact> newManifest =
Maps.newHashMapWithExpectedSize(workingManifest.size());
Set<PathFragment> noFurtherObstructions = new HashSet<>();
outer:
for (Map.Entry<PathFragment, Artifact> entry : workingManifest.entrySet()) {
PathFragment source = entry.getKey();
Artifact symlink = entry.getValue();
// drop nested entries; warn if this changes anything
int n = source.segmentCount();
ArrayList<PathFragment> parents = new ArrayList<>(n);
for (int j = 1; j < n; ++j) {
PathFragment prefix = source.subFragment(0, n - j);
if (noFurtherObstructions.contains(prefix)) {
break;
}
parents.add(prefix);
Artifact ancestor = workingManifest.get(prefix);
if (ancestor != null) {
// This is an obscuring symlink, so just drop it and move on if there's no reporter.
if (eventHandler == null) {
continue outer;
}
PathFragment suffix = source.subFragment(n - j, n);
PathFragment viaAncestor = ancestor.getExecPath().getRelative(suffix);
PathFragment expected = symlink.getExecPath();
if (!viaAncestor.equals(expected)) {
eventHandler.handle(
Event.warn(
location,
"runfiles symlink "
+ source
+ " -> "
+ expected
+ " obscured by "
+ prefix
+ " -> "
+ ancestor.getExecPath()));
}
continue outer;
}
}
noFurtherObstructions.addAll(parents);
newManifest.put(entry.getKey(), entry.getValue());
}
return newManifest;
}
/**
* Returns the symlinks as a map from PathFragment to Artifact.
*
* @param eventHandler Used for throwing an error if we have an obscuring runlink within the
* normal source tree entries, or runfile conflicts. May be null, in which case obscuring
* symlinks are silently discarded, and conflicts are overwritten.
* @param location Location for eventHandler warnings. Ignored if eventHandler is null.
* @param repoMappingManifest repository mapping manifest to add as a root symlink. This manifest
* has to be added automatically for every executable and is thus not part of the Runfiles
* advertised by a configured target.
* @return Map<PathFragment, Artifact> path fragment to artifact, of normal source tree entries
* and elements that live outside the source tree. Null values represent empty input files.
*/
public Map<PathFragment, Artifact> getRunfilesInputs(
EventHandler eventHandler, Location location, @Nullable Artifact repoMappingManifest) {
ConflictChecker checker = new ConflictChecker(conflictPolicy, eventHandler, location);
Map<PathFragment, Artifact> manifest = getSymlinksAsMap(checker);
// Add artifacts (committed to inclusion on construction of runfiles).
for (Artifact artifact : artifacts.toList()) {
checker.put(manifest, artifact.getRunfilesPath(), artifact);
}
manifest = filterListForObscuringSymlinks(eventHandler, location, manifest);
// TODO(bazel-team): Create /dev/null-like Artifact to avoid nulls?
for (PathFragment extraPath : emptyFilesSupplier.getExtraPaths(manifest.keySet())) {
checker.put(manifest, extraPath, null);
}
// Copy manifest map to another manifest map, prepending the workspace name to every path.
// E.g. for workspace "myworkspace", the runfile entry "mylib.so"->"/path/to/mylib.so" becomes
// "myworkspace/mylib.so"->"/path/to/mylib.so".
ManifestBuilder builder =
new ManifestBuilder(PathFragment.create(prefix), legacyExternalRunfiles);
builder.addUnderWorkspace(manifest, checker);
// Finally add symlinks relative to the root of the runfiles tree, on top of everything else.
// This operation is always checked for conflicts, to match historical behavior.
if (conflictPolicy == ConflictPolicy.IGNORE) {
checker = new ConflictChecker(ConflictPolicy.WARN, eventHandler, location);
}
builder.add(getRootSymlinksAsMap(checker), checker);
if (repoMappingManifest != null) {
checker.put(builder.manifest, REPO_MAPPING_PATH_FRAGMENT, repoMappingManifest);
}
return builder.build();
}
public boolean isLegacyExternalRunfiles() {
return legacyExternalRunfiles;
}
/**
* Helper class to handle munging the paths of external artifacts.
*/
@VisibleForTesting
static final class ManifestBuilder {
// Manifest of paths to artifacts. Path fragments are relative to the .runfiles directory.
private final Map<PathFragment, Artifact> manifest;
private final PathFragment workspaceName;
private final boolean legacyExternalRunfiles;
// Whether we saw the local workspace name in the runfiles. If legacyExternalRunfiles is true,
// then this is true, as anything under external/ will also have a runfile under the local
// workspace.
private boolean sawWorkspaceName;
ManifestBuilder(PathFragment workspaceName, boolean legacyExternalRunfiles) {
this.manifest = new HashMap<>();
this.workspaceName = workspaceName;
this.legacyExternalRunfiles = legacyExternalRunfiles;
this.sawWorkspaceName = legacyExternalRunfiles;
}
/** Adds a map under the workspaceName. */
void addUnderWorkspace(Map<PathFragment, Artifact> inputManifest, ConflictChecker checker) {
for (Map.Entry<PathFragment, Artifact> entry : inputManifest.entrySet()) {
PathFragment path = entry.getKey();
if (isUnderWorkspace(path)) {
sawWorkspaceName = true;
checker.put(manifest, workspaceName.getRelative(path), entry.getValue());
} else {
if (legacyExternalRunfiles) {
checker.put(manifest, getLegacyExternalPath(path), entry.getValue());
}
// Always add the non-legacy .runfiles/repo/whatever path.
checker.put(manifest, getExternalPath(path), entry.getValue());
}
}
}
/**
* Adds a map to the root directory.
*/
public void add(Map<PathFragment, Artifact> inputManifest, ConflictChecker checker) {
for (Map.Entry<PathFragment, Artifact> entry : inputManifest.entrySet()) {
checker.put(manifest, checkForWorkspace(entry.getKey()), entry.getValue());
}
}
/**
* Returns the manifest, adding the workspaceName directory if it is not already present.
*/
public Map<PathFragment, Artifact> build() {
if (!sawWorkspaceName) {
// If we haven't seen it and we have seen other files, add the workspace name directory.
// It might not be there if all of the runfiles are from other repos (and then running from
// x.runfiles/ws will fail, because ws won't exist). We can't tell Runfiles to create a
// directory, so instead this creates a hidden file inside the desired directory.
manifest.put(workspaceName.getRelative(".runfile"), null);
}
return manifest;
}
private PathFragment getExternalPath(PathFragment path) {
return checkForWorkspace(path.subFragment(1));
}
private PathFragment getLegacyExternalPath(PathFragment path) {
return workspaceName
.getRelative(LabelConstants.EXTERNAL_PATH_PREFIX)
.getRelative(checkForWorkspace(path.subFragment(1)));
}
private PathFragment checkForWorkspace(PathFragment path) {
sawWorkspaceName = sawWorkspaceName
|| path.getSegment(0).equals(workspaceName.getPathString());
return path;
}
private static boolean isUnderWorkspace(PathFragment path) {
return !path.startsWith(LabelConstants.EXTERNAL_RUNFILES_PATH_PREFIX);
}
}
/** Returns the root symlinks. */
@Override
public Depset /*<SymlinkEntry>*/ getRootSymlinksForStarlark() {
return Depset.of(SymlinkEntry.class, rootSymlinks);
}
public NestedSet<SymlinkEntry> getRootSymlinks() {
return rootSymlinks;
}
/**
* Returns the root symlinks as a map from path fragment to artifact.
*
* @param checker If not null, check for conflicts using this checker.
*/
public Map<PathFragment, Artifact> getRootSymlinksAsMap(@Nullable ConflictChecker checker) {
return entriesToMap(rootSymlinks, checker);
}
/**
* Returns the unified map of path fragments to artifacts, taking both artifacts and symlinks into
* account.
*/
public Map<PathFragment, Artifact> asMapWithoutRootSymlinks() {
Map<PathFragment, Artifact> result = entriesToMap(symlinks, null);
// If multiple artifacts have the same output-dir-relative path, the last one in the list will
// win. That is because the runfiles tree cannot contain the same artifact for different
// configurations, because it only uses output-dir-relative paths.
for (Artifact artifact : artifacts.toList()) {
result.put(artifact.getOutputDirRelativePath(true), artifact);
}
return result;
}
/**
* Returns the manifest expander specified for this runfiles tree.
*/
private EmptyFilesSupplier getEmptyFilesProvider() {
return emptyFilesSupplier;
}
/**
* Returns the unified map of path fragments to artifacts, taking into account artifacts and
* symlinks. The returned set is guaranteed to be a (not necessarily strict) superset of the
* actual runfiles tree created at execution time.
*/
public NestedSet<Artifact> getAllArtifacts() {
if (isEmpty()) {
return NestedSetBuilder.emptySet(Order.STABLE_ORDER);
}
if (allArtifacts == null) {
NestedSetBuilder<Artifact> builder = NestedSetBuilder.stableOrder();
builder
.addTransitive(artifacts)
.addAll(Iterables.transform(symlinks.toList(), SymlinkEntry::getArtifact))
.addAll(Iterables.transform(rootSymlinks.toList(), SymlinkEntry::getArtifact));
allArtifacts = builder.build();
}
return allArtifacts;
}
/**
* Returns if there are no runfiles.
*/
public boolean isEmpty() {
return artifacts.isEmpty() && symlinks.isEmpty() && rootSymlinks.isEmpty();
}
/**
* Flatten a sequence of entries into a single map.
*
* @param entrySet Sequence of entries to add.
* @param checker If not null, check for conflicts with this checker, otherwise silently allow
* entries to overwrite previous entries.
* @return Map<PathFragment, Artifact> Map of runfile entries.
*/
private static Map<PathFragment, Artifact> entriesToMap(
NestedSet<SymlinkEntry> entrySet, @Nullable ConflictChecker checker) {
checker = (checker != null) ? checker : ConflictChecker.IGNORE_CHECKER;
Map<PathFragment, Artifact> map = new LinkedHashMap<>();
for (SymlinkEntry entry : entrySet.toList()) {
checker.put(map, entry.getPath(), entry.getArtifact());
}
return map;
}
/** Returns currently policy for conflicting symlink entries. */
ConflictPolicy getConflictPolicy() {
return this.conflictPolicy;
}
/** Set whether we should warn about conflicting symlink entries. */
@CanIgnoreReturnValue
public Runfiles setConflictPolicy(ConflictPolicy conflictPolicy) {
this.conflictPolicy = conflictPolicy;
return this;
}
/**
* Checks for conflicts between entries in a runfiles tree while putting them in a map.
*/
public static final class ConflictChecker {
/** Prebuilt ConflictChecker with policy set to IGNORE */
static final ConflictChecker IGNORE_CHECKER =
new ConflictChecker(ConflictPolicy.IGNORE, null, null);
/** Behavior when a conflict is found. */
private final ConflictPolicy policy;
/** Used for warning on conflicts. May be null, in which case conflicts are ignored. */
private final EventHandler eventHandler;
/** Location for eventHandler warnings. Ignored if eventHandler is null. */
private final Location location;
/** Type of event to emit */
private final EventKind eventKind;
/** Construct a ConflictChecker for the given reporter with the given behavior */
public ConflictChecker(ConflictPolicy policy, EventHandler eventHandler, Location location) {
if (eventHandler == null) {
this.policy = ConflictPolicy.IGNORE; // Can't warn even if we wanted to
} else {
this.policy = policy;
}
this.eventHandler = eventHandler;
this.location = location;
this.eventKind = (policy == ConflictPolicy.ERROR) ? EventKind.ERROR : EventKind.WARNING;
}
/**
* Add an entry to a Map of symlinks, optionally reporting conflicts.
*
* @param map Manifest of runfile entries.
* @param path Path fragment to use as key in map.
* @param artifact Artifact to store in map. This may be null to indicate an empty file.
*/
public void put(Map<PathFragment, Artifact> map, PathFragment path, Artifact artifact) {
if (artifact != null && artifact.isMiddlemanArtifact() && eventHandler != null) {
eventHandler.handle(
Event.of(
EventKind.ERROR,
location,
"Runfiles must not contain middleman artifacts: " + artifact));
return;
}
Preconditions.checkArgument(
artifact == null || !artifact.isMiddlemanArtifact(), "%s", artifact);
if (policy != ConflictPolicy.IGNORE && map.containsKey(path)) {
// Previous and new entry might have value of null
Artifact previous = map.get(path);
if (!Objects.equals(previous, artifact)) {
String previousStr =
(previous == null) ? "empty file" : previous.getExecPath().toString();
String artifactStr =
(artifact == null) ? "empty file" : artifact.getExecPath().toString();
if (!previousStr.equals(artifactStr)) {
String message =
String.format(
"overwrote runfile %s, was symlink to %s, now symlink to %s",
path.getSafePathString(), previousStr, artifactStr);
eventHandler.handle(Event.of(eventKind, location, message));
}
}
}
map.put(path, artifact);
}
}
/**
* Builder for Runfiles objects.
*/
public static final class Builder {
/** This is set to the workspace name */
private final String prefix;
/**
* This must be COMPILE_ORDER because {@link #asMapWithoutRootSymlinks} overwrites earlier
* entries with later ones, so we want a post-order iteration.
*/
private final NestedSetBuilder<Artifact> artifactsBuilder = NestedSetBuilder.compileOrder();
private final NestedSetBuilder<SymlinkEntry> symlinksBuilder = NestedSetBuilder.stableOrder();
private final NestedSetBuilder<SymlinkEntry> rootSymlinksBuilder =
NestedSetBuilder.stableOrder();
private EmptyFilesSupplier emptyFilesSupplier = DUMMY_EMPTY_FILES_SUPPLIER;
/** Build the Runfiles object with this policy */
private ConflictPolicy conflictPolicy = ConflictPolicy.IGNORE;
private final boolean legacyExternalRunfiles;
/**
* Only used for Runfiles.EMPTY.
*/
private Builder() {
this.prefix = "";
this.legacyExternalRunfiles = false;
}
/**
* Creates a builder with the given suffix. Transitional constructor so that new rules don't
* accidentally depend on the legacy repository structure, until that option is removed.
*
* @param workspace is the string specified in workspace() in the WORKSPACE file.
*/
public Builder(String workspace) {
this(workspace, false);
}
/**
* Creates a builder with the given suffix.
*
* @param prefix is the string specified in workspace() in the WORKSPACE file.
* @param legacyExternalRunfiles if the wsname/external/repo symlinks should also be created.
*/
public Builder(String prefix, boolean legacyExternalRunfiles) {
this.prefix = prefix;
this.legacyExternalRunfiles = legacyExternalRunfiles;
}
/**
* Builds a new Runfiles object.
*/
public Runfiles build() {
return new Runfiles(
prefix,
artifactsBuilder.build(),
symlinksBuilder.build(),
rootSymlinksBuilder.build(),
emptyFilesSupplier,
conflictPolicy,
legacyExternalRunfiles);
}
/** Adds an artifact to the internal collection of artifacts. */
@CanIgnoreReturnValue
public Builder addArtifact(Artifact artifact) {
Preconditions.checkNotNull(artifact);
Preconditions.checkArgument(
!artifact.isMiddlemanArtifact(), "unexpected middleman artifact: %s", artifact);
artifactsBuilder.add(artifact);
return this;
}
/** Adds several artifacts to the internal collection. */
@CanIgnoreReturnValue
public Builder addArtifacts(Iterable<Artifact> artifacts) {
for (Artifact artifact : artifacts) {
addArtifact(artifact);
}
return this;
}
/** Adds a nested set to the internal collection. */
@CanIgnoreReturnValue
public Builder addTransitiveArtifacts(NestedSet<Artifact> artifacts) {
artifactsBuilder.addTransitive(artifacts);
return this;
}
/**
* Adds a nested set to the internal collection.
*
* <p>The nested set will become wrapped in stable order. Only use this when the set of
* artifacts will not have conflicting root relative paths, or the wrong artifact will end up in
* the runfiles tree.
*/
@CanIgnoreReturnValue
public Builder addTransitiveArtifactsWrappedInStableOrder(NestedSet<Artifact> artifacts) {
NestedSet<Artifact> wrappedArtifacts =
NestedSetBuilder.<Artifact>stableOrder().addTransitive(artifacts).build();
artifactsBuilder.addTransitive(wrappedArtifacts);
return this;
}
/** Adds a symlink. */
@CanIgnoreReturnValue
public Builder addSymlink(PathFragment link, Artifact target) {
symlinksBuilder.add(new SymlinkEntry(link, target));
return this;
}
/** Adds several symlinks. Neither keys nor values may be null. */
@CanIgnoreReturnValue
Builder addSymlinks(Map<PathFragment, Artifact> symlinks) {
for (Map.Entry<PathFragment, Artifact> symlink : symlinks.entrySet()) {
symlinksBuilder.add(new SymlinkEntry(symlink.getKey(), symlink.getValue()));
}
return this;
}
/** Adds several symlinks as a NestedSet. */
@CanIgnoreReturnValue
public Builder addSymlinks(NestedSet<SymlinkEntry> symlinks) {
symlinksBuilder.addTransitive(symlinks);
return this;
}
/** Adds a root symlink. */
@CanIgnoreReturnValue
public Builder addRootSymlink(PathFragment link, Artifact target) {
rootSymlinksBuilder.add(new SymlinkEntry(link, target));
return this;
}
/** Adds several root symlinks. Neither keys nor values may be null. */
@CanIgnoreReturnValue
public Builder addRootSymlinks(Map<PathFragment, Artifact> symlinks) {
for (Map.Entry<PathFragment, Artifact> symlink : symlinks.entrySet()) {
rootSymlinksBuilder.add(new SymlinkEntry(symlink.getKey(), symlink.getValue()));
}
return this;
}
/** Adds several root symlinks as a NestedSet. */
@CanIgnoreReturnValue
public Builder addRootSymlinks(NestedSet<SymlinkEntry> symlinks) {
rootSymlinksBuilder.addTransitive(symlinks);
return this;
}
/**
* Specify a function that can create additional manifest entries based on the input entries,
* see {@link EmptyFilesSupplier} for more details.
*/
@CanIgnoreReturnValue
public Builder setEmptyFilesSupplier(EmptyFilesSupplier supplier) {
emptyFilesSupplier = Preconditions.checkNotNull(supplier);
return this;
}
/**
* Merges runfiles from a given runfiles support.
*
* @param runfilesSupport the runfiles support to be merged in
*/
@CanIgnoreReturnValue
public Builder merge(@Nullable RunfilesSupport runfilesSupport) {
if (runfilesSupport == null) {
return this;
}
merge(runfilesSupport.getRunfiles());
return this;
}
/** Adds the other {@link Runfiles} object transitively. */
@CanIgnoreReturnValue
public Builder merge(Runfiles runfiles) {
// Propagate the most strict conflict checking from merged-in runfiles
if (runfiles.conflictPolicy.compareTo(conflictPolicy) > 0) {
conflictPolicy = runfiles.conflictPolicy;
}
if (runfiles.isEmpty()) {
return this;
}
// The prefix should be the same within any blaze build, except for the EMPTY runfiles, which
// may have an empty prefix, but that is covered above.
Preconditions.checkArgument(
prefix.equals(runfiles.prefix), "%s != %s", prefix, runfiles.prefix);
artifactsBuilder.addTransitive(runfiles.getArtifacts());
symlinksBuilder.addTransitive(runfiles.getSymlinks());
rootSymlinksBuilder.addTransitive(runfiles.getRootSymlinks());
if (emptyFilesSupplier == DUMMY_EMPTY_FILES_SUPPLIER) {
emptyFilesSupplier = runfiles.getEmptyFilesProvider();
} else {
EmptyFilesSupplier otherSupplier = runfiles.getEmptyFilesProvider();
Preconditions.checkState(
(otherSupplier == DUMMY_EMPTY_FILES_SUPPLIER)
|| emptyFilesSupplier.equals(otherSupplier));
}
return this;
}
/**
* Adds the runfiles for a particular target and visits the transitive closure of "srcs", "deps"
* and "data", collecting all of their respective runfiles.
*/
@CanIgnoreReturnValue
public Builder addRunfiles(
RuleContext ruleContext, Function<TransitiveInfoCollection, Runfiles> mapping) {
Preconditions.checkNotNull(mapping);
Preconditions.checkNotNull(ruleContext);
addDataDeps(ruleContext);
addNonDataDeps(ruleContext, mapping);
return this;
}
/**
* Adds the files specified by a mapping from the transitive info collection to the runfiles.
*
* <p>Dependencies in {@code srcs} and {@code deps} are considered.
*/
@CanIgnoreReturnValue
public Builder add(
RuleContext ruleContext, Function<TransitiveInfoCollection, Runfiles> mapping) {
Preconditions.checkNotNull(ruleContext);
Preconditions.checkNotNull(mapping);
for (TransitiveInfoCollection dep : getNonDataDeps(ruleContext)) {
Runfiles runfiles = mapping.apply(dep);
if (runfiles != null) {
merge(runfiles);
}
}
return this;
}
/** Collects runfiles from data dependencies of a target. */
@CanIgnoreReturnValue
public Builder addDataDeps(RuleContext ruleContext) {
addTargets(
getPrerequisites(ruleContext, "data"),
RunfilesProvider.DATA_RUNFILES,
ruleContext.getConfiguration().alwaysIncludeFilesToBuildInData());
return this;
}
/** Collects runfiles from "srcs" and "deps" of a target. */
@CanIgnoreReturnValue
Builder addNonDataDeps(
RuleContext ruleContext, Function<TransitiveInfoCollection, Runfiles> mapping) {
for (TransitiveInfoCollection target : getNonDataDeps(ruleContext)) {
addTargetExceptFileTargets(target, mapping);
}
return this;
}
@CanIgnoreReturnValue
public Builder addTargets(
Iterable<? extends TransitiveInfoCollection> targets,
Function<TransitiveInfoCollection, Runfiles> mapping,
boolean alwaysIncludeFilesToBuildInData) {
for (TransitiveInfoCollection target : targets) {
addTarget(target, mapping, alwaysIncludeFilesToBuildInData);
}
return this;
}
@CanIgnoreReturnValue
public Builder addTarget(
TransitiveInfoCollection target,
Function<TransitiveInfoCollection, Runfiles> mapping,
boolean alwaysIncludeFilesToBuildInData) {
return addTargetIncludingFileTargets(target, mapping, alwaysIncludeFilesToBuildInData);
}
@CanIgnoreReturnValue
private Builder addTargetExceptFileTargets(
TransitiveInfoCollection target, Function<TransitiveInfoCollection, Runfiles> mapping) {
Runfiles runfiles = mapping.apply(target);
if (runfiles != null) {
merge(runfiles);
}
return this;
}
private Builder addTargetIncludingFileTargets(
TransitiveInfoCollection target,
Function<TransitiveInfoCollection, Runfiles> mapping,
boolean alwaysIncludeFilesToBuildInData) {
if (target.getProvider(RunfilesProvider.class) == null
&& mapping == RunfilesProvider.DATA_RUNFILES) {
// RuleConfiguredTarget implements RunfilesProvider, so this will only be called on
// FileConfiguredTarget instances.
// TODO(bazel-team): This is a terrible hack. We should be able to make this go away
// by implementing RunfilesProvider on FileConfiguredTarget. We'd need to be mindful
// of the memory use, though, since we have a whole lot of FileConfiguredTarget instances.
addTransitiveArtifacts(target.getProvider(FileProvider.class).getFilesToBuild());
return this;
}
if (alwaysIncludeFilesToBuildInData && mapping == RunfilesProvider.DATA_RUNFILES) {
// Ensure that `DefaultInfo.files` of Starlark rules is merged in so that native rules
// interoperate well with idiomatic Starlark rules..
// https://bazel.build/extending/rules#runfiles_features_to_avoid
// Internal tests fail if the order of filesToBuild is preserved.
addTransitiveArtifacts(
NestedSetBuilder.<Artifact>stableOrder()
.addTransitive(target.getProvider(FileProvider.class).getFilesToBuild())
.build());
}
return addTargetExceptFileTargets(target, mapping);
}
private static Iterable<TransitiveInfoCollection> getNonDataDeps(RuleContext ruleContext) {
return Iterables.concat(
// TODO(bazel-team): This line shouldn't be here. Removing it requires that no rules have
// dependent rules in srcs (except for filegroups and such), but always in deps.
// TODO(bazel-team): DONT_CHECK is not optimal here. Rules that use split configs need to
// be changed not to call into here.
getPrerequisites(ruleContext, "srcs"), getPrerequisites(ruleContext, "deps"));
}
/**
* For the specified attribute "attributeName" (which must be of type list(label)), resolves all
* the labels into ConfiguredTargets (for the same configuration as this one) and returns them
* as a list.
*
* <p>If the rule does not have the specified attribute, returns the empty list.
*/
private static Iterable<? extends TransitiveInfoCollection> getPrerequisites(
RuleContext ruleContext, String attributeName) {
if (ruleContext.getRule().isAttrDefined(attributeName, BuildType.LABEL_LIST)) {
return ruleContext.getPrerequisites(attributeName);
} else {
return Collections.emptyList();
}
}
}
private static void verifyNestedSetDepthLimitHelper(
NestedSet<?> nestedSet, String name, int limit) throws EvalException {
if (nestedSet.getApproxDepth() > limit) {
throw Starlark.errorf(
"%s depset depth %d exceeds limit (%d)", name, nestedSet.getApproxDepth(), limit);
}
}
/**
* Checks that the depth of a Runfiles object's nested sets (artifacts, symlinks, root symlinks,
* extra middlemen) does not exceed Starlark's depset depth limit, as specified by {@code
* --nested_set_depth_limit}.
*