Esempio n. 1
0
  /**
   * Update the listed files from the repository
   *
   * @param client The client to use to perform the update with
   * @param listener The listener to receive notifications of updated files
   * @param theFiles The set of files to update
   * @param force Whether to do a forced "clean copy" update (override local changes)
   * @return UpdateServerResponse with information about the update
   * @throws CommandAbortedException
   * @throws CommandException
   * @throws AuthenticationException
   * @throws InvalidCvsRootException
   */
  synchronized UpdateServerResponse doUpdateFiles(
      BlueJCvsClient client, UpdateListener listener, Set theFiles, boolean force)
      throws CommandAbortedException, CommandException, AuthenticationException {
    UpdateCommand command = new UpdateCommand();
    command.setFiles(listToFileArray(theFiles));

    command.setCleanCopy(force);
    command.setRecursive(false);
    command.setBuildDirectories(true);
    command.setPruneDirectories(true);

    UpdateServerResponse updateServerResponse = new UpdateServerResponse(listener, client);
    client.getEventManager().addCVSListener(updateServerResponse);
    client.setLocalPath(projectPath.getAbsolutePath());

    printCommand(command, client);
    setupConnection(client);

    try {
      adminHandler.setMildManneredMode(true);
      client.executeCommand(command, globalOptions);
      updateServerResponse.waitForExecutionToFinish();
    } finally {
      // restore previous excludes setting
      client.getEventManager().removeCVSListener(updateServerResponse);
      disconnect(client);
      adminHandler.setMildManneredMode(false);
    }

    updateServerResponse.setConflictMap(client.getConflictFiles());
    return updateServerResponse;
  }
Esempio n. 2
0
  /**
   * Get status of all the given files. Returns a List of TeamStatusInfo.
   *
   * @param files The files whose status to retrieve
   * @param remoteDirs These are the directories which we know are in the repository. Any file in
   *     the files list which does not exist locally but for which the containing directory is in
   *     the repository, should have that directory listed here.
   * @throws CommandAbortedException
   * @throws CommandException
   * @throws AuthenticationException
   * @throws InvalidCvsRootException
   */
  public synchronized StatusServerResponse getStatus(Client client, Set files, Set remoteDirs)
      throws CommandAbortedException, CommandException, AuthenticationException {
    // setupConnection();
    // Client client = getClient();
    setupConnection(client);

    // Now we can use the cvs "status" command to get status on the
    // remaining files.

    StatusCommand statusCommand = new StatusCommand();
    statusCommand.setFiles(listToFileArray(files));

    StatusServerResponse statusServerResponse = new StatusServerResponse();
    client.getEventManager().addCVSListener(statusServerResponse);

    client.setLocalPath(projectPath.getAbsolutePath());
    printCommand(statusCommand, client);
    adminHandler.setMildManneredMode(true);

    try {
      client.executeCommand(statusCommand, globalOptions);
      statusServerResponse.waitForExecutionToFinish();
    } finally {
      adminHandler.setMildManneredMode(false);
      client.getEventManager().removeCVSListener(statusServerResponse);
      disconnect(client);
    }

    return statusServerResponse;
  }
Esempio n. 3
0
  /**
   * Remove the files in an array of Files from the repository.
   *
   * @param files the files to remove.
   * @throws CommandException
   * @throws CommandAbortedException
   * @throws AuthenticationException
   * @throws InvalidCvsRootException
   */
  BasicServerResponse removeFromRepository(Client client, Collection files)
      throws CommandException, CommandAbortedException, AuthenticationException {
    BasicServerResponse basicServerResponse = new BasicServerResponse();

    if (files.size() < 1) {
      basicServerResponse.commandTerminated(null);
      return basicServerResponse;
    }

    setupConnection(client);
    // setupConnection();
    // Client client = getClient();

    RemoveCommand removeCommand = new RemoveCommand();
    removeCommand.setFiles(listToFileArray(files));

    client.getEventManager().addCVSListener(basicServerResponse);
    client.setLocalPath(projectPath.getAbsolutePath());

    printCommand(removeCommand, client);
    try {
      adminHandler.setMildManneredMode(true);
      client.executeCommand(removeCommand, globalOptions);
      basicServerResponse.waitForExecutionToFinish();
    } finally {
      client.getEventManager().removeCVSListener(basicServerResponse);
      disconnect(client);
      adminHandler.setMildManneredMode(false);
    }

    return basicServerResponse;
  }
