Java ViewFacet类代码示例

import org.sonatype.nexus.repository.view.ViewFacet; //导入依赖的package包/类
private ViewFacet configure(final ConfigurableViewFacet facet) {
  Router.Builder builder = new Router.Builder();

  builder.route(new Route.Builder().matcher(new AlwaysMatcher())
      .handler(timingHandler)
      .handler(securityHandler)
      .handler(exceptionHandler)
      .handler(negativeCacheHandler)
      .handler(conditionalRequestHandler)
      .handler(partialFetchHandler)
      .handler(contentHeadersHandler)
      .handler(unitOfWorkHandler)
      .handler(snapshotHandler)
      .handler(proxyHandler).create());

  builder.defaultHandlers(notFound());
  facet.configure(builder.create());
  return facet;
}
 

import org.sonatype.nexus.repository.view.ViewFacet; //导入依赖的package包/类
private ViewFacet configure(final ConfigurableViewFacet facet) {
  Router.Builder builder = new Router.Builder();

  builder.route(new Route.Builder().matcher(new AlwaysMatcher())
      .handler(timingHandler)
      .handler(securityHandler)
      .handler(exceptionHandler)
      .handler(conditionalRequestHandler)
      .handler(partialFetchHandler)
      .handler(contentHeadersHandler)
      .handler(unitOfWorkHandler)
      .handler(snapshotHandler)
      .handler(signingHandler)
      .handler(hostedHandler).create());

  builder.defaultHandlers(notFound());
  facet.configure(builder.create());
  return facet;
}
 

import org.sonatype.nexus.repository.view.ViewFacet; //导入依赖的package包/类
protected void doService(final HttpServletRequest httpRequest, final HttpServletResponse httpResponse)
    throws Exception
{
  // resolve repository for request
  RepositoryPath path = RepositoryPath.parse(httpRequest.getPathInfo());
  log.debug("Parsed path: {}", path);

  Repository repo = repository(path.getRepositoryName());
  if (repo == null) {
    send(null, HttpResponses.notFound(REPOSITORY_NOT_FOUND_MESSAGE), httpResponse);
    return;
  }
  log.debug("Repository: {}", repo);

  if (!repo.getConfiguration().isOnline()) {
    send(null, HttpResponses.serviceUnavailable("Repository offline"), httpResponse);
    return;
  }

  ViewFacet facet = repo.facet(ViewFacet.class);
  log.debug("Dispatching to view facet: {}", facet);

  // Dispatch the request
  Request request = buildRequest(httpRequest, path.getRemainingPath());
  dispatchAndSend(request, facet, httpResponseSenderSelector.sender(repo), httpResponse);
}
 

import org.sonatype.nexus.repository.view.ViewFacet; //导入依赖的package包/类
/**
 * Construct a new repository from configuration.
 */
private Repository newRepository(final Configuration configuration) throws Exception {
  String recipeName = configuration.getRecipeName();
  Recipe recipe = recipe(recipeName);
  log.debug("Using recipe: [{}] {}", recipeName, recipe);

  Repository repository = factory.create(recipe.getType(), recipe.getFormat());

  // attach mandatory facets
  repository.attach(configFacet.get());

  // apply recipe to repository
  recipe.apply(repository);

  // verify required facets
  repository.facet(ViewFacet.class);

  // ensure configuration sanity, once all facets are attached
  repository.validate(configuration);

  // initialize repository
  repository.init(configuration);

  return repository;
}
 

import org.sonatype.nexus.repository.view.ViewFacet; //导入依赖的package包/类
/**
 * Returns the first OK response from member repositories or {@link HttpResponses#notFound()} if none of the members
 * responded with OK.
 */
