Examples of ObjectInserter


Examples of org.eclipse.jgit.lib.ObjectInserter

    ProgressMonitor receiving = NullProgressMonitor.INSTANCE;
    ProgressMonitor resolving = NullProgressMonitor.INSTANCE;
    if (sideBand)
      resolving = new SideBandProgressMonitor(msgOut);

    ObjectInserter ins = db.newObjectInserter();
    try {
      String lockMsg = "jgit receive-pack";
      if (getRefLogIdent() != null)
        lockMsg += " from " + getRefLogIdent().toExternalString();

      parser = ins.newPackParser(rawIn);
      parser.setAllowThin(true);
      parser.setNeedNewObjectIds(checkReferencedIsReachable);
      parser.setNeedBaseObjectIds(checkReferencedIsReachable);
      parser.setObjectChecking(isCheckReceivedObjects());
      parser.setLockMessage(lockMsg);
      packLock = parser.parse(receiving, resolving);
      ins.flush();
    } finally {
      ins.release();
    }

    if (timeoutIn != null)
      timeoutIn.setTimeout(timeout * 1000);
  }
 
View Full Code Here

Examples of org.eclipse.jgit.lib.ObjectInserter

    String message = "Created branch " + branchName;
    if (author == null) {
      author = new PersonIdent("Gitblit", "gitblit@localhost");
    }
    try {
      ObjectInserter odi = repository.newObjectInserter();
      try {
        // Create a blob object to insert into a tree
        ObjectId blobId = odi.insert(Constants.OBJ_BLOB,
            message.getBytes(Constants.CHARACTER_ENCODING));

        // Create a tree object to reference from a commit
        TreeFormatter tree = new TreeFormatter();
        tree.append(".branch", FileMode.REGULAR_FILE, blobId);
        ObjectId treeId = odi.insert(tree);

        // Create a commit object
        CommitBuilder commit = new CommitBuilder();
        commit.setAuthor(author);
        commit.setCommitter(author);
        commit.setEncoding(Constants.CHARACTER_ENCODING);
        commit.setMessage(message);
        commit.setTreeId(treeId);

        // Insert the commit into the repository
        ObjectId commitId = odi.insert(commit);
        odi.flush();

        RevWalk revWalk = new RevWalk(repository);
        try {
          RevCommit revCommit = revWalk.parseCommit(commitId);
          if (!branchName.startsWith("refs/")) {
            branchName = "refs/heads/" + branchName;
          }
          RefUpdate ru = repository.updateRef(branchName);
          ru.setNewObjectId(commitId);
          ru.setRefLogMessage("commit: " + revCommit.getShortMessage(), false);
          Result rc = ru.forceUpdate();
          switch (rc) {
          case NEW:
          case FORCED:
          case FAST_FORWARD:
            success = true;
            break;
          default:
            success = false;
          }
        } finally {
          revWalk.release();
        }
      } finally {
        odi.release();
      }
    } catch (Throwable t) {
      error(t, repository, "Failed to create orphan branch {1} in repository {0}", branchName);
    }
    return success;
View Full Code Here

