jgit/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/reftree/Command.java

/*
 * Copyright (C) 2016, Google Inc.
 * and other copyright owners as documented in the project's IP log.
 *
 * This program and the accompanying materials are made available
 * under the terms of the Eclipse Distribution License v1.0 which
 * accompanies this distribution, is reproduced below, and is
 * available at http://www.eclipse.org/org/documents/edl-v10.php
 *
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or
 * without modification, are permitted provided that the following
 * conditions are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 *
 * - Redistributions in binary form must reproduce the above
 *   copyright notice, this list of conditions and the following
 *   disclaimer in the documentation and/or other materials provided
 *   with the distribution.
 *
 * - Neither the name of the Eclipse Foundation, Inc. nor the
 *   names of its contributors may be used to endorse or promote
 *   products derived from this software without specific prior
 *   written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
 * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

package org.eclipse.jgit.internal.storage.reftree;

import static org.eclipse.jgit.lib.Constants.OBJ_BLOB;
import static org.eclipse.jgit.lib.Constants.encode;
import static org.eclipse.jgit.lib.FileMode.TYPE_GITLINK;
import static org.eclipse.jgit.lib.FileMode.TYPE_SYMLINK;
import static org.eclipse.jgit.lib.Ref.Storage.NETWORK;
import static org.eclipse.jgit.transport.ReceiveCommand.Result.NOT_ATTEMPTED;
import static org.eclipse.jgit.transport.ReceiveCommand.Result.REJECTED_OTHER_REASON;

import java.io.IOException;

import org.eclipse.jgit.annotations.Nullable;
import org.eclipse.jgit.dircache.DirCacheEntry;
import org.eclipse.jgit.errors.MissingObjectException;
import org.eclipse.jgit.internal.JGitText;
import org.eclipse.jgit.lib.ObjectId;
import org.eclipse.jgit.lib.ObjectIdRef;
import org.eclipse.jgit.lib.ObjectInserter;
import org.eclipse.jgit.lib.Ref;
import org.eclipse.jgit.revwalk.RevObject;
import org.eclipse.jgit.revwalk.RevTag;
import org.eclipse.jgit.revwalk.RevWalk;
import org.eclipse.jgit.transport.ReceiveCommand;
import org.eclipse.jgit.transport.ReceiveCommand.Result;

/**
 * Command to create, update or delete an entry inside a {@link RefTree}.
 * <p>
 * Unlike {@link ReceiveCommand} (which can only update a reference to an
 * {@link ObjectId}), a RefTree Command can also create, modify or delete
 * symbolic references to a target reference.
 * <p>
 * RefTree Commands may wrap a {@code ReceiveCommand} to allow callers to
 * process an existing ReceiveCommand against a RefTree.
 * <p>
 * Commands should be passed into {@link RefTree#apply(java.util.Collection)}
 * for processing.
 */
public class Command {
	/**
	 * Set unprocessed commands as failed due to transaction aborted.
	 * <p>
	 * If a command is still {@link Result#NOT_ATTEMPTED} it will be set to
	 * {@link Result#REJECTED_OTHER_REASON}. If {@code why} is non-null its
	 * contents will be used as the message for the first command status.
	 *
	 * @param commands
	 *            commands to mark as failed.
	 * @param why
	 *            optional message to set on the first aborted command.
	 */
	public static void abort(Iterable<Command> commands, @Nullable String why) {
		if (why == null || why.isEmpty()) {
			why = JGitText.get().transactionAborted;
		}
		for (Command c : commands) {
			if (c.getResult() == NOT_ATTEMPTED) {
				c.setResult(REJECTED_OTHER_REASON, why);
				why = JGitText.get().transactionAborted;
			}
		}
	}

	private final Ref oldRef;
	private final Ref newRef;
	private final ReceiveCommand cmd;
	private Result result;

	/**
	 * Create a command to create, update or delete a reference.
	 * <p>
	 * At least one of {@code oldRef} or {@code newRef} must be supplied.
	 *
	 * @param oldRef
	 *            expected value. Null if the ref should not exist.
	 * @param newRef
	 *            desired value, must be peeled if not null and not symbolic.
	 *            Null to delete the ref.
	 */
	public Command(@Nullable Ref oldRef, @Nullable Ref newRef) {
		this.oldRef = oldRef;
		this.newRef = newRef;
		this.cmd = null;
		this.result = NOT_ATTEMPTED;

		if (oldRef == null && newRef == null) {
			throw new IllegalArgumentException();
		}
		if (newRef != null && !newRef.isPeeled() && !newRef.isSymbolic()) {
			throw new IllegalArgumentException();
		}
		if (oldRef != null && newRef != null
				&& !oldRef.getName().equals(newRef.getName())) {
			throw new IllegalArgumentException();
		}
	}

