Esempio n. 1
0
 /**
  * Execute this checkout
  *
  * @return <code>false</code> if this method could not delete all the files which should be
  *     deleted (e.g. because of of the files was locked). In this case {@link #getToBeDeleted()}
  *     lists the files which should be tried to be deleted outside of this method. Although <code>
  *     false</code> is returned the checkout was successful and the working tree was updated for
  *     all other files. <code>true</code> is returned when no such problem occurred
  * @throws IOException
  */
 public boolean checkout() throws IOException {
   try {
     return doCheckout();
   } finally {
     dc.unlock();
   }
 }
Esempio n. 2
0
  @Override
  protected boolean mergeImpl() throws IOException {
    if (implicitDirCache) dircache = getRepository().lockDirCache();

    try {
      return mergeTrees(mergeBase(), sourceTrees[0], sourceTrees[1], false);
    } finally {
      if (implicitDirCache) dircache.unlock();
    }
  }
Esempio n. 3
0
  /**
   * Create a new in-core index representation, lock it, and read from disk.
   *
   * <p>The new index will be locked and then read before it is returned to the caller. Read
   * failures are reported as exceptions and therefore prevent the method from returning a partially
   * populated index. On read failure, the lock is released.
   *
   * @param indexLocation location of the index file on disk.
   * @param fs the file system abstraction which will be necessary to perform certain file system
   *     operations.
   * @return a cache representing the contents of the specified index file (if it exists) or an
   *     empty cache if the file does not exist.
   * @throws IOException the index file is present but could not be read, or the lock could not be
   *     obtained.
   * @throws CorruptObjectException the index file is using a format or extension that this library
   *     does not support.
   */
  public static DirCache lock(final File indexLocation, final FS fs)
      throws CorruptObjectException, IOException {
    final DirCache c = new DirCache(indexLocation, fs);
    if (!c.lock()) throw new LockFailedException(indexLocation);

    try {
      c.read();
    } catch (IOException e) {
      c.unlock();
      throw e;
    } catch (RuntimeException e) {
      c.unlock();
      throw e;
    } catch (Error e) {
      c.unlock();
      throw e;
    }

    return c;
  }
Esempio n. 4
0
  @Test
  public void testWriteEmptyUnlock_RealIndex() throws Exception {
    final File idx = new File(db.getDirectory(), "index");
    final File lck = new File(db.getDirectory(), "index.lock");
    assertFalse(idx.exists());
    assertFalse(lck.exists());

    final DirCache dc = db.lockDirCache();
    assertEquals(0, lck.length());
    dc.write();
    assertEquals(12 + 20, lck.length());

    dc.unlock();
    assertFalse(idx.exists());
    assertFalse(lck.exists());
  }
Esempio n. 5
0
  @Test
  public void testLockMissing_RealIndex() throws Exception {
    final File idx = new File(db.getDirectory(), "index");
    final File lck = new File(db.getDirectory(), "index.lock");
    assertFalse(idx.exists());
    assertFalse(lck.exists());

    final DirCache dc = db.lockDirCache();
    assertNotNull(dc);
    assertFalse(idx.exists());
    assertTrue(lck.exists());
    assertEquals(0, dc.getEntryCount());

    dc.unlock();
    assertFalse(idx.exists());
    assertFalse(lck.exists());
  }
Esempio n. 6
0
 @Test
 public void testWriteEmptyLockEmpty_RealIndex() throws Exception {
   final File idx = new File(db.getDirectory(), "index");
   final File lck = new File(db.getDirectory(), "index.lock");
   assertFalse(idx.exists());
   assertFalse(lck.exists());
   {
     final DirCache dc = db.lockDirCache();
     dc.write();
     assertTrue(dc.commit());
     assertTrue(idx.exists());
   }
   {
     final DirCache dc = db.lockDirCache();
     assertEquals(0, dc.getEntryCount());
     assertTrue(idx.exists());
     assertTrue(lck.exists());
     dc.unlock();
   }
 }