Examples of org.eclipse.jgit.lib.ObjectInserter

      RecursiveMerger merger = (RecursiveMerger) MergeStrategy.RECURSIVE.newMerger(repository, true);
      boolean merged = merger.merge(branchTip, srcTip);
      if (merged) {
        // create a merge commit and a reference to track the merge commit
        ObjectId treeId = merger.getResultTreeId();
        ObjectInserter odi = repository.newObjectInserter();
        try {
          // Create a commit object
          CommitBuilder commitBuilder = new CommitBuilder();
          commitBuilder.setCommitter(committer);
          commitBuilder.setAuthor(committer);
          commitBuilder.setEncoding(Constants.CHARSET);
          if (StringUtils.isEmpty(message)) {
            message = MessageFormat.format("merge {0} into {1}", srcTip.getName(), branchTip.getName());
          }
          commitBuilder.setMessage(message);
          commitBuilder.setParentIds(branchTip.getId(), srcTip.getId());
          commitBuilder.setTreeId(treeId);

          // Insert the merge commit into the repository
          ObjectId mergeCommitId = odi.insert(commitBuilder);
          odi.flush();

          // set the merge ref to the merge commit
          RevCommit mergeCommit = revWalk.parseCommit(mergeCommitId);
          RefUpdate mergeRefUpdate = repository.updateRef(toBranch);
          mergeRefUpdate.setNewObjectId(mergeCommitId);
          mergeRefUpdate.setRefLogMessage("commit: " + mergeCommit.getShortMessage(), false);
          RefUpdate.Result rc = mergeRefUpdate.update();
          switch (rc) {
          case FAST_FORWARD:
            // successful, clean merge
            break;
          default:
            throw new GitBlitException(MessageFormat.format("Unexpected result \"{0}\" when merging commit {1} into {2} in {3}",
                rc.name(), srcTip.getName(), branchTip.getName(), repository.getDirectory()));
          }

          // return the merge commit id
          return new MergeResult(MergeStatus.MERGED, mergeCommitId.getName());
        } finally {
          odi.release();
        }
      }
    } catch (IOException e) {
      LOGGER.error("Failed to merge", e);
    } finally {
View Full Code Here

Examples of org.eclipse.jgit.lib.ObjectInserter

    }

    // build an initial commit
    boolean success = false;
    Repository db = app().repositories().getRepository(repositoryModel.name);
    ObjectInserter odi = db.newObjectInserter();
    try {

      UserModel user = GitBlitWebSession.get().getUser();
      String email = Optional.fromNullable(user.emailAddress).or(user.username + "@" + "gitblit");
      PersonIdent author = new PersonIdent(user.getDisplayName(), email);

      DirCache newIndex = DirCache.newInCore();
      DirCacheBuilder indexBuilder = newIndex.builder();

      if (addReadme) {
        // insert a README
        String title = StringUtils.stripDotGit(StringUtils.getLastPathElement(repositoryModel.name));
        String description = repositoryModel.description == null ? "" : repositoryModel.description;
        String readme = String.format("## %s\n\n%s\n\n", title, description);
        byte [] bytes = readme.getBytes(Constants.ENCODING);

        DirCacheEntry entry = new DirCacheEntry("README.md");
        entry.setLength(bytes.length);
        entry.setLastModified(System.currentTimeMillis());
        entry.setFileMode(FileMode.REGULAR_FILE);
        entry.setObjectId(odi.insert(org.eclipse.jgit.lib.Constants.OBJ_BLOB, bytes));

        indexBuilder.add(entry);
      }

      if (!StringUtils.isEmpty(gitignore)) {
        // insert a .gitignore file
        File dir = app().runtime().getFileOrFolder(Keys.git.gitignoreFolder, "${baseFolder}/gitignore");
        File file = new File(dir, gitignore + ".gitignore");
        if (file.exists() && file.length() > 0) {
          byte [] bytes = FileUtils.readContent(file);
          if (!ArrayUtils.isEmpty(bytes)) {
            DirCacheEntry entry = new DirCacheEntry(".gitignore");
            entry.setLength(bytes.length);
            entry.setLastModified(System.currentTimeMillis());
            entry.setFileMode(FileMode.REGULAR_FILE);
            entry.setObjectId(odi.insert(org.eclipse.jgit.lib.Constants.OBJ_BLOB, bytes));

            indexBuilder.add(entry);
          }
        }
      }

      if (addGitFlow) {
        // insert a .gitflow file
        Config config = new Config();
        config.setString("gitflow", null, "masterBranch", Constants.MASTER);
        config.setString("gitflow", null, "developBranch", Constants.DEVELOP);
        config.setString("gitflow", null, "featureBranchPrefix", "feature/");
        config.setString("gitflow", null, "releaseBranchPrefix", "release/");
        config.setString("gitflow", null, "hotfixBranchPrefix", "hotfix/");
        config.setString("gitflow", null, "supportBranchPrefix", "support/");
        config.setString("gitflow", null, "versionTagPrefix", "");

        byte [] bytes = config.toText().getBytes(Constants.ENCODING);

        DirCacheEntry entry = new DirCacheEntry(".gitflow");
        entry.setLength(bytes.length);
        entry.setLastModified(System.currentTimeMillis());
        entry.setFileMode(FileMode.REGULAR_FILE);
        entry.setObjectId(odi.insert(org.eclipse.jgit.lib.Constants.OBJ_BLOB, bytes));

        indexBuilder.add(entry);
      }

      indexBuilder.finish();

      if (newIndex.getEntryCount() == 0) {
        // nothing to commit
        return false;
      }

      ObjectId treeId = newIndex.writeTree(odi);

      // Create a commit object
      CommitBuilder commit = new CommitBuilder();
      commit.setAuthor(author);
      commit.setCommitter(author);
      commit.setEncoding(Constants.ENCODING);
      commit.setMessage("Initial commit");
      commit.setTreeId(treeId);

      // Insert the commit into the repository
      ObjectId commitId = odi.insert(commit);
      odi.flush();

      // set the branch refs
      RevWalk revWalk = new RevWalk(db);
      try {
        // set the master branch
        RevCommit revCommit = revWalk.parseCommit(commitId);
        RefUpdate masterRef = db.updateRef(Constants.R_MASTER);
        masterRef.setNewObjectId(commitId);
        masterRef.setRefLogMessage("commit: " + revCommit.getShortMessage(), false);
        Result masterRC = masterRef.update();
        switch (masterRC) {
        case NEW:
          success = true;
          break;
        default:
          success = false;
        }

        if (addGitFlow) {
          // set the develop branch for git-flow
          RefUpdate developRef = db.updateRef(Constants.R_DEVELOP);
          developRef.setNewObjectId(commitId);
          developRef.setRefLogMessage("commit: " + revCommit.getShortMessage(), false);
          Result developRC = developRef.update();
          switch (developRC) {
          case NEW:
            success = true;
            break;
          default:
            success = false;
          }
        }
      } finally {
        revWalk.release();
      }
    } catch (UnsupportedEncodingException e) {
      logger().error(null, e);
    } catch (IOException e) {
      logger().error(null, e);
    } finally {
      odi.release();
      db.close();
    }
    return success;
  }
