Examples of org.eclipse.jgit.lib.Repository

org.eclipse.jgit.lib.Repository
Represents a Git repository.
A repository holds all objects and refs used for managing source code (could be any type of file, but source code is what SCM's are typically used for).
This class is thread-safe.

    }


    @Override
    public ProjectState load(String projectName) throws Exception {
      Project.NameKey key = new Project.NameKey(projectName);
      Repository git = mgr.openRepository(key);
      try {
        ProjectConfig cfg = new ProjectConfig(key);
        cfg.load(git);
        return projectStateFactory.create(cfg);
      } finally {
        git.close();
      }
    }

View Full Code Here

    final PatchSet patch = db.patchSets().get(patchSetId);
    if (patch == null) {
      throw new NoSuchChangeException(changeId);
    }


    final Repository git;
    try {
      git = gitManager.openRepository(db.changes().get(changeId).getProject());
    } catch (RepositoryNotFoundException e) {
      throw new NoSuchChangeException(changeId, e);
    };


    final RevWalk revWalk = new RevWalk(git);
    try {
      RevCommit commitToRevert =
          revWalk.parseCommit(ObjectId.fromString(patch.getRevision().get()));


      PersonIdent authorIdent =
          user.newCommitterIdent(myIdent.getWhen(), myIdent.getTimeZone());


      RevCommit parentToCommitToRevert = commitToRevert.getParent(0);
      revWalk.parseHeaders(parentToCommitToRevert);


      CommitBuilder revertCommit = new CommitBuilder();
      revertCommit.addParentId(commitToRevert);
      revertCommit.setTreeId(parentToCommitToRevert.getTree());
      revertCommit.setAuthor(authorIdent);
      revertCommit.setCommitter(myIdent);
      revertCommit.setMessage(message);


      final ObjectInserter oi = git.newObjectInserter();;
      ObjectId id;
      try {
        id = oi.insert(revertCommit);
        oi.flush();
      } finally {
        oi.release();
      }


      Change.Key changeKey = new Change.Key("I" + id.name());
      final Change change =
          new Change(changeKey, new Change.Id(db.nextChangeId()),
              user.getAccountId(), db.changes().get(changeId).getDest());
      change.nextPatchSetId();


      final PatchSet ps = new PatchSet(change.currPatchSetId());
      ps.setCreatedOn(change.getCreatedOn());
      ps.setUploader(user.getAccountId());
      ps.setRevision(new RevId(id.getName()));


      db.patchSets().insert(Collections.singleton(ps));


      final PatchSetInfo info =
          patchSetInfoFactory.get(revWalk.parseCommit(id), ps.getId());
      change.setCurrentPatchSet(info);
      ChangeUtil.updated(change);
      db.changes().insert(Collections.singleton(change));


      final RefUpdate ru = git.updateRef(ps.getRefName());
      ru.setNewObjectId(id);
      ru.disableRefLog();
      if (ru.update(revWalk) != RefUpdate.Result.NEW) {
        throw new IOException("Failed to create ref " + ps.getRefName()
            + " in " + git.getDirectory() + ": " + ru.getResult());
      }
      replication.fire(db.changes().get(changeId).getProject(),
          ru.getName());


      final ChangeMessage cmsg =
          new ChangeMessage(new ChangeMessage.Key(changeId,
              ChangeUtil.messageUUID(db)), user.getAccountId(), patchSetId);
      final StringBuilder msgBuf =
          new StringBuilder("Patch Set " + patchSetId.get() + ": Reverted");
      msgBuf.append("\n\n");
      msgBuf.append("This patchset was reverted in change: " + changeKey.get());


      cmsg.setMessage(msgBuf.toString());
      db.changeMessages().insert(Collections.singleton(cmsg));


      final RevertedSender cm = revertedSenderFactory.create(change);
      cm.setFrom(user.getAccountId());
      cm.setChangeMessage(cmsg);
      cm.send();


      hooks.doPatchsetCreatedHook(change, ps, db);


      return change.getId();
    } finally {
      revWalk.release();
      git.close();
    }
  }