Esempio n. 7
0
  /**
   * Executes the {@code commit} command with all the options and parameters collected by the setter
   * methods of this class. Each instance of this class should only be used for one invocation of
   * the command (means: one call to {@link #call()})
   *
   * @return a {@link RevCommit} object representing the successful commit.
   * @throws NoHeadException when called on a git repo without a HEAD reference
   * @throws NoMessageException when called without specifying a commit message
   * @throws UnmergedPathsException when the current index contained unmerged paths (conflicts)
   * @throws ConcurrentRefUpdateException when HEAD or branch ref is updated concurrently by someone
   *     else
   * @throws WrongRepositoryStateException when repository is not in the right state for committing
   * @throws AbortedByHookException if there are either pre-commit or commit-msg hooks present in
   *     the repository and one of them rejects the commit.
   */
  public RevCommit call()
      throws GitAPIException, NoHeadException, NoMessageException, UnmergedPathsException,
          ConcurrentRefUpdateException, WrongRepositoryStateException, AbortedByHookException {
    checkCallable();
    Collections.sort(only);

    try (RevWalk rw = new RevWalk(repo)) {
      RepositoryState state = repo.getRepositoryState();
      if (!state.canCommit())
        throw new WrongRepositoryStateException(
            MessageFormat.format(JGitText.get().cannotCommitOnARepoWithState, state.name()));

      if (!noVerify) {
        Hooks.preCommit(repo, hookOutRedirect).call();
      }

      processOptions(state, rw);

      if (all && !repo.isBare() && repo.getWorkTree() != null) {
        try (Git git = new Git(repo)) {
          git.add()
              .addFilepattern(".") // $NON-NLS-1$
              .setUpdate(true)
              .call();
        } catch (NoFilepatternException e) {
          // should really not happen
          throw new JGitInternalException(e.getMessage(), e);
        }
      }

      Ref head = repo.getRef(Constants.HEAD);
      if (head == null)
        throw new NoHeadException(JGitText.get().commitOnRepoWithoutHEADCurrentlyNotSupported);

      // determine the current HEAD and the commit it is referring to
      ObjectId headId = repo.resolve(Constants.HEAD + "^{commit}"); // $NON-NLS-1$
      if (headId == null && amend)
        throw new WrongRepositoryStateException(JGitText.get().commitAmendOnInitialNotPossible);

      if (headId != null)
        if (amend) {
          RevCommit previousCommit = rw.parseCommit(headId);
          for (RevCommit p : previousCommit.getParents()) parents.add(p.getId());
          if (author == null) author = previousCommit.getAuthorIdent();
        } else {
          parents.add(0, headId);
        }

      if (!noVerify) {
        message = Hooks.commitMsg(repo, hookOutRedirect).setCommitMessage(message).call();
      }

      // lock the index
      DirCache index = repo.lockDirCache();
      try (ObjectInserter odi = repo.newObjectInserter()) {
        if (!only.isEmpty()) index = createTemporaryIndex(headId, index, rw);

        // Write the index as tree to the object database. This may
        // fail for example when the index contains unmerged paths
        // (unresolved conflicts)
        ObjectId indexTreeId = index.writeTree(odi);

        if (insertChangeId) insertChangeId(indexTreeId);

        // Create a Commit object, populate it and write it
        CommitBuilder commit = new CommitBuilder();
        commit.setCommitter(committer);
        commit.setAuthor(author);
        commit.setMessage(message);

        commit.setParentIds(parents);
        commit.setTreeId(indexTreeId);
        ObjectId commitId = odi.insert(commit);
        odi.flush();

        RevCommit revCommit = rw.parseCommit(commitId);
        RefUpdate ru = repo.updateRef(Constants.HEAD);
        ru.setNewObjectId(commitId);
        if (reflogComment != null) {
          ru.setRefLogMessage(reflogComment, false);
        } else {
          String prefix =
              amend
                  ? "commit (amend): " //$NON-NLS-1$
                  : parents.size() == 0
                      ? "commit (initial): " //$NON-NLS-1$
                      : "commit: "; //$NON-NLS-1$
          ru.setRefLogMessage(prefix + revCommit.getShortMessage(), false);
        }
        if (headId != null) ru.setExpectedOldObjectId(headId);
        else ru.setExpectedOldObjectId(ObjectId.zeroId());
        Result rc = ru.forceUpdate();
        switch (rc) {
          case NEW:
          case FORCED:
          case FAST_FORWARD:
            {
              setCallable(false);
              if (state == RepositoryState.MERGING_RESOLVED || isMergeDuringRebase(state)) {
                // Commit was successful. Now delete the files
                // used for merge commits
                repo.writeMergeCommitMsg(null);
                repo.writeMergeHeads(null);
              } else if (state == RepositoryState.CHERRY_PICKING_RESOLVED) {
                repo.writeMergeCommitMsg(null);
                repo.writeCherryPickHead(null);
              } else if (state == RepositoryState.REVERTING_RESOLVED) {
                repo.writeMergeCommitMsg(null);
                repo.writeRevertHead(null);
              }
              return revCommit;
            }
          case REJECTED:
          case LOCK_FAILURE:
            throw new ConcurrentRefUpdateException(
                JGitText.get().couldNotLockHEAD, ru.getRef(), rc);
          default:
            throw new JGitInternalException(
                MessageFormat.format(
                    JGitText.get().updatingRefFailed, Constants.HEAD, commitId.toString(), rc));
        }
      } finally {
        index.unlock();
      }
    } catch (UnmergedPathException e) {
      throw new UnmergedPathsException(e);
    } catch (IOException e) {
      throw new JGitInternalException(
          JGitText.get().exceptionCaughtDuringExecutionOfCommitCommand, e);
    }
  }