java/com/google/gerrit/server/change/MergeabilityCacheImpl.java - gerrit - Git at Google

 // Copyright (C) 2014 The Android Open Source Project
 //
 // 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.gerrit.server.change;

 import static com.google.common.base.Preconditions.checkArgument;
 import static com.google.common.base.Preconditions.checkNotNull;

 import com.google.common.base.Converter;
 import com.google.common.base.Enums;
 import com.google.common.base.MoreObjects;
 import com.google.common.cache.Cache;
 import com.google.common.cache.Weigher;
 import com.google.common.util.concurrent.UncheckedExecutionException;
 import com.google.gerrit.extensions.client.SubmitType;
 import com.google.gerrit.reviewdb.client.Branch;
 import com.google.gerrit.server.cache.BooleanCacheSerializer;
 import com.google.gerrit.server.cache.CacheModule;
 import com.google.gerrit.server.cache.CacheSerializer;
 import com.google.gerrit.server.cache.ProtoCacheSerializers;
 import com.google.gerrit.server.cache.proto.Cache.MergeabilityKeyProto;
 import com.google.gerrit.server.git.CodeReviewCommit;
 import com.google.gerrit.server.git.CodeReviewCommit.CodeReviewRevWalk;
 import com.google.gerrit.server.submit.SubmitDryRun;
 import com.google.inject.Inject;
 import com.google.inject.Module;
 import com.google.inject.Singleton;
 import com.google.inject.name.Named;
 import com.google.protobuf.ByteString;
 import java.io.IOException;
 import java.util.Arrays;
 import java.util.Objects;
 import java.util.Set;
 import java.util.concurrent.ExecutionException;
 import org.eclipse.jgit.lib.Constants;
 import org.eclipse.jgit.lib.ObjectId;
 import org.eclipse.jgit.lib.Ref;
 import org.eclipse.jgit.lib.Repository;
 import org.eclipse.jgit.revwalk.RevCommit;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;

 @Singleton
 public class MergeabilityCacheImpl implements MergeabilityCache {
   private static final Logger log = LoggerFactory.getLogger(MergeabilityCacheImpl.class);

   private static final String CACHE_NAME = "mergeability";

   public static Module module() {
     return new CacheModule() {
       @Override
       protected void configure() {
         persist(CACHE_NAME, EntryKey.class, Boolean.class)
             .maximumWeight(1 << 20)
             .weigher(MergeabilityWeigher.class)
             .version(1)
             .keySerializer(EntryKey.Serializer.INSTANCE)
             .valueSerializer(BooleanCacheSerializer.INSTANCE);
         bind(MergeabilityCache.class).to(MergeabilityCacheImpl.class);
       }
     };
   }

   public static ObjectId toId(Ref ref) {
     return ref != null && ref.getObjectId() != null ? ref.getObjectId() : ObjectId.zeroId();
   }

   public static class EntryKey {
     private ObjectId commit;
     private ObjectId into;
     private SubmitType submitType;
     private String mergeStrategy;

     public EntryKey(ObjectId commit, ObjectId into, SubmitType submitType, String mergeStrategy) {
       checkArgument(
           submitType != SubmitType.INHERIT,
           "Cannot cache %s.%s",
           SubmitType.class.getSimpleName(),
           submitType);
       this.commit = checkNotNull(commit, "commit");
       this.into = checkNotNull(into, "into");
       this.submitType = checkNotNull(submitType, "submitType");
       this.mergeStrategy = checkNotNull(mergeStrategy, "mergeStrategy");
     }

     public ObjectId getCommit() {
       return commit;
     }

     public ObjectId getInto() {
       return into;
     }

     public SubmitType getSubmitType() {
       return submitType;
     }

     public String getMergeStrategy() {
       return mergeStrategy;
     }

     @Override
     public boolean equals(Object o) {
       if (o instanceof EntryKey) {
         EntryKey k = (EntryKey) o;
         return commit.equals(k.commit)
             && into.equals(k.into)
             && submitType == k.submitType
             && mergeStrategy.equals(k.mergeStrategy);
       }
       return false;
     }

     @Override
     public int hashCode() {
       return Objects.hash(commit, into, submitType, mergeStrategy);
     }

     @Override
     public String toString() {
       return MoreObjects.toStringHelper(this)
           .add("commit", commit.name())
           .add("into", into.name())
           .addValue(submitType)
           .addValue(mergeStrategy)
           .toString();
     }

     static enum Serializer implements CacheSerializer<EntryKey> {
       INSTANCE;

       private static final Converter<String, SubmitType> SUBMIT_TYPE_CONVERTER =
           Enums.stringConverter(SubmitType.class);

       @Override
       public byte[] serialize(EntryKey object) {
         byte[] buf = new byte[Constants.OBJECT_ID_LENGTH];
         MergeabilityKeyProto.Builder b = MergeabilityKeyProto.newBuilder();
         object.getCommit().copyRawTo(buf, 0);
         b.setCommit(ByteString.copyFrom(buf));
         object.getInto().copyRawTo(buf, 0);
         b.setInto(ByteString.copyFrom(buf));
         b.setSubmitType(SUBMIT_TYPE_CONVERTER.reverse().convert(object.getSubmitType()));
         b.setMergeStrategy(object.getMergeStrategy());
         return ProtoCacheSerializers.toByteArray(b.build());
       }

       @Override
       public EntryKey deserialize(byte[] in) {
         MergeabilityKeyProto proto;
         try {
           proto = MergeabilityKeyProto.parseFrom(in);
         } catch (IOException e) {
           throw new IllegalArgumentException("Failed to deserialize mergeability cache key");
         }
         byte[] buf = new byte[Constants.OBJECT_ID_LENGTH];
         proto.getCommit().copyTo(buf, 0);
         ObjectId commit = ObjectId.fromRaw(buf);
         proto.getInto().copyTo(buf, 0);
         ObjectId into = ObjectId.fromRaw(buf);
         return new EntryKey(
             commit,
             into,
             SUBMIT_TYPE_CONVERTER.convert(proto.getSubmitType()),
             proto.getMergeStrategy());
       }
     }
   }

   public static class MergeabilityWeigher implements Weigher<EntryKey, Boolean> {
     @Override
     public int weigh(EntryKey k, Boolean v) {
       return 16
           + 2 * (16 + 20)
           + 3 * 8 // Size of EntryKey, 64-bit JVM.
           + 8; // Size of Boolean.
     }
   }

   private final SubmitDryRun submitDryRun;
   private final Cache<EntryKey, Boolean> cache;

   @Inject
   MergeabilityCacheImpl(
       SubmitDryRun submitDryRun, @Named(CACHE_NAME) Cache<EntryKey, Boolean> cache) {
     this.submitDryRun = submitDryRun;
     this.cache = cache;
   }

   @Override
   public boolean get(
       ObjectId commit,
       Ref intoRef,
       SubmitType submitType,
       String mergeStrategy,
       Branch.NameKey dest,
       Repository repo) {
     ObjectId into = intoRef != null ? intoRef.getObjectId() : ObjectId.zeroId();
     EntryKey key = new EntryKey(commit, into, submitType, mergeStrategy);
     try {
       return cache.get(
           key,
           () -> {
             if (key.into.equals(ObjectId.zeroId())) {
               return true; // Assume yes on new branch.
             }
             try (CodeReviewRevWalk rw = CodeReviewCommit.newRevWalk(repo)) {
               Set<RevCommit> accepted = SubmitDryRun.getAlreadyAccepted(repo, rw);
               accepted.add(rw.parseCommit(key.into));
               accepted.addAll(Arrays.asList(rw.parseCommit(key.commit).getParents()));
               return submitDryRun.run(
                   key.submitType, repo, rw, dest, key.into, key.commit, accepted);
             }
           });
     } catch (ExecutionException | UncheckedExecutionException e) {
       log.error(
           String.format(
               "Error checking mergeability of %s into %s (%s)",
               key.commit.name(), key.into.name(), key.submitType.name()),
           e.getCause());
       return false;
     }
   }

   @Override
   public Boolean getIfPresent(
       ObjectId commit, Ref intoRef, SubmitType submitType, String mergeStrategy) {
     return cache.getIfPresent(new EntryKey(commit, toId(intoRef), submitType, mergeStrategy));
   }
 }
	// Copyright (C) 2014 The Android Open Source Project
	//
	// 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.gerrit.server.change;

	import static com.google.common.base.Preconditions.checkArgument;
	import static com.google.common.base.Preconditions.checkNotNull;

	import com.google.common.base.Converter;
	import com.google.common.base.Enums;
	import com.google.common.base.MoreObjects;
	import com.google.common.cache.Cache;
	import com.google.common.cache.Weigher;
	import com.google.common.util.concurrent.UncheckedExecutionException;
	import com.google.gerrit.extensions.client.SubmitType;
	import com.google.gerrit.reviewdb.client.Branch;
	import com.google.gerrit.server.cache.BooleanCacheSerializer;
	import com.google.gerrit.server.cache.CacheModule;
	import com.google.gerrit.server.cache.CacheSerializer;
	import com.google.gerrit.server.cache.ProtoCacheSerializers;
	import com.google.gerrit.server.cache.proto.Cache.MergeabilityKeyProto;
	import com.google.gerrit.server.git.CodeReviewCommit;
	import com.google.gerrit.server.git.CodeReviewCommit.CodeReviewRevWalk;
	import com.google.gerrit.server.submit.SubmitDryRun;
	import com.google.inject.Inject;
	import com.google.inject.Module;
	import com.google.inject.Singleton;
	import com.google.inject.name.Named;
	import com.google.protobuf.ByteString;
	import java.io.IOException;
	import java.util.Arrays;
	import java.util.Objects;
	import java.util.Set;
	import java.util.concurrent.ExecutionException;
	import org.eclipse.jgit.lib.Constants;
	import org.eclipse.jgit.lib.ObjectId;
	import org.eclipse.jgit.lib.Ref;
	import org.eclipse.jgit.lib.Repository;
	import org.eclipse.jgit.revwalk.RevCommit;
	import org.slf4j.Logger;
	import org.slf4j.LoggerFactory;

	@Singleton
	public class MergeabilityCacheImpl implements MergeabilityCache {
	private static final Logger log = LoggerFactory.getLogger(MergeabilityCacheImpl.class);

	private static final String CACHE_NAME = "mergeability";

	public static Module module() {
	return new CacheModule() {
	@Override
	protected void configure() {
	persist(CACHE_NAME, EntryKey.class, Boolean.class)
	.maximumWeight(1 << 20)
	.weigher(MergeabilityWeigher.class)
	.version(1)
	.keySerializer(EntryKey.Serializer.INSTANCE)
	.valueSerializer(BooleanCacheSerializer.INSTANCE);
	bind(MergeabilityCache.class).to(MergeabilityCacheImpl.class);
	}
	};
	}

	public static ObjectId toId(Ref ref) {
	return ref != null && ref.getObjectId() != null ? ref.getObjectId() : ObjectId.zeroId();
	}

	public static class EntryKey {
	private ObjectId commit;
	private ObjectId into;
	private SubmitType submitType;
	private String mergeStrategy;

	public EntryKey(ObjectId commit, ObjectId into, SubmitType submitType, String mergeStrategy) {
	checkArgument(
	submitType != SubmitType.INHERIT,
	"Cannot cache %s.%s",
	SubmitType.class.getSimpleName(),
	submitType);
	this.commit = checkNotNull(commit, "commit");
	this.into = checkNotNull(into, "into");
	this.submitType = checkNotNull(submitType, "submitType");
	this.mergeStrategy = checkNotNull(mergeStrategy, "mergeStrategy");
	}

	public ObjectId getCommit() {
	return commit;
	}

	public ObjectId getInto() {
	return into;
	}

	public SubmitType getSubmitType() {
	return submitType;
	}

	public String getMergeStrategy() {
	return mergeStrategy;
	}

	@Override
	public boolean equals(Object o) {
	if (o instanceof EntryKey) {
	EntryKey k = (EntryKey) o;
	return commit.equals(k.commit)
	&& into.equals(k.into)
	&& submitType == k.submitType
	&& mergeStrategy.equals(k.mergeStrategy);
	}
	return false;
	}

	@Override
	public int hashCode() {
	return Objects.hash(commit, into, submitType, mergeStrategy);
	}

	@Override
	public String toString() {
	return MoreObjects.toStringHelper(this)
	.add("commit", commit.name())
	.add("into", into.name())
	.addValue(submitType)
	.addValue(mergeStrategy)
	.toString();
	}

	static enum Serializer implements CacheSerializer<EntryKey> {
	INSTANCE;

	private static final Converter<String, SubmitType> SUBMIT_TYPE_CONVERTER =
	Enums.stringConverter(SubmitType.class);

	@Override
	public byte[] serialize(EntryKey object) {
	byte[] buf = new byte[Constants.OBJECT_ID_LENGTH];
	MergeabilityKeyProto.Builder b = MergeabilityKeyProto.newBuilder();
	object.getCommit().copyRawTo(buf, 0);
	b.setCommit(ByteString.copyFrom(buf));
	object.getInto().copyRawTo(buf, 0);
	b.setInto(ByteString.copyFrom(buf));
	b.setSubmitType(SUBMIT_TYPE_CONVERTER.reverse().convert(object.getSubmitType()));
	b.setMergeStrategy(object.getMergeStrategy());
	return ProtoCacheSerializers.toByteArray(b.build());
	}

	@Override
	public EntryKey deserialize(byte[] in) {
	MergeabilityKeyProto proto;
	try {
	proto = MergeabilityKeyProto.parseFrom(in);
	} catch (IOException e) {
	throw new IllegalArgumentException("Failed to deserialize mergeability cache key");
	}
	byte[] buf = new byte[Constants.OBJECT_ID_LENGTH];
	proto.getCommit().copyTo(buf, 0);
	ObjectId commit = ObjectId.fromRaw(buf);
	proto.getInto().copyTo(buf, 0);
	ObjectId into = ObjectId.fromRaw(buf);
	return new EntryKey(
	commit,
	into,
	SUBMIT_TYPE_CONVERTER.convert(proto.getSubmitType()),
	proto.getMergeStrategy());
	}
	}
	}

	public static class MergeabilityWeigher implements Weigher<EntryKey, Boolean> {
	@Override
	public int weigh(EntryKey k, Boolean v) {
	return 16
	+ 2 * (16 + 20)
	+ 3 * 8 // Size of EntryKey, 64-bit JVM.
	+ 8; // Size of Boolean.
	}
	}

	private final SubmitDryRun submitDryRun;
	private final Cache<EntryKey, Boolean> cache;

	@Inject
	MergeabilityCacheImpl(
	SubmitDryRun submitDryRun, @Named(CACHE_NAME) Cache<EntryKey, Boolean> cache) {
	this.submitDryRun = submitDryRun;
	this.cache = cache;
	}

	@Override
	public boolean get(
	ObjectId commit,
	Ref intoRef,
	SubmitType submitType,
	String mergeStrategy,
	Branch.NameKey dest,
	Repository repo) {
	ObjectId into = intoRef != null ? intoRef.getObjectId() : ObjectId.zeroId();
	EntryKey key = new EntryKey(commit, into, submitType, mergeStrategy);
	try {
	return cache.get(
	key,
	() -> {
	if (key.into.equals(ObjectId.zeroId())) {
	return true; // Assume yes on new branch.
	}
	try (CodeReviewRevWalk rw = CodeReviewCommit.newRevWalk(repo)) {
	Set<RevCommit> accepted = SubmitDryRun.getAlreadyAccepted(repo, rw);
	accepted.add(rw.parseCommit(key.into));
	accepted.addAll(Arrays.asList(rw.parseCommit(key.commit).getParents()));
	return submitDryRun.run(
	key.submitType, repo, rw, dest, key.into, key.commit, accepted);
	}
	});
	} catch (ExecutionException \| UncheckedExecutionException e) {
	log.error(
	String.format(
	"Error checking mergeability of %s into %s (%s)",
	key.commit.name(), key.into.name(), key.submitType.name()),
	e.getCause());
	return false;
	}
	}

	@Override
	public Boolean getIfPresent(
	ObjectId commit, Ref intoRef, SubmitType submitType, String mergeStrategy) {
	return cache.getIfPresent(new EntryKey(commit, toId(intoRef), submitType, mergeStrategy));
	}
	}