private String loadLogFile(String fileName) throws CommandException {
StringBuffer buffer = new StringBuffer();
BufferedReader reader = null;
try {
reader = new BufferedReader(new FileReader(fileName));
String line;
while ((line = reader.readLine()) != null) {
buffer.append(line + "\n"); // NOI18N
}
} catch (FileNotFoundException ex) {
throw new CommandException(
ex,
CommandException.getLocalMessage(
"CommitCommand.logInfoFileNotExists", new Object[] {fileName})); // NOI18N
} catch (IOException ex) {
throw new CommandException(
ex,
CommandException.getLocalMessage(
"CommitCommand.errorReadingLogFile", new Object[] {fileName})); // NOI18N
} finally {
if (reader != null) {
try {
reader.close();
} catch (IOException exc) {
}
}
}
return buffer.toString();
}
/**
* Executes this command.
*
* @param client the client services object that provides any necessary services to this command,
* including the ability to actually process all the requests.
*/
public void execute(ClientServices clientServices, EventManager eventManager)
throws CommandException {
this.clientServices = clientServices;
try {
clientServices.ensureConnection();
super.execute(clientServices, eventManager);
addArgumentRequest(isCheckThatUnedited(), "-c"); // NOI18N
addArgumentRequest(isForceEvenIfEdited(), "-f"); // NOI18N
// now add the request that indicates the working directory for the
// command
addRequestForWorkingDirectory(clientServices);
addRequest(CommandRequest.NOOP);
clientServices.processRequests(requests);
} catch (AuthenticationException ex) {
// TODO: handle case, where connection wasn't possible to establish
} catch (CommandException ex) {
throw ex;
} catch (EOFException ex) {
throw new CommandException(
ex, CommandException.getLocalMessage("CommandException.EndOfFile", null)); // NOI18N
} catch (Exception ex) {
throw new CommandException(ex, ex.getLocalizedMessage());
} finally {
requests.clear();
this.clientServices = null;
}
}
/**
* Handle the response from a request.
*
* @throws ResponseException if there is a problem reading the response
*/
private void handleResponse() throws ResponseException, CommandAbortedException {
try {
LoggedDataInputStream dis = connection.getInputStream();
loggedDataInputStream = dis;
int ch = -1;
try {
ch = dis.read();
} catch (InterruptedIOException ex) {
abort();
}
while (!abort && ch != -1) {
StringBuffer responseNameBuffer = new StringBuffer();
// read in the response name
while (ch != -1 && (char) ch != '\n' && (char) ch != ' ') {
responseNameBuffer.append((char) ch);
try {
ch = dis.read();
} catch (InterruptedIOException ex) {
abort();
break;
}
}
String responseString = responseNameBuffer.toString();
Response response = getResponseFactory().createResponse(responseString);
// Logger.logInput(new String("<" + responseString + " processing start>\n").getBytes()); //
// NOI18N
response.process(dis, this);
boolean terminal = response.isTerminalResponse();
// handle SpecialResponses
if (terminal && response instanceof ErrorMessageResponse) {
ErrorMessageResponse errorResponce = (ErrorMessageResponse) response;
String errMsg = errorResponce.getMessage();
throw new CommandAbortedException(errMsg, errMsg);
}
// Logger.logInput(new String("<" + responseString + " processed " + terminal +
// ">\n").getBytes()); // NOI18N
if (terminal || abort) {
break;
}
try {
ch = dis.read();
} catch (InterruptedIOException ex) {
abort();
break;
}
}
if (abort) {
String localMsg = CommandException.getLocalMessage("Client.commandAborted", null); // NOI18N
throw new CommandAbortedException("Aborted during request processing", localMsg); // NOI18N
}
} catch (EOFException ex) {
throw new ResponseException(
ex, ResponseException.getLocalMessage("CommandException.EndOfFile", null)); // NOI18N
} catch (IOException ex) {
throw new ResponseException(ex);
}
}
/**
* Process all the requests. The connection must have been opened and set first.
*
* @param requests the requets to process
*/
public void processRequests(List requests)
throws IOException, UnconfiguredRequestException, ResponseException, CommandAbortedException {
if (requests == null || requests.size() == 0) {
throw new IllegalArgumentException(
"[processRequests] requests "
+ // NOI18N
"was either null or empty."); // NOI18N
}
if (abort) {
throw new CommandAbortedException(
"Aborted during request processing", // NOI18N
CommandException.getLocalMessage("Client.commandAborted", null)); // NOI18N
}
loggedDataInputStream = null;
loggedDataOutputStream = null;
// send the initialisation requests if we are handling the first
// command
boolean filterRootRequest = true;
if (isFirstCommand()) {
setIsFirstCommand(false);
int pos = 0;
if (!initialRequestsSent) {
pos = fillInitialRequests(requests);
initialRequestsSent = true;
filterRootRequest = false;
}
if (globalOptions != null) {
// sends the global options that are to be sent to server (-q, -Q, -t, -n, l)
for (Iterator it = globalOptions.createRequestList().iterator(); it.hasNext(); ) {
Request request = (Request) it.next();
requests.add(pos++, request);
}
if (globalOptions.isUseGzip() && globalOptions.getCompressionLevel() != 0) {
requests.add(pos++, new GzipFileContentsRequest(globalOptions.getCompressionLevel()));
}
}
} else if (printConnectionReuseWarning) {
if (System.getProperty("javacvs.multiple_commands_warning") == null) { // NOI18N
System.err.println("WARNING TO DEVELOPERS:"); // NOI18N
System.err.println(
"Please be warned that attempting to reuse one open connection for more commands is not supported by cvs servers very well."); // NOI18N
System.err.println("You are advised to open a new Connection each time."); // NOI18N
System.err.println(
"If you still want to proceed, please do: System.setProperty(\"javacvs.multiple_commands_warning\", \"false\")"); // NOI18N
System.err.println("That will disable this message."); // NOI18N
}
}
if (!ALLOWED_CONNECTION_REUSE_REQUESTS.contains(requests.get(requests.size() - 1).getClass())) {
printConnectionReuseWarning = true;
}
final boolean fireEnhancedEvents = getEventManager().isFireEnhancedEventSet();
int fileDetailRequestCount = 0;
if (fireEnhancedEvents) {
for (Iterator it = requests.iterator(); it.hasNext(); ) {
Request request = (Request) it.next();
FileDetails fileDetails = request.getFileForTransmission();
if (fileDetails != null && fileDetails.getFile().exists()) {
fileDetailRequestCount++;
}
}
CVSEvent event =
new EnhancedMessageEvent(
this, EnhancedMessageEvent.REQUESTS_COUNT, new Integer(fileDetailRequestCount));
getEventManager().fireCVSEvent(event);
}
LoggedDataOutputStream dos = connection.getOutputStream();
loggedDataOutputStream = dos;
// this list stores stream modification requests, each to be called
// to modify the input stream the next time we need to process a
// response
List streamModifierRequests = new LinkedList();
// sending files does not seem to allow compression
transmitFileHandler = getUncompressedFileHandler();
for (Iterator it = requests.iterator(); it.hasNext(); ) {
if (abort) {
throw new CommandAbortedException(
"Aborted during request processing", // NOI18N
CommandException.getLocalMessage("Client.commandAborted", null)); // NOI18N
}
final Request request = (Request) it.next();
if (request instanceof GzipFileContentsRequest) {
if (dontUseGzipFileHandler) {
stderr.println(
"Warning: The server is not supporting gzip-file-contents request, no compression is used.");
continue;
}
}
// skip the root request if already sent
if (request instanceof RootRequest) {
if (filterRootRequest) {
continue;
} else { // Even if we should not filter the RootRequest now, we must filter all successive
// RootRequests
filterRootRequest = true;
}
}
// send request to server
String requestString = request.getRequestString();
dos.writeBytes(requestString);
// we must modify the outputstream now, but defer modification
// of the inputstream until we are about to read a response.
// This is because some modifiers (e.g. gzip) read the header
// on construction, and obviously no header is present when
// no response has been sent
request.modifyOutputStream(connection);
if (request.modifiesInputStream()) {
streamModifierRequests.add(request);
}
dos = connection.getOutputStream();
FileDetails fileDetails = request.getFileForTransmission();
if (fileDetails != null) {
final File file = fileDetails.getFile();
// only transmit the file if it exists! When committing
// a remove request you cannot transmit the file
if (file.exists()) {
Logger.logOutput(
new String(
"<Sending file: "
+ // NOI18N
file.getAbsolutePath()
+ ">\n")
.getBytes("utf8")); // NOI18N
if (fireEnhancedEvents) {
CVSEvent event =
new EnhancedMessageEvent(this, EnhancedMessageEvent.FILE_SENDING, file);
getEventManager().fireCVSEvent(event);
fileDetailRequestCount--;
}
if (fileDetails.isBinary()) {
transmitFileHandler.transmitBinaryFile(file, dos);
} else {
transmitFileHandler.transmitTextFile(file, dos);
}
if (fireEnhancedEvents && fileDetailRequestCount == 0) {
CVSEvent event =
new EnhancedMessageEvent(this, EnhancedMessageEvent.REQUESTS_SENT, "Ok"); // NOI18N
getEventManager().fireCVSEvent(event);
}
}
}
if (request.isResponseExpected()) {
dos.flush();
// now perform the deferred modification of the input stream
Iterator modifiers = streamModifierRequests.iterator();
while (modifiers.hasNext()) {
System.err.println("Modifying the inputstream..."); // NOI18N
final Request smRequest = (Request) modifiers.next();
System.err.println(
"Request is a: "
+ // NOI18N
smRequest.getClass().getName());
smRequest.modifyInputStream(connection);
}
streamModifierRequests.clear();
handleResponse();
}
}
dos.flush();
transmitFileHandler = null;
}