plugins/cvs/javacvs-src/org/netbeans/lib/cvsclient/RequestProcessor.java - platform/tools/idea - Git at Google

 /*
  *                 Sun Public License Notice
  *
  * The contents of this file are subject to the Sun Public License
  * Version 1.0 (the "License"). You may not use this file except in
  * compliance with the License. A copy of the License is available at
  * http://www.sun.com/
  *
  * The Original Code is NetBeans. The Initial Developer of the Original
  * Code is Sun Microsystems, Inc. Portions Copyright 1997-2000 Sun
  * Microsystems, Inc. All Rights Reserved.
  */
 package org.netbeans.lib.cvsclient;

 import com.intellij.util.concurrency.Semaphore;
 import org.jetbrains.annotations.NonNls;
 import org.netbeans.lib.cvsclient.command.CommandAbortedException;
 import org.netbeans.lib.cvsclient.command.CommandException;
 import org.netbeans.lib.cvsclient.command.IGlobalOptions;
 import org.netbeans.lib.cvsclient.command.IOCommandException;
 import org.netbeans.lib.cvsclient.connection.AuthenticationException;
 import org.netbeans.lib.cvsclient.event.IEventSender;
 import org.netbeans.lib.cvsclient.file.FileDetails;
 import org.netbeans.lib.cvsclient.file.FileObject;
 import org.netbeans.lib.cvsclient.io.IStreamLogger;
 import org.netbeans.lib.cvsclient.progress.sending.IRequestsProgressHandler;
 import org.netbeans.lib.cvsclient.request.*;
 import org.netbeans.lib.cvsclient.response.DefaultResponseHandler;
 import org.netbeans.lib.cvsclient.response.IResponseHandler;
 import org.netbeans.lib.cvsclient.response.ResponseParser;
 import org.netbeans.lib.cvsclient.response.ValidRequestsResponseHandler;
 import org.netbeans.lib.cvsclient.util.BugLog;

 import java.io.IOException;
 import java.io.Reader;
 import java.util.Iterator;
 import java.util.Map;
 import java.util.concurrent.Executors;
 import java.util.concurrent.Future;

 /**
  * @author Thomas Singer
  */
 public final class RequestProcessor implements IRequestProcessor {

   // Fields =================================================================

   private final IGlobalOptions globalOptions;
   private final IClientEnvironment clientEnvironment;
   private final ResponseService responseServices;
   private final IStreamLogger streamLogger;
   private final ICvsCommandStopper commandStopper;
   @NonNls private static final String OS_NAME_PROPERTY = "os.name";
   @NonNls private static final String WINDOWS_PREFIX = "Windows";
   @NonNls private static final String CASE_REQUEST = "Case";
   @NonNls private static final String CVS_PASS_ENV_VARS_PROPERTY = "cvs.pass.env.vars";
   @NonNls private static final String NO = "no";
   private final long myTimeout;

   // Setup ==================================================================
   public RequestProcessor(IClientEnvironment clientEnvironment,
                           IGlobalOptions globalOptions,
                           IEventSender eventSender,
                           IStreamLogger streamLogger,
                           ICvsCommandStopper commandStopper) {
     this(clientEnvironment, globalOptions, eventSender, streamLogger, commandStopper, -1);
   }

   public RequestProcessor(IClientEnvironment clientEnvironment,
                           IGlobalOptions globalOptions,
                           IEventSender eventSender,
                           IStreamLogger streamLogger,
                           ICvsCommandStopper commandStopper, final long timeout) {
     myTimeout = timeout;
     BugLog.getInstance().assertNotNull(globalOptions);
     BugLog.getInstance().assertNotNull(clientEnvironment);
     BugLog.getInstance().assertNotNull(eventSender);
     BugLog.getInstance().assertNotNull(streamLogger);
     BugLog.getInstance().assertNotNull(commandStopper);

     this.globalOptions = globalOptions;
     this.clientEnvironment = clientEnvironment;
     this.responseServices = new ResponseService(eventSender);
     this.streamLogger = streamLogger;
     this.commandStopper = commandStopper;
   }

   // Implemented ============================================================

   public boolean processRequests(Requests requests, IRequestsProgressHandler communicationProgressHandler) throws CommandException,
                                                                                                                   AuthenticationException {
     IConnectionStreams connectionStreams = openConnection();
     try {
       return processRequests(requests, connectionStreams, communicationProgressHandler);
     }
     finally {
       connectionStreams.close();
     }
   }

   // Utils ==================================================================

   private IConnectionStreams openConnection() throws CommandException, AuthenticationException {
     clientEnvironment.getConnection().open(streamLogger);

     ConnectionStreams connectionStreams =
       new ConnectionStreams(clientEnvironment.getConnection(), streamLogger, clientEnvironment.getCharset());
     boolean exception = true;
     try {
       updateValidRequests(connectionStreams);

       sendRequest(new RootRequest(clientEnvironment.getConnection().getRepository()), connectionStreams);
       sendSetRequests(globalOptions, connectionStreams);
       // Handle gzip-compression
       if (globalOptions.isUseGzip() && isValidRequest(GzipStreamRequest.REQUEST)) {
         sendRequest(new GzipStreamRequest(), connectionStreams);

         connectionStreams.setGzipped();
       }

       //TODO: set variables

       sendRequest(new ValidResponsesRequest(), connectionStreams);

       sendRequest(new UseUnchangedRequest(), connectionStreams);
       sendGlobalOptionRequests(globalOptions, connectionStreams);

       if (System.getProperty(OS_NAME_PROPERTY).startsWith(WINDOWS_PREFIX) && isValidRequest(CASE_REQUEST)) {
         sendRequest(new CaseRequest(), connectionStreams);
       }

       exception = false;
       return connectionStreams;
     }
     catch (IOException ex) {
       BugLog.getInstance().showException(ex);
       throw new IOCommandException(ex);
     }
     finally {
       if (exception) {
         connectionStreams.close();
       }
     }
   }

   private void sendSetRequests(IGlobalOptions globalOptions, ConnectionStreams connectionStreams)
     throws CommandAbortedException, IOException {
     Map envVariables = globalOptions.getEnvVariables();
     if (envVariables == null) {
       return;
     }
     for (Iterator iterator = envVariables.keySet().iterator(); iterator.hasNext();) {
       String varName = (String)iterator.next();
       String varValue = (String)envVariables.get(varName);
       sendRequest(new SetRequest(varName, varValue), connectionStreams);
     }
   }

   private boolean processRequests(final Requests requests,
                                   final IConnectionStreams connectionStreams,
                                   final IRequestsProgressHandler communicationProgressHandler)
     throws CommandException, IOCommandException {

     BugLog.getInstance().assertNotNull(requests);

     /*final ProcessRequestsHelper helper = (myTimeout == -1) ?
                                          new DirectProcessRequestHelper() : new TimedOutProcessRequestHelper();*/
     final ProcessRequestsHelper helper = new DirectProcessRequestHelper();
     return helper.processRequests(requests, connectionStreams, communicationProgressHandler);
   }

   private abstract class ProcessRequestsHelper {
     protected IOException myIOException;
     protected CommandException myCommandException;
     protected boolean myResult;

     protected abstract void before();
     protected abstract void callRunnable(final Runnable runnable);
     protected abstract void afterInRunnable();
     protected abstract void after() throws CommandException;

     public boolean processRequests(final Requests requests,
                                    final IConnectionStreams connectionStreams,
                                    final IRequestsProgressHandler communicationProgressHandler)
       throws CommandException, IOCommandException {
       final Runnable runnable = new Runnable() {
         public void run() {
           try {
             checkCanceled();
             sendRequests(requests, connectionStreams, communicationProgressHandler);
             checkCanceled();

             sendRequest(requests.getResponseExpectingRequest(), connectionStreams);
             connectionStreams.flushForReading();

             myResult = handleResponses(connectionStreams, new DefaultResponseHandler());
           }
           catch (IOException e) {
             myIOException = e;
           }
           catch (CommandException e) {
             myCommandException = e;
           }
           finally {
             afterInRunnable();
           }
         }
       };

       before();
       callRunnable(runnable);
       if (myIOException != null) throw new IOCommandException(myIOException);
       if (myCommandException != null) throw myCommandException;
       after();

       return myResult;
     }
   }

   private class TimedOutProcessRequestHelper extends ProcessRequestsHelper {
     private final Semaphore mySemaphore;
     private Future<?> myFuture;

     private TimedOutProcessRequestHelper() {
       mySemaphore = new Semaphore();
     }

     @Override
     protected void before() {
       mySemaphore.down();
     }

     @Override
     protected void callRunnable(Runnable runnable) {
       myFuture = Executors.newSingleThreadExecutor().submit(runnable);

       final long tOut = (myTimeout < 20000) ? 20000 : myTimeout;
       while (true) {
         mySemaphore.waitFor(tOut);
         if (myFuture.isDone() || myFuture.isCancelled()) break;
         if (! commandStopper.isAlive()) break;
         commandStopper.resetAlive();
       }
     }

     @Override
     protected void afterInRunnable() {
       mySemaphore.up();
     }

     @Override
     protected void after() throws CommandException {
       if ((! myFuture.isDone() && (! myFuture.isCancelled()) && (! commandStopper.isAlive()))) {
         myFuture.cancel(true);
         throw new CommandException(new CommandAbortedException(), "Command execution timed out");
       }
     }
   }

   private class DirectProcessRequestHelper extends ProcessRequestsHelper {
     @Override
     protected void before() {
     }

     @Override
     protected void callRunnable(Runnable runnable) {
       runnable.run();
     }

     @Override
     protected void afterInRunnable() {
     }

     @Override
     protected void after() throws CommandException {
     }
   }

   private void sendRequests(Requests requests, IConnectionStreams connectionStreams, IRequestsProgressHandler communicationProgressHandler)
     throws CommandAbortedException, IOException {
     for (Iterator it = requests.getRequests().iterator(); it.hasNext();) {
       final IRequest request = (IRequest)it.next();

       sendRequest(request, connectionStreams);

       final FileDetails fileDetails = request.getFileForTransmission();
       if (fileDetails != null) {
         sendFile(fileDetails, connectionStreams);
       }

       communicationProgressHandler.requestSent(request);
     }
   }

   private void updateValidRequests(IConnectionStreams connectionStreams) throws CommandException, IOException {
     sendRequest(new ValidRequestsRequest(), connectionStreams);
     connectionStreams.flushForReading();
     handleResponses(connectionStreams, new ValidRequestsResponseHandler());

     if (responseServices.getValidRequests() == null) {
       throw new ValidRequestsExpectedException();
     }
   }

   private void sendGlobalOptionRequests(IGlobalOptions globalOptions, IConnectionStreams connectionStreams)
     throws CommandAbortedException, IOException {
     if (!isValidRequest(GlobalOptionRequest.REQUEST)) {
       return;
     }

     if (globalOptions.isCheckedOutFilesReadOnly()) {
       sendRequest(new GlobalOptionRequest("-r"), connectionStreams);
     }
     if (globalOptions.isDoNoChanges()) {
       sendRequest(new GlobalOptionRequest("-n"), connectionStreams);
     }
     if (globalOptions.isNoHistoryLogging()) {
       sendRequest(new GlobalOptionRequest("-l"), connectionStreams);
     }
     if (globalOptions.isSomeQuiet()) {
       sendRequest(new GlobalOptionRequest("-q"), connectionStreams);
     }
   }

   private boolean isValidRequest(String request) {
     return responseServices.getValidRequests().indexOf(request) >= 0;
   }

   private void sendRequest(IRequest request, IConnectionStreams connectionStreams) throws CommandAbortedException, IOException {
     checkCanceled();
     connectionStreams.getLoggedWriter().write(request.getRequestString());
   }

   private void checkCanceled() throws CommandAbortedException {
     if (commandStopper.isAborted()) {
       throw new CommandAbortedException();
     }
   }

   private boolean handleResponses(IConnectionStreams connectionStreams, IResponseHandler responseHandler)
     throws CommandException, IOException {
     //final ErrorDefendingResponseHandler proxy = new ErrorDefendingResponseHandler(myTimeout, responseHandler);

     final ResponseParser responseParser = new ResponseParser(responseHandler, clientEnvironment.getCharset());
     final StringBuilder responseBuffer = new StringBuilder(32);
     while (true) {
       readResponse(connectionStreams.getLoggedReader(), responseBuffer);
       checkCanceled();
       if (responseBuffer.length() == 0) {
         return false;
       }

       final Boolean result =
         responseParser.processResponse(responseBuffer.toString(), connectionStreams, responseServices, clientEnvironment);
       if (result != null) {
         return result.booleanValue();
       }

       checkCanceled();
       /*if (proxy.interrupt()) {
         throw new CommandException(null, "Aborted: consequent errors stream");
       }*/
     }
   }

   private static void readResponse(Reader reader, StringBuilder responseBuffer) throws IOException {
     responseBuffer.setLength(0);

     for (int chr = reader.read(); chr >= 0; chr = reader.read()) {
       if (chr == '\n' || chr == ' ') {
         break;
       }
       responseBuffer.append((char)chr);
     }
   }

   private void sendFile(FileDetails fileDetails, IConnectionStreams connectionStreams) throws IOException {
     final FileObject fileObject = fileDetails.getFileObject();

     if (fileDetails.isBinary()) {
       clientEnvironment.getLocalFileReader().transmitBinaryFile(fileObject, connectionStreams, clientEnvironment.getCvsFileSystem());
     }
     else {
       clientEnvironment.getLocalFileReader().transmitTextFile(fileObject, connectionStreams, clientEnvironment.getCvsFileSystem());
     }
   }
 }
	/*
	* Sun Public License Notice
	*
	* The contents of this file are subject to the Sun Public License
	* Version 1.0 (the "License"). You may not use this file except in
	* compliance with the License. A copy of the License is available at
	* http://www.sun.com/
	*
	* The Original Code is NetBeans. The Initial Developer of the Original
	* Code is Sun Microsystems, Inc. Portions Copyright 1997-2000 Sun
	* Microsystems, Inc. All Rights Reserved.
	*/
	package org.netbeans.lib.cvsclient;

	import com.intellij.util.concurrency.Semaphore;
	import org.jetbrains.annotations.NonNls;
	import org.netbeans.lib.cvsclient.command.CommandAbortedException;
	import org.netbeans.lib.cvsclient.command.CommandException;
	import org.netbeans.lib.cvsclient.command.IGlobalOptions;
	import org.netbeans.lib.cvsclient.command.IOCommandException;
	import org.netbeans.lib.cvsclient.connection.AuthenticationException;
	import org.netbeans.lib.cvsclient.event.IEventSender;
	import org.netbeans.lib.cvsclient.file.FileDetails;
	import org.netbeans.lib.cvsclient.file.FileObject;
	import org.netbeans.lib.cvsclient.io.IStreamLogger;
	import org.netbeans.lib.cvsclient.progress.sending.IRequestsProgressHandler;
	import org.netbeans.lib.cvsclient.request.*;
	import org.netbeans.lib.cvsclient.response.DefaultResponseHandler;
	import org.netbeans.lib.cvsclient.response.IResponseHandler;
	import org.netbeans.lib.cvsclient.response.ResponseParser;
	import org.netbeans.lib.cvsclient.response.ValidRequestsResponseHandler;
	import org.netbeans.lib.cvsclient.util.BugLog;

	import java.io.IOException;
	import java.io.Reader;
	import java.util.Iterator;
	import java.util.Map;
	import java.util.concurrent.Executors;
	import java.util.concurrent.Future;

	/**
	* @author Thomas Singer
	*/
	public final class RequestProcessor implements IRequestProcessor {

	// Fields =================================================================

	private final IGlobalOptions globalOptions;
	private final IClientEnvironment clientEnvironment;
	private final ResponseService responseServices;
	private final IStreamLogger streamLogger;
	private final ICvsCommandStopper commandStopper;
	@NonNls private static final String OS_NAME_PROPERTY = "os.name";
	@NonNls private static final String WINDOWS_PREFIX = "Windows";
	@NonNls private static final String CASE_REQUEST = "Case";
	@NonNls private static final String CVS_PASS_ENV_VARS_PROPERTY = "cvs.pass.env.vars";
	@NonNls private static final String NO = "no";
	private final long myTimeout;

	// Setup ==================================================================
	public RequestProcessor(IClientEnvironment clientEnvironment,
	IGlobalOptions globalOptions,
	IEventSender eventSender,
	IStreamLogger streamLogger,
	ICvsCommandStopper commandStopper) {
	this(clientEnvironment, globalOptions, eventSender, streamLogger, commandStopper, -1);
	}

	public RequestProcessor(IClientEnvironment clientEnvironment,
	IGlobalOptions globalOptions,
	IEventSender eventSender,
	IStreamLogger streamLogger,
	ICvsCommandStopper commandStopper, final long timeout) {
	myTimeout = timeout;
	BugLog.getInstance().assertNotNull(globalOptions);
	BugLog.getInstance().assertNotNull(clientEnvironment);
	BugLog.getInstance().assertNotNull(eventSender);
	BugLog.getInstance().assertNotNull(streamLogger);
	BugLog.getInstance().assertNotNull(commandStopper);

	this.globalOptions = globalOptions;
	this.clientEnvironment = clientEnvironment;
	this.responseServices = new ResponseService(eventSender);
	this.streamLogger = streamLogger;
	this.commandStopper = commandStopper;
	}

	// Implemented ============================================================

	public boolean processRequests(Requests requests, IRequestsProgressHandler communicationProgressHandler) throws CommandException,
	AuthenticationException {
	IConnectionStreams connectionStreams = openConnection();
	try {
	return processRequests(requests, connectionStreams, communicationProgressHandler);
	}
	finally {
	connectionStreams.close();
	}
	}

	// Utils ==================================================================

	private IConnectionStreams openConnection() throws CommandException, AuthenticationException {
	clientEnvironment.getConnection().open(streamLogger);

	ConnectionStreams connectionStreams =
	new ConnectionStreams(clientEnvironment.getConnection(), streamLogger, clientEnvironment.getCharset());
	boolean exception = true;
	try {
	updateValidRequests(connectionStreams);

	sendRequest(new RootRequest(clientEnvironment.getConnection().getRepository()), connectionStreams);
	sendSetRequests(globalOptions, connectionStreams);
	// Handle gzip-compression
	if (globalOptions.isUseGzip() && isValidRequest(GzipStreamRequest.REQUEST)) {
	sendRequest(new GzipStreamRequest(), connectionStreams);

	connectionStreams.setGzipped();
	}

	//TODO: set variables

	sendRequest(new ValidResponsesRequest(), connectionStreams);

	sendRequest(new UseUnchangedRequest(), connectionStreams);
	sendGlobalOptionRequests(globalOptions, connectionStreams);

	if (System.getProperty(OS_NAME_PROPERTY).startsWith(WINDOWS_PREFIX) && isValidRequest(CASE_REQUEST)) {
	sendRequest(new CaseRequest(), connectionStreams);
	}

	exception = false;
	return connectionStreams;
	}
	catch (IOException ex) {
	BugLog.getInstance().showException(ex);
	throw new IOCommandException(ex);
	}
	finally {
	if (exception) {
	connectionStreams.close();
	}
	}
	}

	private void sendSetRequests(IGlobalOptions globalOptions, ConnectionStreams connectionStreams)
	throws CommandAbortedException, IOException {
	Map envVariables = globalOptions.getEnvVariables();
	if (envVariables == null) {
	return;
	}
	for (Iterator iterator = envVariables.keySet().iterator(); iterator.hasNext();) {
	String varName = (String)iterator.next();
	String varValue = (String)envVariables.get(varName);
	sendRequest(new SetRequest(varName, varValue), connectionStreams);
	}
	}

	private boolean processRequests(final Requests requests,
	final IConnectionStreams connectionStreams,
	final IRequestsProgressHandler communicationProgressHandler)
	throws CommandException, IOCommandException {

	BugLog.getInstance().assertNotNull(requests);

	/*final ProcessRequestsHelper helper = (myTimeout == -1) ?
	new DirectProcessRequestHelper() : new TimedOutProcessRequestHelper();*/
	final ProcessRequestsHelper helper = new DirectProcessRequestHelper();
	return helper.processRequests(requests, connectionStreams, communicationProgressHandler);
	}

	private abstract class ProcessRequestsHelper {
	protected IOException myIOException;
	protected CommandException myCommandException;
	protected boolean myResult;

	protected abstract void before();
	protected abstract void callRunnable(final Runnable runnable);
	protected abstract void afterInRunnable();
	protected abstract void after() throws CommandException;

	public boolean processRequests(final Requests requests,
	final IConnectionStreams connectionStreams,
	final IRequestsProgressHandler communicationProgressHandler)
	throws CommandException, IOCommandException {
	final Runnable runnable = new Runnable() {
	public void run() {
	try {
	checkCanceled();
	sendRequests(requests, connectionStreams, communicationProgressHandler);
	checkCanceled();

	sendRequest(requests.getResponseExpectingRequest(), connectionStreams);
	connectionStreams.flushForReading();

	myResult = handleResponses(connectionStreams, new DefaultResponseHandler());
	}
	catch (IOException e) {
	myIOException = e;
	}
	catch (CommandException e) {
	myCommandException = e;
	}
	finally {
	afterInRunnable();
	}
	}
	};

	before();
	callRunnable(runnable);
	if (myIOException != null) throw new IOCommandException(myIOException);
	if (myCommandException != null) throw myCommandException;
	after();

	return myResult;
	}
	}

	private class TimedOutProcessRequestHelper extends ProcessRequestsHelper {
	private final Semaphore mySemaphore;
	private Future<?> myFuture;

	private TimedOutProcessRequestHelper() {
	mySemaphore = new Semaphore();
	}

	@Override
	protected void before() {
	mySemaphore.down();
	}

	@Override
	protected void callRunnable(Runnable runnable) {
	myFuture = Executors.newSingleThreadExecutor().submit(runnable);

	final long tOut = (myTimeout < 20000) ? 20000 : myTimeout;
	while (true) {
	mySemaphore.waitFor(tOut);
	if (myFuture.isDone() \|\| myFuture.isCancelled()) break;
	if (! commandStopper.isAlive()) break;
	commandStopper.resetAlive();
	}
	}

	@Override
	protected void afterInRunnable() {
	mySemaphore.up();
	}

	@Override
	protected void after() throws CommandException {
	if ((! myFuture.isDone() && (! myFuture.isCancelled()) && (! commandStopper.isAlive()))) {
	myFuture.cancel(true);
	throw new CommandException(new CommandAbortedException(), "Command execution timed out");
	}
	}
	}

	private class DirectProcessRequestHelper extends ProcessRequestsHelper {
	@Override
	protected void before() {
	}

	@Override
	protected void callRunnable(Runnable runnable) {
	runnable.run();
	}

	@Override
	protected void afterInRunnable() {
	}

	@Override
	protected void after() throws CommandException {
	}
	}

	private void sendRequests(Requests requests, IConnectionStreams connectionStreams, IRequestsProgressHandler communicationProgressHandler)
	throws CommandAbortedException, IOException {
	for (Iterator it = requests.getRequests().iterator(); it.hasNext();) {
	final IRequest request = (IRequest)it.next();

	sendRequest(request, connectionStreams);

	final FileDetails fileDetails = request.getFileForTransmission();
	if (fileDetails != null) {
	sendFile(fileDetails, connectionStreams);
	}

	communicationProgressHandler.requestSent(request);
	}
	}

	private void updateValidRequests(IConnectionStreams connectionStreams) throws CommandException, IOException {
	sendRequest(new ValidRequestsRequest(), connectionStreams);
	connectionStreams.flushForReading();
	handleResponses(connectionStreams, new ValidRequestsResponseHandler());

	if (responseServices.getValidRequests() == null) {
	throw new ValidRequestsExpectedException();
	}
	}

	private void sendGlobalOptionRequests(IGlobalOptions globalOptions, IConnectionStreams connectionStreams)
	throws CommandAbortedException, IOException {
	if (!isValidRequest(GlobalOptionRequest.REQUEST)) {
	return;
	}

	if (globalOptions.isCheckedOutFilesReadOnly()) {
	sendRequest(new GlobalOptionRequest("-r"), connectionStreams);
	}
	if (globalOptions.isDoNoChanges()) {
	sendRequest(new GlobalOptionRequest("-n"), connectionStreams);
	}
	if (globalOptions.isNoHistoryLogging()) {
	sendRequest(new GlobalOptionRequest("-l"), connectionStreams);
	}
	if (globalOptions.isSomeQuiet()) {
	sendRequest(new GlobalOptionRequest("-q"), connectionStreams);
	}
	}

	private boolean isValidRequest(String request) {
	return responseServices.getValidRequests().indexOf(request) >= 0;
	}

	private void sendRequest(IRequest request, IConnectionStreams connectionStreams) throws CommandAbortedException, IOException {
	checkCanceled();
	connectionStreams.getLoggedWriter().write(request.getRequestString());
	}

	private void checkCanceled() throws CommandAbortedException {
	if (commandStopper.isAborted()) {
	throw new CommandAbortedException();
	}
	}

	private boolean handleResponses(IConnectionStreams connectionStreams, IResponseHandler responseHandler)
	throws CommandException, IOException {
	//final ErrorDefendingResponseHandler proxy = new ErrorDefendingResponseHandler(myTimeout, responseHandler);

	final ResponseParser responseParser = new ResponseParser(responseHandler, clientEnvironment.getCharset());
	final StringBuilder responseBuffer = new StringBuilder(32);
	while (true) {
	readResponse(connectionStreams.getLoggedReader(), responseBuffer);
	checkCanceled();
	if (responseBuffer.length() == 0) {
	return false;
	}

	final Boolean result =
	responseParser.processResponse(responseBuffer.toString(), connectionStreams, responseServices, clientEnvironment);
	if (result != null) {
	return result.booleanValue();
	}

	checkCanceled();
	/*if (proxy.interrupt()) {
	throw new CommandException(null, "Aborted: consequent errors stream");
	}*/
	}
	}

	private static void readResponse(Reader reader, StringBuilder responseBuffer) throws IOException {
	responseBuffer.setLength(0);

	for (int chr = reader.read(); chr >= 0; chr = reader.read()) {
	if (chr == '\n' \|\| chr == ' ') {
	break;
	}
	responseBuffer.append((char)chr);
	}
	}

	private void sendFile(FileDetails fileDetails, IConnectionStreams connectionStreams) throws IOException {
	final FileObject fileObject = fileDetails.getFileObject();

	if (fileDetails.isBinary()) {
	clientEnvironment.getLocalFileReader().transmitBinaryFile(fileObject, connectionStreams, clientEnvironment.getCvsFileSystem());
	}
	else {
	clientEnvironment.getLocalFileReader().transmitTextFile(fileObject, connectionStreams, clientEnvironment.getCvsFileSystem());
	}
	}
	}