View Full Code Here

Examples of org.eclipse.jgit.lib.ObjectInserter

    boolean success = false;
    String message = "push";

    try {
      ObjectId headId = repository.resolve(GB_REFLOG + "^{commit}");
      ObjectInserter odi = repository.newObjectInserter();
      try {
        // Create the in-memory index of the reflog log entry
        DirCache index = createIndex(repository, headId, commands);
        ObjectId indexTreeId = index.writeTree(odi);

        PersonIdent ident;
        if (UserModel.ANONYMOUS.equals(user)) {
          // anonymous push
          ident = new PersonIdent(user.username + "/" + user.username, user.username);
        } else {
          // construct real pushing account
          ident =  new PersonIdent(MessageFormat.format("{0}/{1}", user.getDisplayName(), user.username),
            user.emailAddress == null ? user.username : user.emailAddress);
        }

        // Create a commit object
        CommitBuilder commit = new CommitBuilder();
        commit.setAuthor(ident);
        commit.setCommitter(ident);
        commit.setEncoding(Constants.ENCODING);
        commit.setMessage(message);
        commit.setParentId(headId);
        commit.setTreeId(indexTreeId);

        // Insert the commit into the repository
        ObjectId commitId = odi.insert(commit);
        odi.flush();

        RevWalk revWalk = new RevWalk(repository);
        try {
          RevCommit revCommit = revWalk.parseCommit(commitId);
          RefUpdate ru = repository.updateRef(GB_REFLOG);
          ru.setNewObjectId(commitId);
          ru.setExpectedOldObjectId(headId);
          ru.setRefLogMessage("commit: " + revCommit.getShortMessage(), false);
          Result rc = ru.forceUpdate();
          switch (rc) {
          case NEW:
          case FORCED:
          case FAST_FORWARD:
            success = true;
            break;
          case REJECTED:
          case LOCK_FAILURE:
            throw new ConcurrentRefUpdateException(JGitText.get().couldNotLockHEAD,
                ru.getRef(), rc);
          default:
            throw new JGitInternalException(MessageFormat.format(
                JGitText.get().updatingRefFailed, GB_REFLOG, commitId.toString(),
                rc));
          }
        } finally {
          revWalk.release();
        }
      } finally {
        odi.release();
      }
    } catch (Throwable t) {
      error(t, repository, "Failed to commit reflog entry to {0}");
    }
    return success;
View Full Code Here