Esempio n. 4
0
 /**
  * Find the remote directories which also exist locally, but are not locally under version
  * control.
  */
 public synchronized Set getRemoteDirs(Client client)
     throws AuthenticationException, CommandException {
   adminHandler.setMildManneredMode(true);
   Set remoteDirs = new HashSet();
   try {
     getRemoteFiles(client, null, projectPath, remoteDirs, true);
   } finally {
     adminHandler.setMildManneredMode(false);
   }
   return remoteDirs;
 }
Esempio n. 5
0
 /**
  * Get a list of files which are in the repository, but which are not in the local project. This
  * includes both files which have been locally deleted, and files which have been added to the
  * repository from another location.
  *
  * @param remoteDirs This set will have all remote directories which are found added to it.
  * @throws InvalidCvsRootException
  * @throws AuthenticationException
  * @throws CommandException
  */
 public synchronized List getRemoteFiles(Client client, Set remoteDirs)
     throws AuthenticationException, CommandException {
   List files = new LinkedList();
   adminHandler.setMildManneredMode(true);
   try {
     getRemoteFiles(client, files, projectPath, remoteDirs, false);
   } finally {
     adminHandler.setMildManneredMode(false);
   }
   return files;
 }
Esempio n. 6
0
 /**
  * Set the revision of a versioned file to the given revision, without altering the file contents.
  * (This is a way to "update" but keep the current file contents. The server doesn't need to be
  * contacted).
  */
 public synchronized void setFileVersion(File file, String revision) throws IOException {
   Entry cvsEntry = adminHandler.getEntry(file);
   if (cvsEntry != null) {
     cvsEntry.setRevision(revision);
   } else {
     cvsEntry = new Entry();
     cvsEntry.setName(file.getName());
     cvsEntry.setRevision(revision);
   }
   adminHandler.setEntry(file, cvsEntry);
 }
Esempio n. 7
0
 /**
  * Get the locally deleted files (files which are under version control, and which existed
  * locally, but which have been deleted locally).
  *
  * @param set The set to store the locally deleted files in
  * @param dir The directory to look for deleted files in (non-recursively)
  * @throws IOException
  */
 public void getLocallyDeletedFiles(Set set, File dir) throws IOException {
   Iterator i = adminHandler.getEntries(dir);
   while (i.hasNext()) {
     Entry entry = (Entry) i.next();
     File file = new File(dir, entry.getName());
     if (!file.exists() && !entry.isDirectory()) {
       set.add(new File(dir, entry.getName()));
     }
   }
 }
Esempio n. 8
0
 /** Prepare a newly created directory for version control. */
 public void prepareCreateDir(File dir) {
   adminHandler.prepareCreateDir(dir);
 }
Esempio n. 9
0
 /*
  * (non-Javadoc)
  * @see bluej.groupwork.Repository#prepareDeleteDir(java.io.File)
  */
 public boolean prepareDeleteDir(File dir) {
   /* Move the CVS metadata into a new location */
   adminHandler.prepareDeleteDir(dir);
   return true;
 }
Esempio n. 10
0
 /** Check whether a directory is under CVS control. */
 boolean isDirectoryUnderCVS(File dir) {
   String apath = adminHandler.getMetaDataPath(dir.getAbsolutePath());
   dir = new File(apath);
   return (new File(dir, "CVS").isDirectory());
 }