Java ReceivePack类代码示例

import org.eclipse.jgit.transport.ReceivePack; //导入依赖的package包/类
@Override
public void init(Project.NameKey project, ReceivePack rp) {
  ProjectState ps = projectCache.get(project);
  if (!ps.isEnableSignedPush()) {
    rp.setSignedPushConfig(null);
    return;
  } else if (signedPushConfig == null) {
    log.error(
        "receive.enableSignedPush is true for project {} but"
            + " false in gerrit.config, so signed push verification is"
            + " disabled",
        project.get());
    rp.setSignedPushConfig(null);
    return;
  }
  rp.setSignedPushConfig(signedPushConfig);

  List<PreReceiveHook> hooks = new ArrayList<>(3);
  if (ps.isRequireSignedPush()) {
    hooks.add(SignedPushPreReceiveHook.Required.INSTANCE);
  }
  hooks.add(hook);
  hooks.add(rp.getPreReceiveHook());
  rp.setPreReceiveHook(PreReceiveHookChain.newChain(hooks));
}
 

import org.eclipse.jgit.transport.ReceivePack; //导入依赖的package包/类
@Override
public ReceivePack create(HttpServletRequest req, Repository db)
    throws ServiceNotAuthorizedException {
  final ProjectState state = (ProjectState) req.getAttribute(ATT_STATE);

  if (!(userProvider.get().isIdentifiedUser())) {
    // Anonymous users are not permitted to push.
    throw new ServiceNotAuthorizedException();
  }

  AsyncReceiveCommits arc =
      factory.create(
          state, userProvider.get().asIdentifiedUser(), db, null, ImmutableSetMultimap.of());
  ReceivePack rp = arc.getReceivePack();
  req.setAttribute(ATT_ARC, arc);
  return rp;
}
 

import org.eclipse.jgit.transport.ReceivePack; //导入依赖的package包/类
@Override
public void onPreReceive(ReceivePack rp, Collection<ReceiveCommand> commands) {
  Worker w = new Worker(commands);
  try {
    w.progress.waitFor(
        executor.submit(scopePropagator.wrap(w)), timeoutMillis, TimeUnit.MILLISECONDS);
  } catch (ExecutionException e) {
    log.warn(
        String.format(
            "Error in ReceiveCommits while processing changes for project %s",
            projectState.getName()),
        e);
    rp.sendError("internal error while processing changes");
    // ReceiveCommits has tried its best to catch errors, so anything at this
    // point is very bad.
    for (ReceiveCommand c : commands) {
      if (c.getResult() == Result.NOT_ATTEMPTED) {
        c.setResult(Result.REJECTED_OTHER_REASON, "internal error");
      }
    }
  } finally {
    w.sendMessages();
  }
}
 

import org.eclipse.jgit.transport.ReceivePack; //导入依赖的package包/类
@Override
protected void execute(final FileSystemUser user,
                       final Repository repository,
                       final InputStream in,
                       final OutputStream out,
                       final OutputStream err,
                       final JGitFileSystem fileSystem) {
    try {
        final ReceivePack rp = receivePackFactory.create(this,
                                                         repository);
        rp.receive(in,
                   out,
                   err);
        rp.setPostReceiveHook((rp1, commands) -> {
            fileSystem.getGit().gc();
            fileSystem.resetCommitCount();
        });
    } catch (final Exception ignored) {
    }
}
 

import org.eclipse.jgit.transport.ReceivePack; //导入依赖的package包/类
/**
 * Puts a {@link WriteLatexPutHook} into the returned {@link ReceivePack}.
 *
 * The {@link WriteLatexPutHook} needs our hostname, which we get from the
 * original {@link HttpServletRequest}, used to provide a postback URL to
 * the {@link SnapshotApi}. We also give it the oauth2 that we injected in
 * the {@link Oauth2Filter}, and the {@link Bridge}.
 *
 * At this point, the repository will have been synced to the latest on
 * Overleaf, but it's possible that an update happens on Overleaf while our
 * put hook is running. In this case, we fail, and the user tries again,
 * triggering another sync, and so on.
 * @param httpServletRequest the original request
 * @param repository the JGit {@link Repository} provided by
 * {@link WLRepositoryResolver}
 * @return a correctly hooked {@link ReceivePack}
 */
