import org.netbeans.lib.cvsclient.connection.AuthenticationException; //导入依赖的package包/类
protected synchronized void execute(GeneralCommandLine commandLine) throws AuthenticationException {
  try {
    commandLine.withParentEnvironmentType(ParentEnvironmentType.CONSOLE);
    myProcess = commandLine.createProcess();

    myErrThread = new ReadProcessThread(
      new BufferedReader(new InputStreamReader(myProcess.getErrorStream(), EncodingManager.getInstance().getDefaultCharset()))) {
      protected void textAvailable(String s) {
        myErrorText.append(s);
        myErrorRegistry.registerError(s);
        myContainsError = true;
      }
    };
    final Application application = ApplicationManager.getApplication();
    myStdErrFuture = application.executeOnPooledThread(myErrThread);

    myInputStream = myProcess.getInputStream();
    myOutputStream = myProcess.getOutputStream();

    waitForProcess(application);
  }
  catch (Exception e) {
    closeInternal();
    throw new AuthenticationException(e.getLocalizedMessage(), e);
  }
}
 

import org.netbeans.lib.cvsclient.connection.AuthenticationException; //导入依赖的package包/类
public SshSharedConnection(final String repository, final ConnectionSettings connectionSettings, final SshAuthentication authentication) {
  myValid = new AtomicBoolean(true);
  myRepository = repository;
  myConnectionSettings = connectionSettings;
  myLock = new Object();

  myConnectionFactory = new ThrowableComputable<Connection, AuthenticationException>() {
    public Connection compute() throws AuthenticationException {
      try {
        SshLogger.debug("connection factory called");
        return SshConnectionUtils.openConnection(connectionSettings, authentication);
      }
      catch (AuthenticationException e) {
        // todo +-
        myValid.set(false);
        throw e;
      } catch (IOException e) {
        // todo +-
        myValid.set(false);
        throw new AuthenticationException(e.getMessage(), e);
      }
    }
  };
  myQueue = new LinkedList<Cell>();
}
 

import org.netbeans.lib.cvsclient.connection.AuthenticationException; //导入依赖的package包/类
public boolean execute(IRequestProcessor requestProcessor, IEventSender eventManager, ICvsListenerRegistry listenerRegistry, IClientEnvironment clientEnvironment, IProgressViewer progressViewer) throws CommandException,
                                                                                                                                                                                                                 AuthenticationException {
	BugLog.getInstance().assertNotNull(keywordSubstitution);

	final ICvsFiles cvsFiles;
	try {
		cvsFiles = scanFileSystem(clientEnvironment);
	}
	catch (IOException ex) {
		throw new IOCommandException(ex);
	}

	final Requests requests = new Requests(CommandRequest.ADMIN, clientEnvironment);
	requests.addArgumentRequest(keywordSubstitution, "-k");
	addFileRequests(cvsFiles, requests, clientEnvironment);
	requests.addLocalPathDirectoryRequest();
	addArgumentRequests(requests);

	return requestProcessor.processRequests(requests, FileStateRequestsProgressHandler.create(progressViewer, cvsFiles));
}
 

import org.netbeans.lib.cvsclient.connection.AuthenticationException; //导入依赖的package包/类
public boolean execute(IRequestProcessor requestProcessor, IEventSender eventManager, ICvsListenerRegistry listenerRegistry, IClientEnvironment clientEnvironment, IProgressViewer progressViewer) throws CommandException,
                                                                                                                                                                                                                 AuthenticationException {
	BugLog.getInstance().assertTrue(isSetLock() || isResetLock(), "Nothing specified");

	final ICvsFiles cvsFiles;
	try {
		cvsFiles = scanFileSystem(clientEnvironment);
	}
	catch (IOException ex) {
		throw new IOCommandException(ex);
	}

	final Requests requests = new Requests(CommandRequest.ADMIN, clientEnvironment);
	requests.addArgumentRequest(isSetLock(), "-l");
	requests.addArgumentRequest(isResetLock(), "-u");
	addFileRequests(cvsFiles, requests, clientEnvironment);
	requests.addLocalPathDirectoryRequest();
	addArgumentRequests(requests);

	final IRequestsProgressHandler requestsProgressHandler = FileStateRequestsProgressHandler.create(progressViewer, cvsFiles);
	return requestProcessor.processRequests(requests, requestsProgressHandler);
}
 