View Full Code Here

    final PatchSet.Id patchSetId = patch.getId();
    if (patch == null || !patch.isDraft()) {
      throw new NoSuchChangeException(patchSetId.getParentKey());
    }


    Repository repo = gitManager.openRepository(change.getProject());
    try {
      RefUpdate update = repo.updateRef(patch.getRefName());
      update.setForceUpdate(true);
      update.disableRefLog();
      switch (update.delete()) {
        case NEW:
        case FAST_FORWARD:
        case FORCED:
        case NO_CHANGE:
          // Successful deletion.
          break;
        default:
          throw new IOException("Failed to delete ref " + patch.getRefName() +
              " in " + repo.getDirectory() + ": " + update.getResult());
      }
      replication.fire(change.getProject(), update.getName());
    } finally {
      repo.close();
    }


    db.accountPatchReviews().delete(db.accountPatchReviews().byPatchSet(patchSetId));
    db.changeMessages().delete(db.changeMessages().byPatchSet(patchSetId));
    db.patchComments().delete(db.patchComments().byPatchSet(patchSetId));

View Full Code Here

  }


  public String getInlineComments(int lines) {
    StringBuilder  cmts = new StringBuilder();


    final Repository repo = getRepository();
    try {
      PatchList patchList = null;
      if (repo != null) {
        try {
          patchList = getPatchList();
        } catch (PatchListNotAvailableException e) {
          patchList = null;
        }
      }


      Patch.Key currentFileKey = null;
      PatchFile currentFileData = null;
      for (final PatchLineComment c : inlineComments) {
        final Patch.Key pk = c.getKey().getParentKey();
        final int lineNbr = c.getLine();
        final short side = c.getSide();


        if (!pk.equals(currentFileKey)) {
          cmts.append("....................................................\n");
          if (Patch.COMMIT_MSG.equals(pk.get())) {
            cmts.append("Commit Message\n");
          } else {
            cmts.append("File ");
            cmts.append(pk.get());
            cmts.append("\n");
          }
          currentFileKey = pk;


          if (patchList != null) {
            try {
              currentFileData =
                  new PatchFile(repo, patchList, pk.getFileName());
            } catch (IOException e) {
              // Don't quote the line if we can't load it.
            }
          } else {
            currentFileData = null;
          }
        }


        if (currentFileData != null) {
          int maxLines;
          try {
            maxLines = currentFileData.getLineCount(side);
          } catch (Throwable e) {
            maxLines = lineNbr;
          }


          final int startLine = Math.max(1, lineNbr - lines + 1);
          final int stopLine = Math.min(maxLines, lineNbr + lines);


          for (int line = startLine; line <= lineNbr; ++line) {
            appendFileLine(cmts, currentFileData, side, line);
          }


          cmts.append(c.getMessage().trim());
          cmts.append("\n");


          for (int line = lineNbr + 1; line < stopLine; ++line) {
            appendFileLine(cmts, currentFileData, side, line);
          }
        }


        cmts.append("\n\n");
      }
    } finally {
      if (repo != null) {
        repo.close();
      }
    }
    return cmts.toString();
  }

View Full Code Here


    toResolve.removeAll(resolveToUpdate);


    // Update project.config group references to use the new LDAP GroupReference
    for (Project.NameKey name : mgr.list()) {
      Repository git;
      try {
        git = mgr.openRepository(name);
      } catch (RepositoryNotFoundException e) {
        throw new OrmException(e);
      } catch (IOException e) {
        throw new OrmException(e);
      }


      try {
        MetaDataUpdate md =
            new MetaDataUpdate(GitReferenceUpdated.DISABLED, name, git);
        md.getCommitBuilder().setAuthor(serverUser);
        md.getCommitBuilder().setCommitter(serverUser);


        ProjectConfig config = ProjectConfig.read(md);


        // Update the existing refences to the new reference.
        boolean updated = false;
        for (Map.Entry<AccountGroup.UUID, GroupReference> entry: ldapUUIDMap.entrySet()) {
          GroupReference ref = config.getGroup(entry.getKey());
          if (ref != null) {
            updated = true;
            ref.setName(entry.getValue().getName());
            ref.setUUID(entry.getValue().getUUID());
            config.resolve(ref);
          }
        }


        // Determine if a toResolve group is used and should be made INTERNAL.
        Iterator<AccountGroup.UUID> iter = toResolve.iterator();
        while (iter.hasNext()) {
          AccountGroup.UUID uuid = iter.next();
          if (config.getGroup(uuid) != null) {
            resolveToUpdate.add(uuid);
            iter.remove();
          }
        }


        if (!updated) {
          continue;
        }


        md.setMessage("Switch LDAP group UUIDs to DNs\n");
        config.commit(md);
      } catch (IOException e) {
        throw new OrmException(e);
      } catch (ConfigInvalidException e) {
        throw new OrmException(e);
      } finally {
        git.close();
      }
    }


    for (AccountGroup.UUID uuid : resolveToUpdate) {
      AccountGroup group = resolveGroups.get(uuid);

View Full Code Here

      this.args = args;
    }


    @Override
    public void run() {
      Repository repo = null;
      try {
        final List<String> argv = new ArrayList<String>(1 + args.size());
        argv.add(hook.getAbsolutePath());
        argv.addAll(args);


        final ProcessBuilder pb = new ProcessBuilder(argv);
        pb.redirectErrorStream(true);


        if (project != null) {
          repo = openRepository(project);
        }


        final Map<String, String> env = pb.environment();
        env.put("GERRIT_SITE", sitePaths.site_path.getAbsolutePath());


        if (repo != null) {
          pb.directory(repo.getDirectory());


          env.put("GIT_DIR", repo.getDirectory().getAbsolutePath());
        }


        Process ps = pb.start();
        ps.getOutputStream().close();


        BufferedReader br =
            new BufferedReader(new InputStreamReader(ps.getInputStream()));
        try {
          String line;
          while ((line = br.readLine()) != null) {
            log.info("hook[" + hook.getName() + "] output: " + line);
          }
        } finally {
          try {
            br.close();
          } catch (IOException closeErr) {
          }
          ps.waitFor();
        }
      } catch (Throwable err) {
        log.error("Error running hook " + hook.getAbsolutePath(), err);
      } finally {
        if (repo != null) {
          repo.close();
        }
      }
    }