Examples of org.eclipse.jgit.lib.ObjectInserter

  private static DirCache createIndex(Repository repo, ObjectId headId,
      Collection<ReceiveCommand> commands) throws IOException {

    DirCache inCoreIndex = DirCache.newInCore();
    DirCacheBuilder dcBuilder = inCoreIndex.builder();
    ObjectInserter inserter = repo.newObjectInserter();

    long now = System.currentTimeMillis();
    Set<String> ignorePaths = new TreeSet<String>();
    try {
      // add receive commands to the temporary index
      for (ReceiveCommand command : commands) {
        // use the ref names as the path names
        String path = command.getRefName();
        ignorePaths.add(path);

        StringBuilder change = new StringBuilder();
        change.append(command.getType().name()).append(' ');
        switch (command.getType()) {
        case CREATE:
          change.append(ObjectId.zeroId().getName());
          change.append(' ');
          change.append(command.getNewId().getName());
          break;
        case UPDATE:
        case UPDATE_NONFASTFORWARD:
          change.append(command.getOldId().getName());
          change.append(' ');
          change.append(command.getNewId().getName());
          break;
        case DELETE:
          change = null;
          break;
        }
        if (change == null) {
          // ref deleted
          continue;
        }
        String content = change.toString();

        // create an index entry for this attachment
        final DirCacheEntry dcEntry = new DirCacheEntry(path);
        dcEntry.setLength(content.length());
        dcEntry.setLastModified(now);
        dcEntry.setFileMode(FileMode.REGULAR_FILE);

        // insert object
        dcEntry.setObjectId(inserter.insert(org.eclipse.jgit.lib.Constants.OBJ_BLOB, content.getBytes("UTF-8")));

        // add to temporary in-core index
        dcBuilder.add(dcEntry);
      }

      // Traverse HEAD to add all other paths
      TreeWalk treeWalk = new TreeWalk(repo);
      int hIdx = -1;
      if (headId != null)
        hIdx = treeWalk.addTree(new RevWalk(repo).parseTree(headId));
      treeWalk.setRecursive(true);

      while (treeWalk.next()) {
        String path = treeWalk.getPathString();
        CanonicalTreeParser hTree = null;
        if (hIdx != -1)
          hTree = treeWalk.getTree(hIdx, CanonicalTreeParser.class);
        if (!ignorePaths.contains(path)) {
          // add entries from HEAD for all other paths
          if (hTree != null) {
            // create a new DirCacheEntry with data retrieved from
            // HEAD
            final DirCacheEntry dcEntry = new DirCacheEntry(path);
            dcEntry.setObjectId(hTree.getEntryObjectId());
            dcEntry.setFileMode(hTree.getEntryFileMode());

            // add to temporary in-core index
            dcBuilder.add(dcEntry);
          }
        }
      }

      // release the treewalk
      treeWalk.release();

      // finish temporary in-core index used for this commit
      dcBuilder.finish();
    } finally {
      inserter.release();
    }
    return inCoreIndex;
  }
View Full Code Here

Examples of org.eclipse.jgit.lib.ObjectInserter

      createTicketsBranch(db);
    }

    DirCache newIndex = DirCache.newInCore();
    DirCacheBuilder builder = newIndex.builder();
    ObjectInserter inserter = db.newObjectInserter();

    try {
      // create an index entry for the revised index
      final DirCacheEntry idIndexEntry = new DirCacheEntry(file);
      idIndexEntry.setLength(content.length());
      idIndexEntry.setLastModified(System.currentTimeMillis());
      idIndexEntry.setFileMode(FileMode.REGULAR_FILE);

      // insert new ticket index
      idIndexEntry.setObjectId(inserter.insert(org.eclipse.jgit.lib.Constants.OBJ_BLOB,
          content.getBytes(Constants.ENCODING)));

      // add to temporary in-core index
      builder.add(idIndexEntry);

      Set<String> ignorePaths = new HashSet<String>();
      ignorePaths.add(file);

      for (DirCacheEntry entry : getTreeEntries(db, ignorePaths)) {
        builder.add(entry);
      }

      // finish temporary in-core index used for this commit
      builder.finish();

      // commit the change
      commitIndex(db, newIndex, createdBy, msg);

    } catch (ConcurrentRefUpdateException e) {
      log.error("", e);
    } catch (IOException e) {
      log.error("", e);
    } finally {
      inserter.release();
    }
  }
View Full Code Here