import org.netbeans.lib.cvsclient.connection.AuthenticationException; //导入依赖的package包/类
public boolean loginAll(final boolean goOffline) {
  for (CvsEnvironment root : myRoots) {
    final CvsLoginWorker worker = root.getLoginWorker(myProject);

    try {
      final ThreeState checkResult = checkLoginWorker(worker, myForceCheck);
      if (! ThreeState.YES.equals(checkResult)) {
        if (ThreeState.UNSURE.equals(checkResult)) {
          if (goOffline) {
            worker.goOffline();
          }
          myExceptionConsumer.consume(new CvsException("Authentication canceled", root.getCvsRootAsString()));
        }
        return false;
      }
    } catch (AuthenticationException e) {
      myExceptionConsumer.consume(new CvsException(e, root.getCvsRootAsString()));
      return false;
    }
  }
  return true;
}
 

import org.netbeans.lib.cvsclient.connection.AuthenticationException; //导入依赖的package包/类
@Override
public ThreeState silentLogin(boolean forceCheck) throws AuthenticationException {
  if (mySettings.isOffline())  return ThreeState.NO;

  try {
    silentLoginImpl(forceCheck);
  }
  catch (AuthenticationException e) {
    if (e.isSolveable()) {
      clearOldCredentials();
      return ThreeState.UNSURE;
    }
    throw e;
  }
  return ThreeState.YES;
}
 

import org.netbeans.lib.cvsclient.connection.AuthenticationException; //导入依赖的package包/类
@Override
protected void silentLoginImpl(boolean forceCheck) throws AuthenticationException {
  IConnection connection = mySettings.createConnection(new ReadWriteStatistics());
  try {
    connection.open(new StreamLogger());
    mySettings.setOffline(false);
  }
  finally {
    try {
      connection.close();
    }
    catch (IOException e) {
      LOG.info(e);
    }
  }
}
 

import org.netbeans.lib.cvsclient.connection.AuthenticationException; //导入依赖的package包/类
public boolean execute(IRequestProcessor requestProcessor, IEventSender eventSender, ICvsListenerRegistry listenerRegistry, IClientEnvironment clientEnvironment, IProgressViewer progressViewer) throws CommandException,
                                                                                                                                                                                                                AuthenticationException {
	final ICvsFiles cvsFiles;
	try {
		cvsFiles = scanFileSystem(clientEnvironment);
	}
	catch (IOException ex) {
		throw new IOCommandException(ex);
	}

	final Requests requests = new Requests(CommandRequest.EDITORS, clientEnvironment);
	addFileRequests(cvsFiles, requests, clientEnvironment);
	requests.addLocalPathDirectoryRequest();
	addArgumentRequests(requests);

	final ICvsListener builder = new EditorsMessageParser(eventSender, clientEnvironment.getCvsFileSystem(), cvsFiles);
	builder.registerListeners(listenerRegistry);
	try {
		return requestProcessor.processRequests(requests, FileStateRequestsProgressHandler.create(progressViewer, cvsFiles));
	}
	finally {
		builder.unregisterListeners(listenerRegistry);
	}
}
 

