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
|
// Copyright 2014 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.buildtool;
import com.google.common.base.Joiner;
import com.google.devtools.build.lib.Constants;
import com.google.devtools.build.lib.analysis.config.BuildConfiguration;
import com.google.devtools.build.lib.events.Event;
import com.google.devtools.build.lib.events.EventHandler;
import com.google.devtools.build.lib.vfs.FileSystemUtils;
import com.google.devtools.build.lib.vfs.Path;
import com.google.devtools.build.lib.vfs.PathFragment;
import com.google.devtools.build.lib.vfs.Symlinks;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
/**
* Static utilities for managing output directory symlinks.
*/
public class OutputDirectoryLinksUtils {
public static final String OUTPUT_SYMLINK_NAME = Constants.PRODUCT_NAME + "-out";
// Used in getPrettyPath() method below.
private static final String[] LINKS = { "bin", "genfiles", "includes" };
private static final String NO_CREATE_SYMLINKS_PREFIX = "/";
private static String execRootSymlink(String workspaceName) {
return Constants.PRODUCT_NAME + "-" + workspaceName;
}
/**
* Attempts to create convenience symlinks in the workspaceDirectory and in
* execRoot to the output area and to the configuration-specific output
* directories. Issues a warning if it fails, e.g. because workspaceDirectory
* is readonly.
*/
public static void createOutputDirectoryLinks(String workspaceName,
Path workspace, Path execRoot, Path outputPath,
EventHandler eventHandler, BuildConfiguration targetConfig, String symlinkPrefix) {
if (NO_CREATE_SYMLINKS_PREFIX.equals(symlinkPrefix)) {
return;
}
List<String> failures = new ArrayList<>();
// Make the two non-specific links from the workspace to the output area,
// and the configuration-specific links in both the workspace and the execution root dirs.
// NB! Keep in sync with removeOutputDirectoryLinks below.
createLink(workspace, OUTPUT_SYMLINK_NAME, outputPath, failures);
// Points to execroot
createLink(workspace, execRootSymlink(workspaceName), execRoot, failures);
createLink(workspace, symlinkPrefix + "bin", targetConfig.getBinDirectory().getPath(),
failures);
createLink(workspace, symlinkPrefix + "testlogs", targetConfig.getTestLogsDirectory().getPath(),
failures);
createLink(workspace, symlinkPrefix + "genfiles", targetConfig.getGenfilesDirectory().getPath(),
failures);
if (!failures.isEmpty()) {
eventHandler.handle(Event.warn(String.format(
"failed to create one or more convenience symlinks for prefix '%s':\n %s",
symlinkPrefix, Joiner.on("\n ").join(failures))));
}
}
/**
* Returns a convenient path to the specified file, relativizing it and using output-dir symlinks
* if possible. Otherwise, return a path relative to the workspace directory if possible.
* Otherwise, return the absolute path.
*
* <p>This method must be called after the symlinks are created at the end of a build. If called
* before, the pretty path may be incorrect if the symlinks end up pointing somewhere new.
*/
public static PathFragment getPrettyPath(Path file, String workspaceName,
Path workspaceDirectory, String symlinkPrefix) {
for (String link : LINKS) {
PathFragment result = relativize(file, workspaceDirectory, symlinkPrefix + link);
if (result != null) {
return result;
}
}
PathFragment result = relativize(file, workspaceDirectory, execRootSymlink(workspaceName));
if (result != null) {
return result;
}
result = relativize(file, workspaceDirectory, OUTPUT_SYMLINK_NAME);
if (result != null) {
return result;
}
return file.asFragment();
}
// Helper to getPrettyPath. Returns file, relativized w.r.t. the referent of
// "linkname", or null if it was a not a child.
private static PathFragment relativize(Path file, Path workspaceDirectory, String linkname) {
PathFragment link = new PathFragment(linkname);
try {
Path dir = workspaceDirectory.getRelative(link);
PathFragment levelOneLinkTarget = dir.readSymbolicLink();
if (levelOneLinkTarget.isAbsolute() &&
file.startsWith(dir = file.getRelative(levelOneLinkTarget))) {
return link.getRelative(file.relativeTo(dir));
}
} catch (IOException e) {
/* ignore */
}
return null;
}
/**
* Attempts to remove the convenience symlinks in the workspace directory.
*
* <p>Issues a warning if it fails, e.g. because workspaceDirectory is readonly.
* Also cleans up any child directories created by a custom prefix.
*
* @param workspace the runtime's workspace
* @param eventHandler the error eventHandler
* @param symlinkPrefix the symlink prefix which should be removed
*/
public static void removeOutputDirectoryLinks(String workspaceName, Path workspace,
EventHandler eventHandler, String symlinkPrefix) {
if (NO_CREATE_SYMLINKS_PREFIX.equals(symlinkPrefix)) {
return;
}
List<String> failures = new ArrayList<>();
removeLink(workspace, OUTPUT_SYMLINK_NAME, failures);
removeLink(workspace, execRootSymlink(workspaceName), failures);
removeLink(workspace, symlinkPrefix + "bin", failures);
removeLink(workspace, symlinkPrefix + "testlogs", failures);
removeLink(workspace, symlinkPrefix + "genfiles", failures);
FileSystemUtils.removeDirectoryAndParents(workspace, new PathFragment(symlinkPrefix));
if (!failures.isEmpty()) {
eventHandler.handle(Event.warn(String.format(
"failed to remove one or more convenience symlinks for prefix '%s':\n %s", symlinkPrefix,
Joiner.on("\n ").join(failures))));
}
}
/**
* Helper to createOutputDirectoryLinks that creates a symlink from base + name to target.
*/
private static boolean createLink(Path base, String name, Path target, List<String> failures) {
try {
FileSystemUtils.ensureSymbolicLink(base.getRelative(name), target);
return true;
} catch (IOException e) {
failures.add(String.format("%s -> %s: %s", name, target.getPathString(), e.getMessage()));
return false;
}
}
/**
* Helper to removeOutputDirectoryLinks that removes one of the Blaze convenience symbolic links.
*/
private static boolean removeLink(Path base, String name, List<String> failures) {
Path link = base.getRelative(name);
try {
if (link.exists(Symlinks.NOFOLLOW)) {
ExecutionTool.LOG.finest("Removing " + link);
link.delete();
}
return true;
} catch (IOException e) {
failures.add(String.format("%s: %s", name, e.getMessage()));
return false;
}
}
}
|