Examples of org.eclipse.jgit.lib.ObjectInserter

      throws IOException, ClassNotFoundException, NoSuchFieldException {

    String ticketPath = toTicketPath(ticketId);
    DirCache newIndex = DirCache.newInCore();
    DirCacheBuilder builder = newIndex.builder();
    ObjectInserter inserter = db.newObjectInserter();

    Set<String> ignorePaths = new TreeSet<String>();
    try {
      // create/update the journal
      // exclude the attachment content
      List<Change> changes = getJournal(db, ticketId);
      changes.add(change);
      String journal = TicketSerializer.serializeJournal(changes).trim();

      byte [] journalBytes = journal.getBytes(Constants.ENCODING);
      String journalPath = ticketPath + "/" + JOURNAL;
      final DirCacheEntry journalEntry = new DirCacheEntry(journalPath);
      journalEntry.setLength(journalBytes.length);
      journalEntry.setLastModified(change.date.getTime());
      journalEntry.setFileMode(FileMode.REGULAR_FILE);
      journalEntry.setObjectId(inserter.insert(org.eclipse.jgit.lib.Constants.OBJ_BLOB, journalBytes));

      // add journal to index
      builder.add(journalEntry);
      ignorePaths.add(journalEntry.getPathString());

      // Add any attachments to the index
      if (change.hasAttachments()) {
        for (Attachment attachment : change.attachments) {
          // build a path name for the attachment and mark as ignored
          String path = toAttachmentPath(ticketId, attachment.name);
          ignorePaths.add(path);

          // create an index entry for this attachment
          final DirCacheEntry entry = new DirCacheEntry(path);
          entry.setLength(attachment.content.length);
          entry.setLastModified(change.date.getTime());
          entry.setFileMode(FileMode.REGULAR_FILE);

          // insert object
          entry.setObjectId(inserter.insert(org.eclipse.jgit.lib.Constants.OBJ_BLOB, attachment.content));

          // add to temporary in-core index
          builder.add(entry);
        }
      }

      for (DirCacheEntry entry : getTreeEntries(db, ignorePaths)) {
        builder.add(entry);
      }

      // finish the index
      builder.finish();
    } finally {
      inserter.release();
    }
    return newIndex;
  }
View Full Code Here

Examples of org.eclipse.jgit.lib.ObjectInserter

    if (headId == null) {
      // create the branch
      createTicketsBranch(db);
      headId = db.resolve(BRANCH + "^{commit}");
    }
    ObjectInserter odi = db.newObjectInserter();
    try {
      // Create the in-memory index of the new/updated ticket
      ObjectId indexTreeId = index.writeTree(odi);

      // Create a commit object
      PersonIdent ident = new PersonIdent(author, "gitblit@localhost");
      CommitBuilder commit = new CommitBuilder();
      commit.setAuthor(ident);
      commit.setCommitter(ident);
      commit.setEncoding(Constants.ENCODING);
      commit.setMessage(message);
      commit.setParentId(headId);
      commit.setTreeId(indexTreeId);

      // Insert the commit into the repository
      ObjectId commitId = odi.insert(commit);
      odi.flush();

      RevWalk revWalk = new RevWalk(db);
      try {
        RevCommit revCommit = revWalk.parseCommit(commitId);
        RefUpdate ru = db.updateRef(BRANCH);
        ru.setNewObjectId(commitId);
        ru.setExpectedOldObjectId(headId);
        ru.setRefLogMessage("commit: " + revCommit.getShortMessage(), false);
        Result rc = ru.forceUpdate();
        switch (rc) {
        case NEW:
        case FORCED:
        case FAST_FORWARD:
          success = true;
          break;
        case REJECTED:
        case LOCK_FAILURE:
          throw new ConcurrentRefUpdateException(JGitText.get().couldNotLockHEAD,
              ru.getRef(), rc);
        default:
          throw new JGitInternalException(MessageFormat.format(
              JGitText.get().updatingRefFailed, BRANCH, commitId.toString(),
              rc));
        }
      } finally {
        revWalk.release();
      }
    } finally {
      odi.release();
    }
    return success;
  }
View Full Code Here

Examples of org.eclipse.jgit.lib.ObjectInserter

      builder = null;

      if (hasConflict)
        return false;
      try {
        ObjectInserter odi = getObjectInserter();
        resultTree = cache.writeTree(odi);
        odi.flush();
        return true;
      } catch (UnmergedPathException upe) {
        resultTree = null;
        return false;
      }
View Full Code Here
TOP
Copyright © 2018 www.massapi.com. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.