protected Response getFirst(@Nonnull final Context context,
                            @Nonnull final List<Repository> members,
                            @Nonnull final DispatchedRepositories dispatched)
    throws Exception
{
  final Request request = context.getRequest();
  for (Repository member : members) {
    log.trace("Trying member: {}", member);
    // track repositories we have dispatched to, prevent circular dispatch for nested groups
    if (dispatched.contains(member)) {
      log.trace("Skipping already dispatched member: {}", member);
      continue;
    }
    dispatched.add(member);

    final ViewFacet view = member.facet(ViewFacet.class);
    final Response response = view.dispatch(request, context);
    log.trace("Member {} response {}", member, response.getStatus());
    if (response.getStatus().isSuccessful()) {
      return response;
    }
  }
  return notFoundResponse(context);
}
 

import org.sonatype.nexus.repository.view.ViewFacet; //导入依赖的package包/类
/**
 * Returns all responses from all members as a linked map, where order is group member order.
 */
protected LinkedHashMap<Repository, Response> getAll(@Nonnull final Context context,
                                                     @Nonnull final Iterable<Repository> members,
                                                     @Nonnull final DispatchedRepositories dispatched)
    throws Exception
{
  final Request request = context.getRequest();
  final LinkedHashMap<Repository, Response> responses = Maps.newLinkedHashMap();
  for (Repository member : members) {
    log.trace("Trying member: {}", member);
    // track repositories we have dispatched to, prevent circular dispatch for nested groups
    if (dispatched.contains(member)) {
      log.trace("Skipping already dispatched member: {}", member);
      continue;
    }
    dispatched.add(member);

    final ViewFacet view = member.facet(ViewFacet.class);
    final Response response = view.dispatch(request, context);
    log.trace("Member {} response {}", member, response.getStatus());

    responses.put(member, response);
  }
  return responses;
}
 

import org.sonatype.nexus.repository.view.ViewFacet; //导入依赖的package包/类
private void setupRepository(final Repository repository) throws Exception {
  ViewFacet viewFacet = mock(ViewFacet.class);
  Response response = mock(Response.class);
  Payload payload = mock(Payload.class);
  GroupFacet groupFacet = mock(GroupFacet.class);
  when(groupFacet.members()).thenReturn(members);
  when(repository.facet(GroupFacet.class)).thenReturn(groupFacet);
  when(repository.facet(ViewFacet.class)).thenReturn(viewFacet);
  when(viewFacet.dispatch(any(), any())).thenReturn(response);
  when(response.getPayload()).thenReturn(payload);
  when(payload.openInputStream()).thenReturn(new FileInputStream(packages));
  when(response.getStatus()).thenReturn(new Status(true, 200));
}
 

import org.sonatype.nexus.repository.view.ViewFacet; //导入依赖的package包/类
@VisibleForTesting
void dispatchAndSend(final Request request,
                     final ViewFacet facet,
                     final HttpResponseSender sender,
                     final HttpServletResponse httpResponse)
    throws Exception
{
  Response response = null;
  Exception failure = null;
  try {
    response = facet.dispatch(request);
  }
  catch (Exception e) {
    failure = e;
  }

  String describeFlags = request.getParameters().get(P_DESCRIBE);
  log.trace("Describe flags: {}", describeFlags);
  if (describeFlags != null) {
    send(request, describe(request, response, failure, describeFlags), httpResponse);
  }
  else {
    if (failure != null) {
      throw failure;
    }
    log.debug("Request: {}", request);
    sender.send(request, response, httpResponse);
  }
}
 

import org.sonatype.nexus.repository.view.ViewFacet; //导入依赖的package包/类
private void mockRepository() {
  when(repositoryManager.get(REPOSITORY_NAME)).thenReturn(repository);
  when(repository.getConfiguration()).thenReturn(configuration);
  when(repository.facet(ViewFacet.class)).thenReturn(viewFacet);
  when(repository.getFormat()).thenReturn(new Format("maven") { });
  when(configuration.isOnline()).thenReturn(true);
}
 

import org.sonatype.nexus.repository.view.ViewFacet; //导入依赖的package包/类
private Response forward(final Context context, final String path) throws Exception {
  log.trace("Forwarding request to path: {}", path);

  Request request = new Request.Builder()
      .copy(context.getRequest())
      .path(path)
      .build();

  return context.getRepository()
      .facet(ViewFacet.class)
      .dispatch(request);
}