View Full Code Here

    private static ESLogger logger = Loggers.getLogger(FetchOrCloneRepositoryPredicate.class);


    @Override
    public boolean apply(Context context) {
        try {
            final Repository repository = new FileRepositoryBuilder()
                .setGitDir(context.getProjectPath())
                .readEnvironment()
                .findGitDir()
                .setMustExist(false)
                .build();


            return repository.getObjectDatabase().exists();
        } catch(Throwable e) {
            logger.error(this.getClass().getName(), e);
            throw new RuntimeException(e);
        }
    }

View Full Code Here

                .setCloneAllBranches(true)
                .setDirectory(context.getProjectPath())
                .setURI(context.getUri())
                .setProgressMonitor(new LoggingProgressMonitor(logger))
                .call();
            Repository repository = git.getRepository();
            context.setRepository(repository);


            Collection<Ref> refs = repository.getRefDatabase().getRefs(R_HEADS).values();
            context.setRefs(refs);
            logger.info("Found {} refs to process.", refs.size());
        } catch(Throwable e) {
            logger.error(this.getClass().getName(), e);
        }

View Full Code Here

    private static ESLogger logger = Loggers.getLogger(FetchRepositoryFunction.class);


    @Override
    public Context apply(Context context) {
        try {
            final Repository repository = new FileRepositoryBuilder()
                .setGitDir(context.getProjectPath())
                .readEnvironment() // scan environment GIT_* variables
                .findGitDir()
                .setMustExist(true)
                .build();
            context.setRepository(repository);


            logger.info("Fetching '{}' repository at path: '{}'", context.getName(), context.getProjectPath());


            Git git = new Git(repository);


            FetchResult fetchResult = git.fetch()
                .setProgressMonitor(new LoggingProgressMonitor(logger))
                .call();




            Collection<Ref> refs = FluentIterable
                .from(fetchResult.getTrackingRefUpdates())
                .filter(Predicates.not(new Predicate<TrackingRefUpdate>() {
                    @Override
                    public boolean apply(TrackingRefUpdate input) {
                        return NO_CHANGE.equals(input.getResult());
                    }
                }))
                .transform(new Function<TrackingRefUpdate, Ref>() {
                    @Override
                    public Ref apply(TrackingRefUpdate input) {
                        try {
                            return repository.getRef(input.getLocalName());
                        } catch(Throwable e) {
                            logger.error(this.getClass().getName(), e);
                            return null;
                        }
                    }

View Full Code Here

      if (RepositoryCache.FileKey.isGitRepository(dir, FS.DETECTED))
        rb.setGitDir(dir);
      else
        rb.findGitDir(dir);


      Repository db = rb.build();
      try {
        run(db);
      } finally {
        db.close();
      }
    }
  }

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.eclipse.jgit.lib.Repository

com.gitblit.manager.RepositoryManager

com.gitblit.servlet.BranchGraphServlet

com.gitblit.tests.DiffUtilsTest

com.gitblit.tests.JGitUtilsTest

com.gitblit.tests.JnaUtilsTest

com.gitblit.tests.LuceneExecutorTest

com.gitblit.tests.RepositoryModelTest

com.gitblit.tickets.BranchTicketService

com.gitblit.tickets.FileTicketService

com.gitblit.tickets.ITicketService

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.