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
|
// Copyright 2014 Google Inc. 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.packages;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Maps;
import com.google.devtools.build.lib.events.Location;
import com.google.devtools.build.lib.events.StoredEventHandler;
import com.google.devtools.build.lib.packages.PackageIdentifier.RepositoryName;
import com.google.devtools.build.lib.packages.RuleFactory.InvalidRuleException;
import com.google.devtools.build.lib.syntax.EvalException;
import com.google.devtools.build.lib.syntax.FuncallExpression;
import com.google.devtools.build.lib.syntax.Label;
import com.google.devtools.build.lib.syntax.Label.SyntaxException;
import com.google.devtools.build.lib.vfs.Path;
import java.util.Map;
import java.util.Map.Entry;
/**
* This creates the //external package, where targets not homed in this repository can be bound.
*/
public class ExternalPackage extends Package {
private Map<RepositoryName, Rule> repositoryMap;
ExternalPackage() {
super(PackageIdentifier.createInDefaultRepo("external"));
}
/**
* Returns a description of the repository with the given name, or null if there's no such
* repository.
*/
public Rule getRepositoryInfo(RepositoryName repositoryName) {
return repositoryMap.get(repositoryName);
}
/**
* Holder for a binding's actual label and location.
*/
public static class Binding {
private final Label actual;
private final Location location;
public Binding(Label actual, Location location) {
this.actual = actual;
this.location = location;
}
public Label getActual() {
return actual;
}
public Location getLocation() {
return location;
}
/**
* Checks if the label is bound, i.e., starts with //external:.
*/
public static boolean isBoundLabel(Label label) {
return label.getPackageName().equals("external");
}
}
/**
* Given a workspace file path, creates an ExternalPackage.
*/
public static class ExternalPackageBuilder
extends AbstractBuilder<ExternalPackage, ExternalPackageBuilder> {
private Map<Label, Binding> bindMap = Maps.newHashMap();
private Map<RepositoryName, Rule> repositoryMap = Maps.newHashMap();
public ExternalPackageBuilder(Path workspacePath) {
super(new ExternalPackage());
setFilename(workspacePath);
setMakeEnv(new MakeEnvironment.Builder());
}
@Override
protected ExternalPackageBuilder self() {
return this;
}
@Override
public ExternalPackage build() {
pkg.repositoryMap = ImmutableMap.copyOf(repositoryMap);
return super.build();
}
public void addBinding(Label label, Binding binding) {
bindMap.put(label, binding);
}
public void resolveBindTargets(RuleClass ruleClass)
throws EvalException, NoSuchBindingException {
for (Entry<Label, Binding> entry : bindMap.entrySet()) {
resolveLabel(entry.getKey(), entry.getValue());
}
for (Entry<Label, Binding> entry : bindMap.entrySet()) {
try {
addRule(ruleClass, entry);
} catch (NameConflictException | InvalidRuleException e) {
throw new EvalException(entry.getValue().location, e.getMessage());
}
}
}
// Uses tortoise and the hare algorithm to detect cycles.
private void resolveLabel(final Label virtual, Binding binding)
throws NoSuchBindingException {
Label actual = binding.getActual();
Label tortoise = virtual;
Label hare = actual;
boolean moveTortoise = true;
while (Binding.isBoundLabel(actual)) {
if (tortoise == hare) {
throw new NoSuchBindingException("cycle detected resolving " + virtual + " binding");
}
Label previous = actual; // For the exception.
binding = bindMap.get(actual);
if (binding == null) {
throw new NoSuchBindingException("no binding found for target " + previous + " (via "
+ virtual + ")");
}
actual = binding.getActual();
hare = actual;
moveTortoise = !moveTortoise;
if (moveTortoise) {
tortoise = bindMap.get(tortoise).getActual();
}
}
bindMap.put(virtual, binding);
}
private void addRule(RuleClass klass, Map.Entry<Label, Binding> bindingEntry)
throws InvalidRuleException, NameConflictException {
Label virtual = bindingEntry.getKey();
Label actual = bindingEntry.getValue().actual;
Location location = bindingEntry.getValue().location;
Map<String, Object> attributes = Maps.newHashMap();
// Bound rules don't have a name field, but this works because we don't want more than one
// with the same virtual name.
attributes.put("name", virtual.getName());
attributes.put("actual", actual);
StoredEventHandler handler = new StoredEventHandler();
Rule rule = RuleFactory.createAndAddRule(this, klass, attributes, handler, null, location);
rule.setVisibility(ConstantRuleVisibility.PUBLIC);
}
/**
* This is used when a binding is invalid, either because one of the targets is malformed,
* refers to a package that does not exist, or creates a circular dependency.
*/
public class NoSuchBindingException extends NoSuchThingException {
public NoSuchBindingException(String message) {
super(message);
}
}
/**
* Creates an external repository rule.
* @throws SyntaxException if the repository name is invalid.
*/
public ExternalPackageBuilder createAndAddRepositoryRule(RuleClass ruleClass,
Map<String, Object> kwargs, FuncallExpression ast)
throws InvalidRuleException, NameConflictException, SyntaxException {
StoredEventHandler eventHandler = new StoredEventHandler();
Rule rule = RuleFactory.createAndAddRule(this, ruleClass, kwargs, eventHandler, ast,
ast.getLocation());
// Propagate Rule errors to the builder.
addEvents(eventHandler.getEvents());
repositoryMap.put(RepositoryName.create("@" + rule.getName()), rule);
return this;
}
}
}
|