	/**
	 * Construct a RefTree command wrapped around a ReceiveCommand.
	 *
	 * @param rw
	 *            walk instance to peel the {@code newId}.
	 * @param cmd
	 *            command received from a push client.
	 * @throws MissingObjectException
	 *             {@code oldId} or {@code newId} is missing.
	 * @throws IOException
	 *             {@code oldId} or {@code newId} cannot be peeled.
	 */
	public Command(RevWalk rw, ReceiveCommand cmd)
			throws MissingObjectException, IOException {
		this.oldRef = toRef(rw, cmd.getOldId(), cmd.getRefName(), false);
		this.newRef = toRef(rw, cmd.getNewId(), cmd.getRefName(), true);
		this.cmd = cmd;
	}

	static Ref toRef(RevWalk rw, ObjectId id, String name,
			boolean mustExist) throws MissingObjectException, IOException {
		if (ObjectId.zeroId().equals(id)) {
			return null;
		}

		try {
			RevObject o = rw.parseAny(id);
			if (o instanceof RevTag) {
				RevObject p = rw.peel(o);
				return new ObjectIdRef.PeeledTag(NETWORK, name, id, p.copy());
			}
			return new ObjectIdRef.PeeledNonTag(NETWORK, name, id);
		} catch (MissingObjectException e) {
			if (mustExist) {
				throw e;
			}
			return new ObjectIdRef.Unpeeled(NETWORK, name, id);
		}
	}

	/** @return name of the reference affected by this command. */
	public String getRefName() {
		if (cmd != null) {
			return cmd.getRefName();
		} else if (newRef != null) {
			return newRef.getName();
		}
		return oldRef.getName();
	}

	/**
	 * Set the result of this command.
	 *
	 * @param result
	 *            the command result.
	 */
	public void setResult(Result result) {
		setResult(result, null);
	}

	/**
	 * Set the result of this command.
	 *
	 * @param result
	 *            the command result.
	 * @param why
	 *            optional message explaining the result status.
	 */
	public void setResult(Result result, @Nullable String why) {
		if (cmd != null) {
			cmd.setResult(result, why);
		} else {
			this.result = result;
		}
	}

	/** @return result of executing this command. */
	public Result getResult() {
		return cmd != null ? cmd.getResult() : result;
	}

	/** @return optional message explaining command failure. */
	@Nullable
	public String getMessage() {
		return cmd != null ? cmd.getMessage() : null;
	}

	/**
	 * Old peeled reference.
	 *
	 * @return the old reference; null if the command is creating the reference.
	 */
	@Nullable
	public Ref getOldRef() {
		return oldRef;
	}

	/**
	 * New peeled reference.
	 *
	 * @return the new reference; null if the command is deleting the reference.
	 */
	@Nullable
	public Ref getNewRef() {
		return newRef;
	}

	@Override
	public String toString() {
		StringBuilder s = new StringBuilder();
		append(s, oldRef, "CREATE"); //$NON-NLS-1$
		s.append(' ');
		append(s, newRef, "DELETE"); //$NON-NLS-1$
		s.append(' ').append(getRefName());
		s.append(' ').append(getResult());
		if (getMessage() != null) {
			s.append(' ').append(getMessage());
		}
		return s.toString();
	}

	private static void append(StringBuilder s, Ref r, String nullName) {
		if (r == null) {
			s.append(nullName);
		} else if (r.isSymbolic()) {
			s.append(r.getTarget().getName());
		} else {
			ObjectId id = r.getObjectId();
			if (id != null) {
				s.append(id.name());
			}
		}
	}

	/**
	 * Check the entry is consistent with either the old or the new ref.
	 *
	 * @param entry
	 *            current entry; null if the entry does not exist.
	 * @return true if entry matches {@link #getOldRef()} or
	 *         {@link #getNewRef()}; otherwise false.
	 */
	boolean checkRef(@Nullable DirCacheEntry entry) {
		if (entry != null && entry.getRawMode() == 0) {
			entry = null;
		}
		return check(entry, oldRef) || check(entry, newRef);
	}

	private static boolean check(@Nullable DirCacheEntry cur,
			@Nullable Ref exp) {
		if (cur == null) {
			// Does not exist, ok if oldRef does not exist.
			return exp == null;
		} else if (exp == null) {
			// Expected to not exist, but currently exists, fail.
			return false;
		}

		if (exp.isSymbolic()) {
			String dst = exp.getTarget().getName();
			return cur.getRawMode() == TYPE_SYMLINK
					&& cur.getObjectId().equals(symref(dst));
		}

		return cur.getRawMode() == TYPE_GITLINK
				&& cur.getObjectId().equals(exp.getObjectId());
	}

	static ObjectId symref(String s) {
		@SuppressWarnings("resource")
		ObjectInserter.Formatter fmt = new ObjectInserter.Formatter();
		return fmt.idFor(OBJ_BLOB, encode(s));
	}
}