@Override
public ReceivePack create(
        HttpServletRequest httpServletRequest,
        Repository repository
) {
    Log.info(
            "[{}] Creating receive-pack",
            repository.getWorkTree().getName()
    );
    Optional<Credential> oauth2 = Optional.ofNullable(
            (Credential) httpServletRequest.getAttribute(
                    Oauth2Filter.ATTRIBUTE_KEY));
    ReceivePack receivePack = new ReceivePack(repository);
    String hostname = Util.getPostbackURL();
    if (hostname == null) {
        hostname = httpServletRequest.getLocalName();
    }
    receivePack.setPreReceiveHook(
            new WriteLatexPutHook(repoStore, bridge, hostname, oauth2)
    );
    return receivePack;
}
 

import org.eclipse.jgit.transport.ReceivePack; //导入依赖的package包/类
private void handleSnapshotPostException(
        ReceivePack receivePack,
        ReceiveCommand receiveCommand,
        GitUserException e
) {
    String message = e.getMessage();
    receivePack.sendError(message);
    StringBuilder msg = new StringBuilder();
    for (
            Iterator<String> it = e.getDescriptionLines().iterator();
            it.hasNext();
    ) {
        String line = it.next();
        msg.append("hint: ");
        msg.append(line);
        if (it.hasNext()) {
            msg.append('\n');
        }
    }
    receivePack.sendMessage("");
    receivePack.sendMessage(msg.toString());
    receiveCommand.setResult(Result.REJECTED_OTHER_REASON, message);
}
 

import org.eclipse.jgit.transport.ReceivePack; //导入依赖的package包/类
@Override
public void onPreReceive(ReceivePack rp, Collection<ReceiveCommand> commands) {
  if (rp.getPushCertificate() == null) {
    rp.sendMessage("ERROR: Signed push is required");
    reject(commands, "push cert error");
  }
}
 

import org.eclipse.jgit.transport.ReceivePack; //导入依赖的package包/类
@Override
public ReceivePack create(HttpServletRequest req, Repository db) throws ServiceNotEnabledException, ServiceNotAuthorizedException {
  ReceivePack receivePack = new ReceivePack(db);

  GwReceiveHook hook = new GwReceiveHook(parsePK(req).get());
  GuiceListener.get().injectMembers(hook);
  receivePack.setPreReceiveHook(hook);
  receivePack.setPostReceiveHook(hook);
  return receivePack;
}
 

import org.eclipse.jgit.transport.ReceivePack; //导入依赖的package包/类
@Override
public void onPreReceive(ReceivePack rp, Collection<ReceiveCommand> commands) {
  commandsForBranch = commands.stream()
      .filter(this::isBranch)
      .map(Command::new)
      .collect(Collectors.toList());
  commandsForTag = commands.stream()
      .filter(this::isTag)
      .map(Command::new)
      .collect(Collectors.toList());
}
 

import org.eclipse.jgit.transport.ReceivePack; //导入依赖的package包/类
@Override
public void onPostReceive(ReceivePack rp, Collection<ReceiveCommand> commands) {
  service.onPost(repositoryPK, Lists.transform(commandsForBranch, command -> command.getRefName().substring(Constants.R_HEADS.length())));

  commandsForTag.forEach(command -> {
    // String tagName = command.getRefName().substring(Constants.R_TAGS.length());

    });
}
 

import org.eclipse.jgit.transport.ReceivePack; //导入依赖的package包/类
@Override
protected int runGitCommand() {
	ReceivePack receivePack = new ReceivePack(gitRepository);
	receivePack.setPreReceiveHook(hook);
	receivePack.setPostReceiveHook(hook);
	receivePack.setRefLogIdent(new PersonIdent(username, username + "@"
			+ remoteHost));
	try {
		receivePack.receive(getInputStream(), getOutputStream(),
				getErrorStream());
	} catch (IOException e) {
		return -4;
	}
	return 0;
}
 