import org.netbeans.lib.cvsclient.connection.AuthenticationException; //导入依赖的package包/类
public boolean execute(IRequestProcessor requestProcessor, IEventSender eventManager, ICvsListenerRegistry listenerRegistry, IClientEnvironment clientEnvironment, IProgressViewer progressViewer) throws CommandException,
                                                                                                                                                                                                                 AuthenticationException {
	final ICvsFiles cvsFiles;
	try {
		cvsFiles = scanFileSystem(clientEnvironment);
	}
	catch (IOException ex) {
		throw new IOCommandException(ex);
	}

	final Requests requests = new Requests(CommandRequest.NOOP, clientEnvironment);
	addFileRequests(cvsFiles, requests, clientEnvironment);
	requests.addLocalPathDirectoryRequest();

	return requestProcessor.processRequests(requests, FileStateRequestsProgressHandler.create(progressViewer, cvsFiles));
}
 

import org.netbeans.lib.cvsclient.connection.AuthenticationException; //导入依赖的package包/类
/**
 * Executes this command.
 *
 * @param requestProcessor the client services object that provides any necessary
 *               services to this command, including the ability to actually
 *               process all the requests
 */
public boolean execute(IRequestProcessor requestProcessor, IEventSender eventManager, ICvsListenerRegistry listenerRegistry, IClientEnvironment clientEnvironment, IProgressViewer progressViewer) throws CommandException,
                                                                                                                                                                                                                 AuthenticationException {
	final ICvsFiles cvsFiles;
	try {
		cvsFiles = scanFileSystem(clientEnvironment);
	}
	catch (IOException ex) {
		throw new IOCommandException(ex);
	}

	final Requests requests = new Requests(CommandRequest.WATCHERS, clientEnvironment);
	addFileRequests(cvsFiles, requests, clientEnvironment);
	requests.addLocalPathDirectoryRequest();
	addArgumentRequests(requests);

	return requestProcessor.processRequests(requests, FileStateRequestsProgressHandler.create(progressViewer, cvsFiles));
}
 

import org.netbeans.lib.cvsclient.connection.AuthenticationException; //导入依赖的package包/类
private boolean checkout(ExpandedModules expandedModules, IRequestProcessor requestProcessor, ICvsListenerRegistry listenerRegistry, IClientEnvironment clientEnvironment)
         throws CommandException, AuthenticationException {
	// we first see whether the modules specified actually exist
	// checked out already. If so, we must work something like an update
	// command and send modified files to the server.
	processExistingModules(expandedModules, clientEnvironment);

	final Requests requests;
	requests = new Requests(CommandRequest.EXPORT, clientEnvironment);
	if (getAlternativeCheckoutDirectory() != null) {
		requests.addArgumentRequest("-d");
		requests.addArgumentRequest(getAlternativeCheckoutDirectory());
	}
	requests.addArgumentRequest(!isRecursive(), "-l");
	requests.addArgumentRequest(getUpdateByDate(), "-D");
	requests.addArgumentRequest(getUpdateByRevisionOrTag(), "-r");
	requests.addArgumentRequest(getKeywordSubstitution(), "-k");
	addModuleArguments(requests);
	requests.addLocalPathDirectoryRequest();

	try {
		return requestProcessor.processRequests(requests, new DummyRequestsProgressHandler());
	}
	finally {
	}
}
 

import org.netbeans.lib.cvsclient.connection.AuthenticationException; //导入依赖的package包/类
@Override
public boolean execute(IRequestProcessor requestProcessor, IEventSender eventManager,
                       ICvsListenerRegistry listenerRegistry,
                       IClientEnvironment clientEnvironment,
                       IProgressViewer progressViewer) throws CommandException, AuthenticationException {
  modules.clear();

  final Requests requests = new Requests(CommandRequest.CHECKOUT, clientEnvironment);
  requests.addArgumentRequest("-N");
  requests.addArgumentRequest("-c");
  requests.addDirectoryRequest(DirectoryObject.createInstance("/"));

  final ICvsListener listener = new GetModulesParser();
  listener.registerListeners(listenerRegistry);
  try {
    return requestProcessor.processRequests(requests, new DummyRequestsProgressHandler());
  }
  finally {
    listener.unregisterListeners(listenerRegistry);
  }
}
 

