gerrit-server/src/main/java/com/google/gerrit/server/ChangeUtil.java - gerrit - Git at Google

 // Copyright (C) 2009 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;

 import static com.google.gerrit.server.query.change.ChangeData.asChanges;

 import com.google.common.base.Function;
 import com.google.common.base.Optional;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Ordering;
 import com.google.gerrit.common.TimeUtil;
 import com.google.gerrit.extensions.restapi.ResourceConflictException;
 import com.google.gerrit.extensions.restapi.ResourceNotFoundException;
 import com.google.gerrit.extensions.restapi.RestApiException;
 import com.google.gerrit.reviewdb.client.Change;
 import com.google.gerrit.reviewdb.client.ChangeMessage;
 import com.google.gerrit.reviewdb.client.PatchSet;
 import com.google.gerrit.reviewdb.client.Project;
 import com.google.gerrit.reviewdb.server.ReviewDb;
 import com.google.gerrit.server.change.ChangeInserter;
 import com.google.gerrit.server.change.ChangeMessages;
 import com.google.gerrit.server.change.ChangeTriplet;
 import com.google.gerrit.server.extensions.events.GitReferenceUpdated;
 import com.google.gerrit.server.git.BatchUpdate;
 import com.google.gerrit.server.git.GitRepositoryManager;
 import com.google.gerrit.server.git.UpdateException;
 import com.google.gerrit.server.git.validators.CommitValidators;
 import com.google.gerrit.server.index.ChangeIndexer;
 import com.google.gerrit.server.mail.RevertedSender;
 import com.google.gerrit.server.notedb.ChangeUpdate;
 import com.google.gerrit.server.project.ChangeControl;
 import com.google.gerrit.server.project.NoSuchChangeException;
 import com.google.gerrit.server.project.RefControl;
 import com.google.gerrit.server.query.change.InternalChangeQuery;
 import com.google.gerrit.server.util.IdGenerator;
 import com.google.gwtorm.server.OrmConcurrencyException;
 import com.google.gwtorm.server.OrmException;
 import com.google.inject.Inject;
 import com.google.inject.Provider;
 import com.google.inject.Singleton;

 import org.eclipse.jgit.errors.IncorrectObjectTypeException;
 import org.eclipse.jgit.errors.MissingObjectException;
 import org.eclipse.jgit.errors.RepositoryNotFoundException;
 import org.eclipse.jgit.lib.BatchRefUpdate;
 import org.eclipse.jgit.lib.CommitBuilder;
 import org.eclipse.jgit.lib.NullProgressMonitor;
 import org.eclipse.jgit.lib.ObjectId;
 import org.eclipse.jgit.lib.ObjectInserter;
 import org.eclipse.jgit.lib.PersonIdent;
 import org.eclipse.jgit.lib.Ref;
 import org.eclipse.jgit.lib.RefDatabase;
 import org.eclipse.jgit.lib.RefUpdate;
 import org.eclipse.jgit.lib.Repository;
 import org.eclipse.jgit.revwalk.RevCommit;
 import org.eclipse.jgit.revwalk.RevWalk;
 import org.eclipse.jgit.transport.ReceiveCommand;
 import org.eclipse.jgit.util.ChangeIdUtil;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;

 import java.io.IOException;
 import java.text.MessageFormat;
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;

 @Singleton
 public class ChangeUtil {
   private static final Object uuidLock = new Object();
   private static final int SEED = 0x2418e6f9;
   private static int uuidPrefix;
   private static int uuidSeq;

   private static final int SUBJECT_MAX_LENGTH = 80;
   private static final String SUBJECT_CROP_APPENDIX = "...";
   private static final int SUBJECT_CROP_RANGE = 10;

   private static final Logger log =
       LoggerFactory.getLogger(ChangeUtil.class);

   public static final Function<PatchSet, Integer> TO_PS_ID =
       new Function<PatchSet, Integer>() {
         @Override
         public Integer apply(PatchSet in) {
           return in.getId().get();
         }
       };

   public static final Ordering<PatchSet> PS_ID_ORDER = Ordering.natural()
     .onResultOf(TO_PS_ID);

   /**
    * Generate a new unique identifier for change message entities.
    *
    * @param db the database connection, used to increment the change message
    *        allocation sequence.
    * @return the new unique identifier.
    * @throws OrmException the database couldn't be incremented.
    */
   public static String messageUUID(ReviewDb db) throws OrmException {
     int p;
     int s;
     synchronized (uuidLock) {
       if (uuidSeq == 0) {
         uuidPrefix = db.nextChangeMessageId();
         uuidSeq = Integer.MAX_VALUE;
       }
       p = uuidPrefix;
       s = uuidSeq--;
     }
     String u = IdGenerator.format(IdGenerator.mix(SEED, p));
     String l = IdGenerator.format(IdGenerator.mix(p, s));
     return u + '_' + l;
   }

   public static void touch(Change change, ReviewDb db)
       throws OrmException {
     try {
       updated(change);
       db.changes().update(Collections.singleton(change));
     } catch (OrmConcurrencyException e) {
       // Ignore a concurrent update, we just wanted to tag it as newer.
     }
   }

   public static void bumpRowVersionNotLastUpdatedOn(Change.Id id, ReviewDb db)
       throws OrmException {
     // Empty update of Change to bump rowVersion, changing its ETag.
     Change c = db.changes().get(id);
     if (c != null) {
       db.changes().update(Collections.singleton(c));
     }
   }

   public static void updated(Change c) {
     c.setLastUpdatedOn(TimeUtil.nowTs());
   }

   public static PatchSet.Id nextPatchSetId(Map<String, Ref> allRefs,
       PatchSet.Id id) {
     PatchSet.Id next = nextPatchSetId(id);
     while (allRefs.containsKey(next.toRefName())) {
       next = nextPatchSetId(next);
     }
     return next;
   }

   public static PatchSet.Id nextPatchSetId(Repository git, PatchSet.Id id)
       throws IOException {
     return nextPatchSetId(git.getRefDatabase().getRefs(RefDatabase.ALL), id);
   }

   public static String cropSubject(String subject) {
     if (subject.length() > SUBJECT_MAX_LENGTH) {
       int maxLength = SUBJECT_MAX_LENGTH - SUBJECT_CROP_APPENDIX.length();
       for (int cropPosition = maxLength;
           cropPosition > maxLength - SUBJECT_CROP_RANGE; cropPosition--) {
         if (Character.isWhitespace(subject.charAt(cropPosition - 1))) {
           return subject.substring(0, cropPosition) + SUBJECT_CROP_APPENDIX;
         }
       }
       return subject.substring(0, maxLength) + SUBJECT_CROP_APPENDIX;
     }
     return subject;
   }

   private final Provider<IdentifiedUser> user;
   private final Provider<ReviewDb> db;
   private final Provider<InternalChangeQuery> queryProvider;
   private final RevertedSender.Factory revertedSenderFactory;
   private final ChangeInserter.Factory changeInserterFactory;
   private final GitRepositoryManager gitManager;
   private final GitReferenceUpdated gitRefUpdated;
   private final ChangeIndexer indexer;
   private final BatchUpdate.Factory updateFactory;
   private final ChangeMessagesUtil changeMessagesUtil;
   private final ChangeUpdate.Factory changeUpdateFactory;

   @Inject
   ChangeUtil(Provider<IdentifiedUser> user,
       Provider<ReviewDb> db,
       Provider<InternalChangeQuery> queryProvider,
       RevertedSender.Factory revertedSenderFactory,
       ChangeInserter.Factory changeInserterFactory,
       GitRepositoryManager gitManager,
       GitReferenceUpdated gitRefUpdated,
       ChangeIndexer indexer,
       BatchUpdate.Factory updateFactory,
       ChangeMessagesUtil changeMessagesUtil,
       ChangeUpdate.Factory changeUpdateFactory) {
     this.user = user;
     this.db = db;
     this.queryProvider = queryProvider;
     this.revertedSenderFactory = revertedSenderFactory;
     this.changeInserterFactory = changeInserterFactory;
     this.gitManager = gitManager;
     this.gitRefUpdated = gitRefUpdated;
     this.indexer = indexer;
     this.updateFactory = updateFactory;
     this.changeMessagesUtil = changeMessagesUtil;
     this.changeUpdateFactory = changeUpdateFactory;
   }

   public Change.Id revert(ChangeControl ctl, PatchSet.Id patchSetId,
       String message, PersonIdent myIdent)
       throws NoSuchChangeException, OrmException,
       MissingObjectException, IncorrectObjectTypeException, IOException,
       RestApiException, UpdateException {
     Change.Id changeId = patchSetId.getParentKey();
     PatchSet patch = db.get().patchSets().get(patchSetId);
     if (patch == null) {
       throw new NoSuchChangeException(changeId);
     }
     Change changeToRevert = db.get().changes().get(changeId);

     Project.NameKey project = ctl.getChange().getProject();
     try (Repository git = gitManager.openRepository(project);
         RevWalk revWalk = new RevWalk(git)) {
       RevCommit commitToRevert =
           revWalk.parseCommit(ObjectId.fromString(patch.getRevision().get()));

       PersonIdent authorIdent = user.get()
           .newCommitterIdent(myIdent.getWhen(), myIdent.getTimeZone());

       if (commitToRevert.getParentCount() == 0) {
         throw new ResourceConflictException("Cannot revert initial commit");
       }

       RevCommit parentToCommitToRevert = commitToRevert.getParent(0);
       revWalk.parseHeaders(parentToCommitToRevert);

       CommitBuilder revertCommitBuilder = new CommitBuilder();
       revertCommitBuilder.addParentId(commitToRevert);
       revertCommitBuilder.setTreeId(parentToCommitToRevert.getTree());
       revertCommitBuilder.setAuthor(authorIdent);
       revertCommitBuilder.setCommitter(authorIdent);

       if (message == null) {
         message = MessageFormat.format(
             ChangeMessages.get().revertChangeDefaultMessage,
             changeToRevert.getSubject(), patch.getRevision().get());
       }

       ObjectId computedChangeId =
           ChangeIdUtil.computeChangeId(parentToCommitToRevert.getTree(),
               commitToRevert, authorIdent, myIdent, message);
       revertCommitBuilder.setMessage(
           ChangeIdUtil.insertId(message, computedChangeId, true));

       RevCommit revertCommit;
       ChangeInserter ins;
       try (ObjectInserter oi = git.newObjectInserter()) {
         ObjectId id = oi.insert(revertCommitBuilder);
         oi.flush();
         revertCommit = revWalk.parseCommit(id);

         RefControl refControl = ctl.getRefControl();
         Change change = new Change(
             new Change.Key("I" + computedChangeId.name()),
             new Change.Id(db.get().nextChangeId()),
             user.get().getAccountId(),
             changeToRevert.getDest(),
             TimeUtil.nowTs());
         change.setTopic(changeToRevert.getTopic());
         ins = changeInserterFactory.create(
               refControl, change, revertCommit)
             .setValidatePolicy(CommitValidators.Policy.GERRIT);

         ChangeMessage changeMessage = new ChangeMessage(
             new ChangeMessage.Key(
                 patchSetId.getParentKey(), ChangeUtil.messageUUID(db.get())),
                 user.get().getAccountId(), TimeUtil.nowTs(), patchSetId);
         StringBuilder msgBuf = new StringBuilder();
         msgBuf.append("Patch Set ").append(patchSetId.get()).append(": Reverted");
         msgBuf.append("\n\n");
         msgBuf.append("This patchset was reverted in change: ")
               .append(change.getKey().get());
         changeMessage.setMessage(msgBuf.toString());
         ChangeUpdate update = changeUpdateFactory.create(ctl, TimeUtil.nowTs());
         changeMessagesUtil.addChangeMessage(db.get(), update, changeMessage);
         update.commit();

         ins.setMessage("Uploaded patch set 1.");
         try (BatchUpdate bu = updateFactory.create(
             db.get(), change.getProject(), refControl.getUser(),
             change.getCreatedOn())) {
           bu.setRepository(git, revWalk, oi);
           bu.insertChange(ins);
           bu.execute();
         }
       }

       Change.Id id = ins.getChange().getId();
       try {
         RevertedSender cm = revertedSenderFactory.create(id);
         cm.setFrom(user.get().getAccountId());
         cm.setChangeMessage(ins.getChangeMessage());
         cm.send();
       } catch (Exception err) {
         log.error("Cannot send email for revert change " + id, err);
       }

       return id;
     } catch (RepositoryNotFoundException e) {
       throw new NoSuchChangeException(changeId, e);
     }
   }

   public String getMessage(Change change)
       throws NoSuchChangeException, OrmException,
       MissingObjectException, IncorrectObjectTypeException, IOException {
     Change.Id changeId = change.getId();
     PatchSet ps = db.get().patchSets().get(change.currentPatchSetId());
     if (ps == null) {
       throw new NoSuchChangeException(changeId);
     }

     try (Repository git = gitManager.openRepository(change.getProject());
         RevWalk revWalk = new RevWalk(git)) {
       RevCommit commit = revWalk.parseCommit(
           ObjectId.fromString(ps.getRevision().get()));
       return commit.getFullMessage();
     } catch (RepositoryNotFoundException e) {
       throw new NoSuchChangeException(changeId, e);
     }
   }

   public void deleteDraftChange(Change change)
       throws NoSuchChangeException, OrmException, IOException {
     Change.Id changeId = change.getId();
     if (change.getStatus() != Change.Status.DRAFT) {
       throw new NoSuchChangeException(changeId);
     }

     ReviewDb db = this.db.get();
     db.changes().beginTransaction(change.getId());
     try {
       List<PatchSet> patchSets = db.patchSets().byChange(changeId).toList();
       for (PatchSet ps : patchSets) {
         if (!ps.isDraft()) {
           throw new NoSuchChangeException(changeId);
         }
         db.accountPatchReviews().delete(
             db.accountPatchReviews().byPatchSet(ps.getId()));
       }

       // No need to delete from notedb; draft patch sets will be filtered out.
       db.patchComments().delete(db.patchComments().byChange(changeId));

       db.patchSetApprovals().delete(db.patchSetApprovals().byChange(changeId));
       db.patchSets().delete(patchSets);
       db.changeMessages().delete(db.changeMessages().byChange(changeId));
       db.starredChanges().delete(db.starredChanges().byChange(changeId));
       db.changes().delete(Collections.singleton(change));

       // Delete all refs at once.
       try (Repository repo = gitManager.openRepository(change.getProject());
           RevWalk rw = new RevWalk(repo)) {
         String prefix = new PatchSet.Id(changeId, 1).toRefName();
         prefix = prefix.substring(0, prefix.length() - 1);
         BatchRefUpdate ru = repo.getRefDatabase().newBatchUpdate();
         for (Ref ref : repo.getRefDatabase().getRefs(prefix).values()) {
           ru.addCommand(
               new ReceiveCommand(
                 ref.getObjectId(), ObjectId.zeroId(), ref.getName()));
         }
         ru.execute(rw, NullProgressMonitor.INSTANCE);
         for (ReceiveCommand cmd : ru.getCommands()) {
           if (cmd.getResult() != ReceiveCommand.Result.OK) {
             throw new IOException("failed: " + cmd + ": " + cmd.getResult());
           }
         }
       }

       db.commit();
       indexer.delete(change.getId());
     } finally {
       db.rollback();
     }
   }

   public void deleteOnlyDraftPatchSet(PatchSet patch, Change change)
       throws NoSuchChangeException, OrmException, IOException {
     PatchSet.Id patchSetId = patch.getId();
     if (!patch.isDraft()) {
       throw new NoSuchChangeException(patchSetId.getParentKey());
     }

     try (Repository repo = gitManager.openRepository(change.getProject())) {
       RefUpdate update = repo.updateRef(patch.getRefName());
       update.setForceUpdate(true);
       update.disableRefLog();
       switch (update.delete()) {
         case NEW:
         case FAST_FORWARD:
         case FORCED:
         case NO_CHANGE:
           // Successful deletion.
           break;
         default:
           throw new IOException("Failed to delete ref " + patch.getRefName() +
               " in " + repo.getDirectory() + ": " + update.getResult());
       }
       gitRefUpdated.fire(change.getProject(), update, ReceiveCommand.Type.DELETE);
     }

     deleteOnlyDraftPatchSetPreserveRef(this.db.get(), patch);
   }

   /**
    * Find changes matching the given identifier.
    *
    * @param id change identifier, either a numeric ID, a Change-Id, or
    *     project~branch~id triplet.
    * @return all matching changes, even if they are not visible to the current
    *     user.
    */
   public List<Change> findChanges(String id)
       throws OrmException, ResourceNotFoundException {
     // Try legacy id
     if (id.matches("^[1-9][0-9]*$")) {
       Change c = db.get().changes().get(Change.Id.parse(id));
       if (c != null) {
         return ImmutableList.of(c);
       }
       return Collections.emptyList();
     }

     // Try isolated changeId
     if (!id.contains("~")) {
       return asChanges(queryProvider.get().byKeyPrefix(id));
     }

     // Try change triplet
     Optional<ChangeTriplet> triplet = ChangeTriplet.parse(id);
     if (triplet.isPresent()) {
       return asChanges(queryProvider.get().byBranchKey(
           triplet.get().branch(),
           triplet.get().id()));
     }

     throw new ResourceNotFoundException(id);
   }

   private static void deleteOnlyDraftPatchSetPreserveRef(ReviewDb db,
       PatchSet patch) throws NoSuchChangeException, OrmException {
     PatchSet.Id patchSetId = patch.getId();
     if (!patch.isDraft()) {
       throw new NoSuchChangeException(patchSetId.getParentKey());
     }

     db.accountPatchReviews().delete(db.accountPatchReviews().byPatchSet(patchSetId));
     db.changeMessages().delete(db.changeMessages().byPatchSet(patchSetId));
     // No need to delete from notedb; draft patch sets will be filtered out.
     db.patchComments().delete(db.patchComments().byPatchSet(patchSetId));
     db.patchSetApprovals().delete(db.patchSetApprovals().byPatchSet(patchSetId));

     db.patchSets().delete(Collections.singleton(patch));
   }

   public static PatchSet.Id nextPatchSetId(PatchSet.Id id) {
     return new PatchSet.Id(id.getParentKey(), id.get() + 1);
   }
 }
	// Copyright (C) 2009 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;

	import static com.google.gerrit.server.query.change.ChangeData.asChanges;

	import com.google.common.base.Function;
	import com.google.common.base.Optional;
	import com.google.common.collect.ImmutableList;
	import com.google.common.collect.Ordering;
	import com.google.gerrit.common.TimeUtil;
	import com.google.gerrit.extensions.restapi.ResourceConflictException;
	import com.google.gerrit.extensions.restapi.ResourceNotFoundException;
	import com.google.gerrit.extensions.restapi.RestApiException;
	import com.google.gerrit.reviewdb.client.Change;
	import com.google.gerrit.reviewdb.client.ChangeMessage;
	import com.google.gerrit.reviewdb.client.PatchSet;
	import com.google.gerrit.reviewdb.client.Project;
	import com.google.gerrit.reviewdb.server.ReviewDb;
	import com.google.gerrit.server.change.ChangeInserter;
	import com.google.gerrit.server.change.ChangeMessages;
	import com.google.gerrit.server.change.ChangeTriplet;
	import com.google.gerrit.server.extensions.events.GitReferenceUpdated;
	import com.google.gerrit.server.git.BatchUpdate;
	import com.google.gerrit.server.git.GitRepositoryManager;
	import com.google.gerrit.server.git.UpdateException;
	import com.google.gerrit.server.git.validators.CommitValidators;
	import com.google.gerrit.server.index.ChangeIndexer;
	import com.google.gerrit.server.mail.RevertedSender;
	import com.google.gerrit.server.notedb.ChangeUpdate;
	import com.google.gerrit.server.project.ChangeControl;
	import com.google.gerrit.server.project.NoSuchChangeException;
	import com.google.gerrit.server.project.RefControl;
	import com.google.gerrit.server.query.change.InternalChangeQuery;
	import com.google.gerrit.server.util.IdGenerator;
	import com.google.gwtorm.server.OrmConcurrencyException;
	import com.google.gwtorm.server.OrmException;
	import com.google.inject.Inject;
	import com.google.inject.Provider;
	import com.google.inject.Singleton;

	import org.eclipse.jgit.errors.IncorrectObjectTypeException;
	import org.eclipse.jgit.errors.MissingObjectException;
	import org.eclipse.jgit.errors.RepositoryNotFoundException;
	import org.eclipse.jgit.lib.BatchRefUpdate;
	import org.eclipse.jgit.lib.CommitBuilder;
	import org.eclipse.jgit.lib.NullProgressMonitor;
	import org.eclipse.jgit.lib.ObjectId;
	import org.eclipse.jgit.lib.ObjectInserter;
	import org.eclipse.jgit.lib.PersonIdent;
	import org.eclipse.jgit.lib.Ref;
	import org.eclipse.jgit.lib.RefDatabase;
	import org.eclipse.jgit.lib.RefUpdate;
	import org.eclipse.jgit.lib.Repository;
	import org.eclipse.jgit.revwalk.RevCommit;
	import org.eclipse.jgit.revwalk.RevWalk;
	import org.eclipse.jgit.transport.ReceiveCommand;
	import org.eclipse.jgit.util.ChangeIdUtil;
	import org.slf4j.Logger;
	import org.slf4j.LoggerFactory;

	import java.io.IOException;
	import java.text.MessageFormat;
	import java.util.Collections;
	import java.util.List;
	import java.util.Map;

	@Singleton
	public class ChangeUtil {
	private static final Object uuidLock = new Object();
	private static final int SEED = 0x2418e6f9;
	private static int uuidPrefix;
	private static int uuidSeq;

	private static final int SUBJECT_MAX_LENGTH = 80;
	private static final String SUBJECT_CROP_APPENDIX = "...";
	private static final int SUBJECT_CROP_RANGE = 10;

	private static final Logger log =
	LoggerFactory.getLogger(ChangeUtil.class);

	public static final Function<PatchSet, Integer> TO_PS_ID =
	new Function<PatchSet, Integer>() {
	@Override
	public Integer apply(PatchSet in) {
	return in.getId().get();
	}
	};

	public static final Ordering<PatchSet> PS_ID_ORDER = Ordering.natural()
	.onResultOf(TO_PS_ID);

	/**
	* Generate a new unique identifier for change message entities.
	*
	* @param db the database connection, used to increment the change message
	* allocation sequence.
	* @return the new unique identifier.
	* @throws OrmException the database couldn't be incremented.
	*/
	public static String messageUUID(ReviewDb db) throws OrmException {
	int p;
	int s;
	synchronized (uuidLock) {
	if (uuidSeq == 0) {
	uuidPrefix = db.nextChangeMessageId();
	uuidSeq = Integer.MAX_VALUE;
	}
	p = uuidPrefix;
	s = uuidSeq--;
	}
	String u = IdGenerator.format(IdGenerator.mix(SEED, p));
	String l = IdGenerator.format(IdGenerator.mix(p, s));
	return u + '_' + l;
	}

	public static void touch(Change change, ReviewDb db)
	throws OrmException {
	try {
	updated(change);
	db.changes().update(Collections.singleton(change));
	} catch (OrmConcurrencyException e) {
	// Ignore a concurrent update, we just wanted to tag it as newer.
	}
	}

	public static void bumpRowVersionNotLastUpdatedOn(Change.Id id, ReviewDb db)
	throws OrmException {
	// Empty update of Change to bump rowVersion, changing its ETag.
	Change c = db.changes().get(id);
	if (c != null) {
	db.changes().update(Collections.singleton(c));
	}
	}

	public static void updated(Change c) {
	c.setLastUpdatedOn(TimeUtil.nowTs());
	}

	public static PatchSet.Id nextPatchSetId(Map<String, Ref> allRefs,
	PatchSet.Id id) {
	PatchSet.Id next = nextPatchSetId(id);
	while (allRefs.containsKey(next.toRefName())) {
	next = nextPatchSetId(next);
	}
	return next;
	}

	public static PatchSet.Id nextPatchSetId(Repository git, PatchSet.Id id)
	throws IOException {
	return nextPatchSetId(git.getRefDatabase().getRefs(RefDatabase.ALL), id);
	}

	public static String cropSubject(String subject) {
	if (subject.length() > SUBJECT_MAX_LENGTH) {
	int maxLength = SUBJECT_MAX_LENGTH - SUBJECT_CROP_APPENDIX.length();
	for (int cropPosition = maxLength;
	cropPosition > maxLength - SUBJECT_CROP_RANGE; cropPosition--) {
	if (Character.isWhitespace(subject.charAt(cropPosition - 1))) {
	return subject.substring(0, cropPosition) + SUBJECT_CROP_APPENDIX;
	}
	}
	return subject.substring(0, maxLength) + SUBJECT_CROP_APPENDIX;
	}
	return subject;
	}

	private final Provider<IdentifiedUser> user;
	private final Provider<ReviewDb> db;
	private final Provider<InternalChangeQuery> queryProvider;
	private final RevertedSender.Factory revertedSenderFactory;
	private final ChangeInserter.Factory changeInserterFactory;
	private final GitRepositoryManager gitManager;
	private final GitReferenceUpdated gitRefUpdated;
	private final ChangeIndexer indexer;
	private final BatchUpdate.Factory updateFactory;
	private final ChangeMessagesUtil changeMessagesUtil;
	private final ChangeUpdate.Factory changeUpdateFactory;

	@Inject
	ChangeUtil(Provider<IdentifiedUser> user,
	Provider<ReviewDb> db,
	Provider<InternalChangeQuery> queryProvider,
	RevertedSender.Factory revertedSenderFactory,
	ChangeInserter.Factory changeInserterFactory,
	GitRepositoryManager gitManager,
	GitReferenceUpdated gitRefUpdated,
	ChangeIndexer indexer,
	BatchUpdate.Factory updateFactory,
	ChangeMessagesUtil changeMessagesUtil,
	ChangeUpdate.Factory changeUpdateFactory) {
	this.user = user;
	this.db = db;
	this.queryProvider = queryProvider;
	this.revertedSenderFactory = revertedSenderFactory;
	this.changeInserterFactory = changeInserterFactory;
	this.gitManager = gitManager;
	this.gitRefUpdated = gitRefUpdated;
	this.indexer = indexer;
	this.updateFactory = updateFactory;
	this.changeMessagesUtil = changeMessagesUtil;
	this.changeUpdateFactory = changeUpdateFactory;
	}

	public Change.Id revert(ChangeControl ctl, PatchSet.Id patchSetId,
	String message, PersonIdent myIdent)
	throws NoSuchChangeException, OrmException,
	MissingObjectException, IncorrectObjectTypeException, IOException,
	RestApiException, UpdateException {
	Change.Id changeId = patchSetId.getParentKey();
	PatchSet patch = db.get().patchSets().get(patchSetId);
	if (patch == null) {
	throw new NoSuchChangeException(changeId);
	}
	Change changeToRevert = db.get().changes().get(changeId);

	Project.NameKey project = ctl.getChange().getProject();
	try (Repository git = gitManager.openRepository(project);
	RevWalk revWalk = new RevWalk(git)) {
	RevCommit commitToRevert =
	revWalk.parseCommit(ObjectId.fromString(patch.getRevision().get()));

	PersonIdent authorIdent = user.get()
	.newCommitterIdent(myIdent.getWhen(), myIdent.getTimeZone());

	if (commitToRevert.getParentCount() == 0) {
	throw new ResourceConflictException("Cannot revert initial commit");
	}

	RevCommit parentToCommitToRevert = commitToRevert.getParent(0);
	revWalk.parseHeaders(parentToCommitToRevert);

	CommitBuilder revertCommitBuilder = new CommitBuilder();
	revertCommitBuilder.addParentId(commitToRevert);
	revertCommitBuilder.setTreeId(parentToCommitToRevert.getTree());
	revertCommitBuilder.setAuthor(authorIdent);
	revertCommitBuilder.setCommitter(authorIdent);

	if (message == null) {
	message = MessageFormat.format(
	ChangeMessages.get().revertChangeDefaultMessage,
	changeToRevert.getSubject(), patch.getRevision().get());
	}

	ObjectId computedChangeId =
	ChangeIdUtil.computeChangeId(parentToCommitToRevert.getTree(),
	commitToRevert, authorIdent, myIdent, message);
	revertCommitBuilder.setMessage(
	ChangeIdUtil.insertId(message, computedChangeId, true));

	RevCommit revertCommit;
	ChangeInserter ins;
	try (ObjectInserter oi = git.newObjectInserter()) {
	ObjectId id = oi.insert(revertCommitBuilder);
	oi.flush();
	revertCommit = revWalk.parseCommit(id);

	RefControl refControl = ctl.getRefControl();
	Change change = new Change(
	new Change.Key("I" + computedChangeId.name()),
	new Change.Id(db.get().nextChangeId()),
	user.get().getAccountId(),
	changeToRevert.getDest(),
	TimeUtil.nowTs());
	change.setTopic(changeToRevert.getTopic());
	ins = changeInserterFactory.create(
	refControl, change, revertCommit)
	.setValidatePolicy(CommitValidators.Policy.GERRIT);

	ChangeMessage changeMessage = new ChangeMessage(
	new ChangeMessage.Key(
	patchSetId.getParentKey(), ChangeUtil.messageUUID(db.get())),
	user.get().getAccountId(), TimeUtil.nowTs(), patchSetId);
	StringBuilder msgBuf = new StringBuilder();
	msgBuf.append("Patch Set ").append(patchSetId.get()).append(": Reverted");
	msgBuf.append("\n\n");
	msgBuf.append("This patchset was reverted in change: ")
	.append(change.getKey().get());
	changeMessage.setMessage(msgBuf.toString());
	ChangeUpdate update = changeUpdateFactory.create(ctl, TimeUtil.nowTs());
	changeMessagesUtil.addChangeMessage(db.get(), update, changeMessage);
	update.commit();

	ins.setMessage("Uploaded patch set 1.");
	try (BatchUpdate bu = updateFactory.create(
	db.get(), change.getProject(), refControl.getUser(),
	change.getCreatedOn())) {
	bu.setRepository(git, revWalk, oi);
	bu.insertChange(ins);
	bu.execute();
	}
	}

	Change.Id id = ins.getChange().getId();
	try {
	RevertedSender cm = revertedSenderFactory.create(id);
	cm.setFrom(user.get().getAccountId());
	cm.setChangeMessage(ins.getChangeMessage());
	cm.send();
	} catch (Exception err) {
	log.error("Cannot send email for revert change " + id, err);
	}

	return id;
	} catch (RepositoryNotFoundException e) {
	throw new NoSuchChangeException(changeId, e);
	}
	}

	public String getMessage(Change change)
	throws NoSuchChangeException, OrmException,
	MissingObjectException, IncorrectObjectTypeException, IOException {
	Change.Id changeId = change.getId();
	PatchSet ps = db.get().patchSets().get(change.currentPatchSetId());
	if (ps == null) {
	throw new NoSuchChangeException(changeId);
	}

	try (Repository git = gitManager.openRepository(change.getProject());
	RevWalk revWalk = new RevWalk(git)) {
	RevCommit commit = revWalk.parseCommit(
	ObjectId.fromString(ps.getRevision().get()));
	return commit.getFullMessage();
	} catch (RepositoryNotFoundException e) {
	throw new NoSuchChangeException(changeId, e);
	}
	}

	public void deleteDraftChange(Change change)
	throws NoSuchChangeException, OrmException, IOException {
	Change.Id changeId = change.getId();
	if (change.getStatus() != Change.Status.DRAFT) {
	throw new NoSuchChangeException(changeId);
	}

	ReviewDb db = this.db.get();
	db.changes().beginTransaction(change.getId());
	try {
	List<PatchSet> patchSets = db.patchSets().byChange(changeId).toList();
	for (PatchSet ps : patchSets) {
	if (!ps.isDraft()) {
	throw new NoSuchChangeException(changeId);
	}
	db.accountPatchReviews().delete(
	db.accountPatchReviews().byPatchSet(ps.getId()));
	}

	// No need to delete from notedb; draft patch sets will be filtered out.
	db.patchComments().delete(db.patchComments().byChange(changeId));

	db.patchSetApprovals().delete(db.patchSetApprovals().byChange(changeId));
	db.patchSets().delete(patchSets);
	db.changeMessages().delete(db.changeMessages().byChange(changeId));
	db.starredChanges().delete(db.starredChanges().byChange(changeId));
	db.changes().delete(Collections.singleton(change));

	// Delete all refs at once.
	try (Repository repo = gitManager.openRepository(change.getProject());
	RevWalk rw = new RevWalk(repo)) {
	String prefix = new PatchSet.Id(changeId, 1).toRefName();
	prefix = prefix.substring(0, prefix.length() - 1);
	BatchRefUpdate ru = repo.getRefDatabase().newBatchUpdate();
	for (Ref ref : repo.getRefDatabase().getRefs(prefix).values()) {
	ru.addCommand(
	new ReceiveCommand(
	ref.getObjectId(), ObjectId.zeroId(), ref.getName()));
	}
	ru.execute(rw, NullProgressMonitor.INSTANCE);
	for (ReceiveCommand cmd : ru.getCommands()) {
	if (cmd.getResult() != ReceiveCommand.Result.OK) {
	throw new IOException("failed: " + cmd + ": " + cmd.getResult());
	}
	}
	}

	db.commit();
	indexer.delete(change.getId());
	} finally {
	db.rollback();
	}
	}

	public void deleteOnlyDraftPatchSet(PatchSet patch, Change change)
	throws NoSuchChangeException, OrmException, IOException {
	PatchSet.Id patchSetId = patch.getId();
	if (!patch.isDraft()) {
	throw new NoSuchChangeException(patchSetId.getParentKey());
	}

	try (Repository repo = gitManager.openRepository(change.getProject())) {
	RefUpdate update = repo.updateRef(patch.getRefName());
	update.setForceUpdate(true);
	update.disableRefLog();
	switch (update.delete()) {
	case NEW:
	case FAST_FORWARD:
	case FORCED:
	case NO_CHANGE:
	// Successful deletion.
	break;
	default:
	throw new IOException("Failed to delete ref " + patch.getRefName() +
	" in " + repo.getDirectory() + ": " + update.getResult());
	}
	gitRefUpdated.fire(change.getProject(), update, ReceiveCommand.Type.DELETE);
	}

	deleteOnlyDraftPatchSetPreserveRef(this.db.get(), patch);
	}

	/**
	* Find changes matching the given identifier.
	*
	* @param id change identifier, either a numeric ID, a Change-Id, or
	* project~branch~id triplet.
	* @return all matching changes, even if they are not visible to the current
	* user.
	*/
	public List<Change> findChanges(String id)
	throws OrmException, ResourceNotFoundException {
	// Try legacy id
	if (id.matches("^[1-9][0-9]*$")) {
	Change c = db.get().changes().get(Change.Id.parse(id));
	if (c != null) {
	return ImmutableList.of(c);
	}
	return Collections.emptyList();
	}

	// Try isolated changeId
	if (!id.contains("~")) {
	return asChanges(queryProvider.get().byKeyPrefix(id));
	}

	// Try change triplet
	Optional<ChangeTriplet> triplet = ChangeTriplet.parse(id);
	if (triplet.isPresent()) {
	return asChanges(queryProvider.get().byBranchKey(
	triplet.get().branch(),
	triplet.get().id()));
	}

	throw new ResourceNotFoundException(id);
	}

	private static void deleteOnlyDraftPatchSetPreserveRef(ReviewDb db,
	PatchSet patch) throws NoSuchChangeException, OrmException {
	PatchSet.Id patchSetId = patch.getId();
	if (!patch.isDraft()) {
	throw new NoSuchChangeException(patchSetId.getParentKey());
	}

	db.accountPatchReviews().delete(db.accountPatchReviews().byPatchSet(patchSetId));
	db.changeMessages().delete(db.changeMessages().byPatchSet(patchSetId));
	// No need to delete from notedb; draft patch sets will be filtered out.
	db.patchComments().delete(db.patchComments().byPatchSet(patchSetId));
	db.patchSetApprovals().delete(db.patchSetApprovals().byPatchSet(patchSetId));

	db.patchSets().delete(Collections.singleton(patch));
	}

	public static PatchSet.Id nextPatchSetId(PatchSet.Id id) {
	return new PatchSet.Id(id.getParentKey(), id.get() + 1);
	}
	}