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
|
// 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.skyframe;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.MoreObjects;
import com.google.devtools.build.lib.actions.Artifact;
import com.google.devtools.build.lib.actions.cache.DigestUtils;
import com.google.devtools.build.lib.util.Preconditions;
import com.google.devtools.build.lib.vfs.FileStatus;
import com.google.devtools.build.lib.vfs.Path;
import java.io.IOException;
import java.util.Arrays;
import javax.annotation.Nullable;
/**
* Stores the actual metadata data of a file. We have the following cases:
* <ul><li>
* an ordinary file, in which case we would expect to see a digest and size;
* </li><li>
* a directory, in which case we would expect to see an mtime;
* </li><li>
* an intentionally omitted file which the build system is aware of but doesn't actually exist,
* where all access methods are unsupported;
* </li><li>
* The "self data" of a middleman artifact or TreeArtifact, where we would expect to see a digest
* representing the artifact's contents, and a size of 1.
* </li></ul>
*/
public class FileArtifactValue extends ArtifactValue {
/** Data for Middleman artifacts that did not have data specified. */
static final FileArtifactValue DEFAULT_MIDDLEMAN = new FileArtifactValue(null, 0, 0);
/** Data that marks that a file is not present on the filesystem. */
@VisibleForTesting
public static final FileArtifactValue MISSING_FILE_MARKER = new FileArtifactValue(null, 1, 0) {
@Override
public boolean exists() {
return false;
}
};
/**
* Represents an omitted file -- we are aware of it but it doesn't exist. All access methods
* are unsupported.
*/
static final FileArtifactValue OMITTED_FILE_MARKER = new FileArtifactValue(null, 2, 0) {
@Override public byte[] getDigest() { throw new UnsupportedOperationException(); }
@Override public boolean isFile() { throw new UnsupportedOperationException(); }
@Override public long getSize() { throw new UnsupportedOperationException(); }
@Override public long getModifiedTime() { throw new UnsupportedOperationException(); }
@Override public boolean equals(Object o) { return this == o; }
@Override public int hashCode() { return System.identityHashCode(this); }
@Override public String toString() { return "OMITTED_FILE_MARKER"; }
};
@Nullable private final byte[] digest;
private final long mtime;
private final long size;
private FileArtifactValue(byte[] digest, long size) {
this.digest = Preconditions.checkNotNull(digest, size);
this.size = size;
this.mtime = -1;
}
// Only used by directories (null digest).
private FileArtifactValue(byte[] digest, long mtime, long size) {
Preconditions.checkState(mtime >= 0, "mtime must be non-negative: %s %s", mtime, size);
Preconditions.checkState(size == 0, "size must be zero: %s %s", mtime, size);
Preconditions.checkState(digest == null, "digest must be null:");
this.digest = digest;
this.size = size;
this.mtime = mtime;
}
@VisibleForTesting
public static FileArtifactValue create(Artifact artifact) throws IOException {
Path path = artifact.getPath();
FileStatus stat = path.stat();
boolean isFile = stat.isFile();
return create(artifact, isFile, isFile ? stat.getSize() : 0, null);
}
static FileArtifactValue create(Artifact artifact, FileValue fileValue) throws IOException {
boolean isFile = fileValue.isFile();
return create(artifact, isFile, isFile ? fileValue.getSize() : 0,
isFile ? fileValue.getDigest() : null);
}
static FileArtifactValue create(Artifact artifact, boolean isFile, long size,
@Nullable byte[] digest) throws IOException {
if (isFile && digest == null) {
digest = DigestUtils.getDigestOrFail(artifact.getPath(), size);
}
if (!isFile) {
// In this case, we need to store the mtime because the action cache uses mtime for
// directories to determine if this artifact has changed. We want this code path to go away
// somehow (maybe by implementing FileSet in Skyframe).
return new FileArtifactValue(digest, artifact.getPath().getLastModifiedTime(), size);
}
Preconditions.checkState(digest != null, artifact);
return new FileArtifactValue(digest, size);
}
/**
* Creates a FileArtifactValue used as a 'proxy' input for other ArtifactValues.
* These are used in {@link com.google.devtools.build.lib.actions.ActionCacheChecker}.
*/
static FileArtifactValue createProxy(byte[] digest) {
Preconditions.checkNotNull(digest);
// The Middleman artifact values have size 1 because we want their digests to be used. This hack
// can be removed once empty files are digested.
return new FileArtifactValue(digest, /*size=*/1);
}
@Nullable
public byte[] getDigest() {
return digest;
}
/** @return true if this is a file or a symlink to an existing file */
boolean isFile() {
return digest != null;
}
/** Gets the size of the file. Directories have size 0. */
public long getSize() {
return size;
}
/** Gets last modified time of file. Should only be called if this is a directory. */
long getModifiedTime() {
Preconditions.checkState(size == 0 && digest == null, "%s %s %s", digest, mtime, size);
return mtime;
}
public boolean exists() {
return true;
}
@Override
public int hashCode() {
// Hash digest by content, not reference. Note that digest is the only array in this array.
return Arrays.deepHashCode(new Object[] {size, mtime, digest});
}
/**
* Two FileArtifactValues will only compare equal if they have the same content. This differs
* from the {@code Metadata#equivalence} method, which allows for comparison using mtime if
* one object does not have a digest available.
*/
@Override
public boolean equals(Object other) {
if (this == other) {
return true;
}
if (!(other instanceof FileArtifactValue)) {
return false;
}
FileArtifactValue that = (FileArtifactValue) other;
return this.mtime == that.mtime && this.size == that.size
&& Arrays.equals(this.digest, that.digest);
}
@Override
public String toString() {
return MoreObjects.toStringHelper(FileArtifactValue.class)
.add("digest", digest)
.add("mtime", mtime)
.add("size", size).toString();
}
}
|