import org.netbeans.lib.cvsclient.connection.AuthenticationException; //导入依赖的package包/类
private boolean expandModules(ExpandedModules expandedModules,
                              ICvsListenerRegistry listenerRegistry,
                              IRequestProcessor requestProcessor,
                              IClientEnvironment clientEnvironment) throws CommandException, AuthenticationException {
  final Requests requests = new Requests(new ExpandModulesRequest(), clientEnvironment);

  addModuleArguments(requests);
  requests.addLocalPathDirectoryRequest();

  expandedModules.registerListeners(listenerRegistry);
  try {
    return requestProcessor.processRequests(requests, new DummyRequestsProgressHandler());
  }
  finally {
    expandedModules.unregisterListeners(listenerRegistry);
  }
}
 

import org.netbeans.lib.cvsclient.connection.AuthenticationException; //导入依赖的package包/类
protected synchronized void execute(GeneralCommandLine commandLine) throws AuthenticationException {
  try {
    commandLine.setPassParentEnvironment(true);
    myProcess = commandLine.createProcess();

    myErrThread = new ReadProcessThread(
      new BufferedReader(new InputStreamReader(myProcess.getErrorStream(), EncodingManager.getInstance().getDefaultCharset()))) {
      protected void textAvailable(String s) {
        myErrorText.append(s);
        myErrorRegistry.registerError(s);
        myContainsError = true;
      }
    };
    final Application application = ApplicationManager.getApplication();
    myStdErrFuture = application.executeOnPooledThread(myErrThread);

    myInputStream = myProcess.getInputStream();
    myOutputStream = myProcess.getOutputStream();

    waitForProcess(application);
  }
  catch (Exception e) {
    closeInternal();
    throw new AuthenticationException(e.getLocalizedMessage(), e);
  }
}
 

import org.netbeans.lib.cvsclient.connection.AuthenticationException; //导入依赖的package包/类
/**
 * Process the CVS command passed in args[] array with all necessary
 * options. The only difference from main() method is, that this method
 * does not exit the JVM and provides command output.
 *
 * @param args The command with options
 * @throws AuthenticationException 
 * @throws CommandException 
 */
public boolean processCommand(String command, GlobalOptions globalOptions, String[] args, File workingDir, CVSListener listener)
  throws AuthenticationException, CommandException {

  // if we don't have a CVS root by now, the user has messed up
  if (globalOptions.getCVSRoot() == null) {
    throw new IllegalStateException("No CVS root is set. Please set " + CvsConfiguration.CVS_ROOT_PROP_KEY + ".");
  }

  final String cvsRoot = globalOptions.getCVSRoot();
  CVSRoot root = parseCvsRoot(cvsRoot);

  org.netbeans.lib.cvsclient.command.Command c = CommandFactory.getDefault().createCommand(command, args, 0, globalOptions, workingDir.getAbsolutePath());

  String username = getUsername(root);
  String password = getPassword(cvsRoot, root);
  try {
    connect(workingDir, root, username, password);
    client.getEventManager().addCVSListener(listener);
    LOG.debug("Executing CVS command: " + c.getCVSCommand());
    return client.executeCommand(c, globalOptions);
  } finally {
    disconnect();
  }
}
 

import org.netbeans.lib.cvsclient.connection.AuthenticationException; //导入依赖的package包/类
public List<String> getModules(CvsCredentials cvsCredentials, String localPath)
			throws CommandException, CommandAbortedException, AuthenticationException {
		
		try {
			Client client = CvsConnection.openClient(cvsCredentials.getCvsRoot(), cvsCredentials.getPassword(), localPath);
			globalOptions = new GlobalOptions();
			globalOptions.setCVSRoot(cvsCredentials.getCvsRoot());
			globalOptions.setDoNoChanges(true);

			UpdateCommand updateCommand = new UpdateCommand();
			updateCommand.setBuildDirectories(true);
			AdminHandler handler = new StandardAdminHandler();

			client.setAdminHandler(handler);
			EventManager eventManager = client.getEventManager();
			ModuleCollectingListener moduleCollectingListener = new ModuleCollectingListener();
			eventManager.addCVSListener(moduleCollectingListener);
			client.executeCommand(updateCommand, globalOptions);
			return moduleCollectingListener.getModules();
		} finally {
//			closeConnection(connection);
		}
	}
 

