/*
* #%L
* JavaHg
* %%
* Copyright (C) 2011 aragost Trifork ag
* %%
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
* #L%
*/
package com.aragost.javahg.internals;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.charset.CharsetDecoder;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.ConcurrentModificationException;
import java.util.List;
import java.util.concurrent.atomic.AtomicReference;
import com.aragost.javahg.Changeset;
import com.aragost.javahg.DateTime;
import com.aragost.javahg.Repository;
import com.aragost.javahg.UnknownCommandException;
import com.aragost.javahg.commands.CancelledExecutionException;
import com.aragost.javahg.commands.ExecutionException;
import com.google.common.collect.Lists;
import com.google.common.io.ByteStreams;
/**
* Base class for the command classes.
*
* Each Mercurial command (e.g., "log", "commit", etc) is mapped to a command
* class, which is a subclass of this class. The command classes will provide
* methods for setting command line flags and for actually executing the
* command.
*
* Concurrency: Instances of this class should be accessed only on a single
* thread. The only exception is {@link #cancel()}.
*
* States: Normally: READY->QUEUED->RUNNING->READY. If cancelled: From READY,
* QUEUED, or RUNNING -> CANCELLING -> READY. If cancelled the executing thread
* will have a CancelledExecutionException thrown and state will be READY.
*/
public abstract class AbstractCommand {
public enum State { READY, QUEUED, RUNNING, CANCELING };
private AtomicReference<State> state = new AtomicReference<AbstractCommand.State>(State.READY);
private final List<String> cmdLine;
private final Repository repository;
private OutputChannelInputStream outputChannelStream;
private ByteArrayOutputStream error = new ByteArrayOutputStream();
private int returnCode = Integer.MIN_VALUE;
private int lineChannelLength;
/**
* Not null while in {@link State#RUNNING}.
*/
private volatile Server server;
protected AbstractCommand(Repository repository) {
this.repository = repository;
this.cmdLine = Lists.newArrayList(getCommandName());
}
protected AbstractCommand(Repository repository, String commandName) {
this.repository = repository;
this.cmdLine = Lists.newArrayList(commandName);
}
/**
* @return the name of this Mercurial command, i.e., "add", "log",
* etc
*/
public abstract String getCommandName();
public void cmdAppend(String option) {
this.cmdLine.add(option);
}
public void cmdAppend(String option, String arg) {
if (arg == null) {
throw new NullPointerException("cannot pass null for " + option + " flag");
}
this.cmdLine.add(option);
this.cmdLine.add(arg);
}
public void cmdAppend(String option, String[] args) {
for (String arg : args) {
cmdAppend(option, arg);
}
}
public void cmdAppend(String option, int arg) {
this.cmdLine.add(option);
this.cmdLine.add("" + arg);
}
public void cmdAppend(String option, DateTime date) {
if (date == null) {
throw new NullPointerException("cannot pass null for " + option + " flag");
}
this.cmdLine.add(option);
this.cmdLine.add(date.getHgString());
}
/**
* Launch the command and return stdout as a String.
*
* @param args
* extra command line arguments (optional).
* @return stdout as a String.
* @throws IOException
*/
protected final String launchString(String... args) {
InputStream stdout = launchStream(args);
try {
return Utils.readStream(stdout, getRepository().newDecoder());
} finally {
cleanUp();
}
}
/**
* Launch the command and return stdout as a InputStream.
*
* @param args
* extra command line arguments (optional).
* @return stdout stream
*/
protected final HgInputStream launchStream(String... args) {
clear();
changeState(State.READY, State.QUEUED, true);
try {
server = repository.getServerPool().take(this);
changeState(State.QUEUED, State.RUNNING, true);
} catch (InterruptedException e1) {
changeState(State.CANCELING, State.READY, false);
throw new CancelledExecutionException(this);
}
List<String> commandLine = new ArrayList<String>(this.cmdLine);
boolean ok = false;
getRepository().addToCommandLine(commandLine);
commandLine.addAll(Arrays.asList(args));
try {
this.outputChannelStream = server.runCommand(commandLine, this);
HgInputStream stream = new HgInputStream(outputChannelStream, this.repository.newDecoder());
ok = true;
return stream;
} catch (UnexpectedServerTerminationException e) {
if (state.get() == State.CANCELING) {
throw new CancelledExecutionException(this);
}
throw e;
} catch (IOException e) {
throw new RuntimeIOException(e);
} finally {
// If an exception is thrown there is no chance the command will
// finish normally so abort the server. E.g protocol error
if (!ok && state.get() != State.READY) {
state.set(State.READY);
repository.getServerPool().abort(server);
server = null;
}
}
}
/**
* Changes state checking for cancellation
*
* @param current
* The expected state
* @param next
* The state to change to
* @param strict
* If true a {@link ConcurrentModificationException} is thrown if
* in unexpected state
* @throws CancelledExecutionException
* If in cancelled state
* @throws ConcurrentModificationException
* If in another unexpected state and if strict is true
*/
private void changeState(State current, State next, boolean strict) {
if (!state.compareAndSet(current, next)) {
if (state.compareAndSet(State.CANCELING, State.READY)) {
throw new CancelledExecutionException(this);
}
if (strict) {
throw new ConcurrentModificationException("Unexpected command state");
}
}
}
protected final LineIterator launchIterator(String... args) {
return new LineIterator(launchStream(args));
}
/**
* Open the output stream again after sending input to the command
* server. When the server alternates between sending output on
* the 'o' channel and reading input lines, the output channel
* will run dry several times. Call this method after sending
* input to the command server in response to reading from the 'L'
* channel. New output from the server will then appear on the
* output channel.
*/
public void reopenOutputChannelStream() {
this.outputChannelStream.reopen();
}
/**
* Send input line to command server in response to reading a
* block on the 'L' channel.
*
* @param s
* line of input.
*/
public void sendLine(String s) {
if (this.lineChannelLength == 0) {
throw new IllegalStateException("No input expected");
}
server.sendLine(s);
this.lineChannelLength = 0;
}
/**
* @return true if we have read a 'L' channel from the server.
*/
public boolean needsInputLine() {
return this.lineChannelLength > 0;
}
/**
* Finish the request by consuming any remaining input on the
* output channel from the server. The server wont respond to new
* commands until this is done.
*/
void cleanUp() {
if (this.outputChannelStream != null) {
try {
Utils.consumeAll(this.outputChannelStream);
} catch (IOException e) {
throw new RuntimeIOException(e);
}
}
}
protected void clear() {
this.error.reset();
this.returnCode = Integer.MIN_VALUE;
}
/**
* Check if the command ended with a zero return code. Subclasses
* can override this to accept other return codes as successful.
*
* @return true if the command ended successfully.
*/
protected boolean isSuccessful() {
return getReturnCode() == 0;
}
private String streamAsString(OutputStream stream) {
if (stream instanceof ByteArrayOutputStream) {
byte[] bytes = ((ByteArrayOutputStream) stream).toByteArray();
CharsetDecoder decoder = getRepository().newDecoder();
return Utils.decodeBytes(bytes, decoder);
} else {
throw new IllegalStateException();
}
}
/**
* @return data read on the 'e' channel
*/
public String getErrorString() {
return streamAsString(this.error);
}
/**
* @return the return code read from the 'r' channel
*/
public int getReturnCode() {
if (this.returnCode == Integer.MIN_VALUE) {
throw new IllegalStateException("cmdserver is still executing request");
}
return this.returnCode;
}
/**
* @return the {@link Repository} associated with this command.
*/
public Repository getRepository() {
return repository;
}
@Override
public String toString() {
return getCommandName();
}
/**
* @param lineChannelLength
* the line length requested by the server on the 'L'
* channel.
*/
void setLineChannelLength(int lineChannelLength) {
this.lineChannelLength = lineChannelLength;
}
/**
* Add to the stderr data stored in this command.
*
* @param cin
* stderr of the command server.
* @throws IOException
*/
void addToError(BlockInputStream cin) throws IOException {
ByteStreams.copy(cin, this.error);
}
protected void withDebugAndChangesetStyle() {
withDebugFlag();
cmdAppend("--style", Changeset.CHANGESET_STYLE_PATH);
}
protected void withDebugFlag() {
cmdAppend("--debug");
}
/**
* Called exactly once when this command finishes executing. The server is
* freed and the state is changed to DONE.
*
* @param returnCode The exit code of the completed command
*/
final void handleReturnCode(int returnCode) {
this.returnCode = returnCode;
server.clearCurrentCommand(this);
repository.getServerPool().put(server);
server = null;
changeState(State.RUNNING, State.READY, false);
if (returnCode == -1) {
// This can for example happens for an unknown command
String errorString = getErrorString();
if (errorString.startsWith("hg: unknown command '")) {
throw new UnknownCommandException(this);
}
}
doneHook();
if (!isSuccessful()) {
throw new ExecutionException(this);
}
}
/**
* Cancel a running command. May be called from a different thread. Returns
* immediately. The thread executing the command should return soon after
* with a {@link CancelledExecutionException} thrown.
*/
public final void cancel() {
State oldState = state.getAndSet(State.CANCELING);
if (oldState != State.READY) {
// There is a small chance the final state of a command will be
// CANCELLING rather than DONE but this doesn't actually matter.
Server server = this.server;
Process process;
if (server != null && (process = server.getProcess()) != null) {
process.destroy();
}
}
}
/**
* @return The current state of the command.
*/
State getState() {
return state.get();
}
/**
* This method is called when the processing of a command is
* finished. More precise it is called just after the 'r' channel
* is read
* <p>
* It can be overridden in subclasses.
*/
protected void doneHook() {
}
}