import org.eclipse.jgit.transport.ReceivePack; //导入依赖的package包/类
@Inject
AsyncReceiveCommits(
    ReceiveCommits.Factory factory,
    PermissionBackend permissionBackend,
    VisibleRefFilter.Factory refFilterFactory,
    Provider<InternalChangeQuery> queryProvider,
    @ReceiveCommitsExecutor ExecutorService executor,
    RequestScopePropagator scopePropagator,
    ReceiveConfig receiveConfig,
    TransferConfig transferConfig,
    Provider<LazyPostReceiveHookChain> lazyPostReceive,
    ContributorAgreementsChecker contributorAgreements,
    @Named(TIMEOUT_NAME) long timeoutMillis,
    @Assisted ProjectState projectState,
    @Assisted IdentifiedUser user,
    @Assisted Repository repo,
    @Assisted @Nullable MessageSender messageSender,
    @Assisted SetMultimap<ReviewerStateInternal, Account.Id> extraReviewers)
    throws PermissionBackendException {
  this.factory = factory;
  this.executor = executor;
  this.scopePropagator = scopePropagator;
  this.receiveConfig = receiveConfig;
  this.contributorAgreements = contributorAgreements;
  this.timeoutMillis = timeoutMillis;
  this.projectState = projectState;
  this.user = user;
  this.repo = repo;
  this.messageSender = messageSender;
  this.extraReviewers = extraReviewers;

  Project.NameKey projectName = projectState.getNameKey();
  rp = new ReceivePack(repo);
  rp.setAllowCreates(true);
  rp.setAllowDeletes(true);
  rp.setAllowNonFastForwards(true);
  rp.setRefLogIdent(user.newRefLogIdent());
  rp.setTimeout(transferConfig.getTimeout());
  rp.setMaxObjectSizeLimit(transferConfig.getEffectiveMaxObjectSizeLimit(projectState));
  rp.setCheckReceivedObjects(projectState.getConfig().getCheckReceivedObjects());
  rp.setRefFilter(new ReceiveRefFilter());
  rp.setAllowPushOptions(true);
  rp.setPreReceiveHook(this);
  rp.setPostReceiveHook(lazyPostReceive.get());

  // If the user lacks READ permission, some references may be filtered and hidden from view.
  // Check objects mentioned inside the incoming pack file are reachable from visible refs.
  this.perm = permissionBackend.user(user).project(projectName);
  try {
    this.perm.check(ProjectPermission.READ);
  } catch (AuthException e) {
    rp.setCheckReferencedObjectsAreReachable(receiveConfig.checkReferencedObjectsAreReachable);
  }

  List<AdvertiseRefsHook> advHooks = new ArrayList<>(4);
  allRefsWatcher = new AllRefsWatcher();
  advHooks.add(allRefsWatcher);
  advHooks.add(refFilterFactory.create(projectState, repo).setShowMetadata(false));
  advHooks.add(new ReceiveCommitsAdvertiseRefsHook(queryProvider, projectName));
  advHooks.add(new HackPushNegotiateHook());
  rp.setAdvertiseRefsHook(AdvertiseRefsHookChain.newChain(advHooks));
}
 

import org.eclipse.jgit.transport.ReceivePack; //导入依赖的package包/类
public ReceivePack getReceivePack() {
  return rp;
}
 

import org.eclipse.jgit.transport.ReceivePack; //导入依赖的package包/类
@Override
public void onPostReceive(ReceivePack rp, Collection<ReceiveCommand> commands) {
  for (PostReceiveHook h : hooks) {
    h.onPostReceive(rp, commands);
  }
}
 

import org.eclipse.jgit.transport.ReceivePack; //导入依赖的package包/类
ReceiveCommits create(
ProjectState projectState,
IdentifiedUser user,
ReceivePack receivePack,
AllRefsWatcher allRefsWatcher,
SetMultimap<ReviewerStateInternal, Account.Id> extraReviewers);