import org.netbeans.lib.cvsclient.connection.AuthenticationException; //导入依赖的package包/类
public void open() throws AuthenticationException {
  if (!myLocalSettings.isCvsClientVerified()) {
    verifyServerCapability();
    myLocalSettings.setCvsClientVerified(true);
  }

  final GeneralCommandLine commandLine = new GeneralCommandLine();
  commandLine.setExePath(myLocalSettings.PATH_TO_CVS_CLIENT);
  commandLine.addParameter("server");
  
  execute(commandLine);
}
 

import org.netbeans.lib.cvsclient.connection.AuthenticationException; //导入依赖的package包/类
private void verifyServerCapability() throws AuthenticationException {
  final GeneralCommandLine commandLine = new GeneralCommandLine();
  commandLine.setExePath(myLocalSettings.PATH_TO_CVS_CLIENT);
  commandLine.addParameter("-v");
  execute(commandLine);
  try {
    StringBuilder responseBuilder = new StringBuilder();
    while(true) {
      int c = myInputStream.read();
      if (c == -1) {
        break;
      }
      responseBuilder.append((char) c);
    }
    String[] lines = responseBuilder.toString().split("\n");
    for (String line : lines) {
      // check that the first non-empty line does not end with (client)
      if (line.trim().endsWith("(client)")) {
        throw new AuthenticationException("CVS client does not support server mode operation", null);
      }
      if (line.trim().length() > 0) {
        break;
      }
    }
  }
  catch (IOException e) {
    throw new AuthenticationException("Can't read CVS version", e);
  }
  closeInternal();
}
 

import org.netbeans.lib.cvsclient.connection.AuthenticationException; //导入依赖的package包/类
private Cell(final ThrowableComputable<Connection, AuthenticationException> factory, final String repository) {
  myConnectionLifeCycle = new ConnectionLifeCycle(CHECK_GRANULARITY, factory);
  myRepository = repository;
  mySessions = new LinkedList<IConnection>();

  myCloseListener = new Consumer<SshSessionConnection>() {
        public void consume(final SshSessionConnection sshSessionConnection) {
          synchronized (myLock) {
            final boolean removed = mySessions.remove(sshSessionConnection);
            SshLogger.debug("shared connection: session closed notification, removed: " + removed);
            myTs = System.currentTimeMillis();
          }
        }
      };

  mySessionProvider = new ThrowableComputable<Session, AuthenticationException>() {
    public Session compute() throws AuthenticationException {
      final Connection connection;
      synchronized (myLock) {
        connection = myConnectionLifeCycle.getConnection();
      }
      SshLogger.debug("shared connection: opening session");
      try {
        final Session session = connection.openSession();
        session.execCommand("cvs server");
        return session;
      }
      catch (IOException e) {
        throw new AuthenticationException(e.getMessage(), e);
      }
    }
  };
}
 

import org.netbeans.lib.cvsclient.connection.AuthenticationException; //导入依赖的package包/类
public static Connection openConnection(final ConnectionSettings connectionSettings, final SshAuthentication authentication)
  throws AuthenticationException, IOException {
  final int port = connectionSettings.getPort() == -1 ? SSH_DEFAULT_PORT : connectionSettings.getPort();
  final Connection connection = new Connection(connectionSettings.getHostName(), port);
  final ProxyData proxy = SshProxyFactory.createAndRegister(connectionSettings);
  if (proxy != null) {
    connection.setProxyData(proxy);
  }
  connection.connect(null, connectionSettings.getConnectionTimeout(), connectionSettings.getConnectionTimeout());
  authentication.authenticate(connection);
  //HTTPProxyException
  return connection;
}