public HashCode getOutputHash(FileHashCache fileHashCache) throws IOException {
Hasher hasher = Hashing.md5().newHasher();
for (Path path : getRecordedPaths()) {
hasher.putBytes(fileHashCache.get(path).asBytes());
}
return hasher.hash();
}
private String etag(MarkdownFile srcmd, @Nullable MarkdownFile navmd) {
byte[] b = new byte[Constants.OBJECT_ID_LENGTH];
Hasher h = Hashing.sha1().newHasher();
h.putInt(ETAG_GEN);
renderer.getTemplateHash(SOY_FILE).writeBytesTo(b, 0, b.length);
h.putBytes(b);
if (navmd != null) {
navmd.id.copyRawTo(b, 0);
h.putBytes(b);
}
srcmd.id.copyRawTo(b, 0);
h.putBytes(b);
return h.hash().toString();
}
private static HashCode hashPath(Path file, final Hasher hasher) throws IOException {
byte[] tmpBuffer = new byte[512];
final InputStream in = Files.newInputStream(file);
for (int read = in.read(tmpBuffer); read > 0; read = in.read(tmpBuffer)) {
hasher.putBytes(tmpBuffer, 0, read);
}
final HashCode fileHash = hasher.hash();
in.close();
return fileHash;
}
@Override
public int read(@Nonnull final byte[] bytes, final int off, final int len) throws IOException {
int numRead = in.read(bytes, off, len);
if (numRead != -1) {
for (Hasher hasher : hashers.values()) {
hasher.putBytes(bytes, off, numRead);
}
count += numRead;
}
return numRead;
}
@Override
public int hashCode() {
HashFunction hf = Hashing.goodFastHash(32);
Hasher h = hf.newHasher();
h.putInt(slots.size());
for (int i = 0; i < slots.size(); i++) {
h.putInt(slots.get(i).size());
for (int j = 0; j < slots.size(); j++) {
h.putBytes(slots.get(i).get(j).getLowerRange());
h.putBytes(slots.get(i).get(j).getUpperRange());
}
}
return h.hash().asInt();
}
private void deserializeRule(DeserializationContext context, Build.Rule rulePb)
throws PackageDeserializationException, InterruptedException {
Location ruleLocation = EmptyLocation.INSTANCE;
RuleClass ruleClass = packageDeserializationEnvironment.getRuleClass(rulePb, ruleLocation);
Map<String, ParsedAttributeValue> attributeValues = new HashMap<>();
AttributesToDeserialize attrToDeserialize =
packageDeserializationEnvironment.attributesToDeserialize();
Hasher hasher = Hashing.md5().newHasher();
for (Build.Attribute attrPb : rulePb.getAttributeList()) {
Type<?> type = ruleClass.getAttributeByName(attrPb.getName()).getType();
attributeValues.put(attrPb.getName(), deserializeAttribute(type, attrPb));
if (attrToDeserialize.addSyntheticAttributeHash) {
// TODO(bazel-team): This might give false positives because of explicit vs implicit.
hasher.putBytes(attrPb.toByteArray());
}
}
AttributeContainerWithoutLocation attributeContainer =
new AttributeContainerWithoutLocation(ruleClass, hasher.hash());
Label ruleLabel = deserializeLabel(rulePb.getName());
try {
Rule rule =
createRuleWithParsedAttributeValues(
ruleClass,
ruleLabel,
context.packageBuilder,
ruleLocation,
attributeValues,
NullEventHandler.INSTANCE,
attributeContainer);
context.packageBuilder.addRule(rule);
// Remove the attribute after it is added to package in order to pass the validations
// and be able to compute all the outputs.
if (attrToDeserialize != DESERIALIZE_ALL_ATTRS) {
for (String attrName : attributeValues.keySet()) {
Attribute attribute = ruleClass.getAttributeByName(attrName);
if (!(attrToDeserialize.shouldKeepAttributeWithName.apply(attrName)
|| BuildType.isLabelType(attribute.getType()))) {
attributeContainer.clearIfNotLabel(attrName);
}
}
}
Preconditions.checkState(!rule.containsErrors());
} catch (NameConflictException | LabelSyntaxException e) {
throw new PackageDeserializationException(e);
}
}
private void putByteSquence(ByteSequence data, Hasher hasher) {
hasher.putBytes(data.getBackingArray(), data.offset(), data.length());
}
private Builder feed(byte[] bytes) {
hasher.putBytes(bytes);
return this;
}
private <T extends Value> HashCode taskHash(Task task) {
Hasher hasher = Hash.newHasher();
hasher.putBytes(smoothJarHash.asBytes());
hasher.putBytes(task.hash().asBytes());
return hasher.hash();
}