Пример #1
0
  /**
   * Detaches the target from this router. All routes routing to this target Restlet are removed
   * from the list of routes and the default route is set to null.
   *
   * @param targetClass The target class to detach.
   */
  public void detach(Class<?> targetClass) {
    for (int i = getRoutes().size() - 1; i >= 0; i--) {
      Restlet target = getRoutes().get(i).getNext();

      if (target != null && Finder.class.isAssignableFrom(target.getClass())) {
        Finder finder = (Finder) target;

        if (finder.getTargetClass().equals(targetClass)) {
          getRoutes().remove(i);
        }
      }
    }

    if (getDefaultRoute() != null) {
      Restlet target = getDefaultRoute().getNext();

      if (target != null && Finder.class.isAssignableFrom(target.getClass())) {
        Finder finder = (Finder) target;

        if (finder.getTargetClass().equals(targetClass)) {
          setDefaultRoute(null);
        }
      }
    }
  }
Пример #2
0
  /**
   * Sets the next handler such as a Restlet or a Filter.
   *
   * <p>In addition, this method will set the context of the next Restlet if it is null by passing a
   * reference to its own context.
   *
   * @param next The next handler.
   */
  public void setNext(org.restlet.Uniform next) {
    if (next instanceof Restlet) {
      Restlet nextRestlet = (Restlet) next;

      if (nextRestlet.getContext() == null) {
        nextRestlet.setContext(getContext());
      }
    }

    this.next = next;

    // If true, it must be updated after calling this method
    this.nextCreated = false;
  }
  @Override
  public void handle(Request request, Response response) {
    super.handle(request, response);

    if (Method.GET.equals(request.getMethod())) {
      response.setEntity(getSwagger());
    } else {
      response.setStatus(Status.CLIENT_ERROR_METHOD_NOT_ALLOWED);
    }
  }
Пример #4
0
  /**
   * Handles a call by invoking the next Restlet if it is available.
   *
   * @param request The request to handle.
   * @param response The response to update.
   */
  @Override
  public void handle(Request request, Response response) {
    super.handle(request, response);
    Restlet next = getNext(request, response);

    if (next != null) {
      doHandle(next, request, response);
    } else {
      response.setStatus(Status.CLIENT_ERROR_NOT_FOUND);
    }
  }
Пример #5
0
  /** Stops the filter and the attached routes. */
  @Override
  public synchronized void stop() throws Exception {
    if (isStarted()) {
      if (getDefaultRoute() != null) {
        getDefaultRoute().stop();
      }

      for (Route route : getRoutes()) {
        route.stop();
      }

      super.stop();
    }
  }
Пример #6
0
  /**
   * Indicates that a Restlet's context has changed.
   *
   * @param restlet The Restlet with a changed context.
   * @param context The new context.
   */
  private static void fireContextChanged(Restlet restlet, Context context) {
    if (context != null) {
      if (context instanceof org.restlet.engine.util.ChildContext) {
        org.restlet.engine.util.ChildContext childContext =
            (org.restlet.engine.util.ChildContext) context;

        if (childContext.getChild() == null) {
          childContext.setChild(restlet);
        }
      } else if (!(restlet instanceof Component)
          && (context instanceof org.restlet.engine.component.ComponentContext)) {
        context
            .getLogger()
            .severe(
                "For security reasons, don't pass the component context to child Restlets anymore. Use the Context#createChildContext() method instead. "
                    + restlet.getClass());
      }
    }
  }
  @Override
  public void handle(Request request, Response response) {
    super.handle(request, response);

    try {
      if (request.getMethod().equals(Method.GET)) {

        try {
          if ("users".equalsIgnoreCase(request.getResourceRef().getLastSegment())) {
            UserListValue users = importer.users();
            StringRepresentation result =
                new StringRepresentation(
                    users.toJSON(),
                    MediaType.APPLICATION_JSON,
                    Language.DEFAULT,
                    CharacterSet.UTF_8);
            response.setStatus(Status.SUCCESS_OK);
            response.setEntity(result);
          } else if ("groups".equalsIgnoreCase(request.getResourceRef().getLastSegment())) {
            GroupListValue groups = importer.groups();
            StringRepresentation result =
                new StringRepresentation(
                    groups.toJSON(),
                    MediaType.APPLICATION_JSON,
                    Language.DEFAULT,
                    CharacterSet.UTF_8);
            response.setStatus(Status.SUCCESS_OK);
            response.setEntity(result);
          }
        } catch (ResourceException e) {
          response.setStatus(Status.CLIENT_ERROR_UNAUTHORIZED);
          response.setEntity(e.getStatus().getDescription(), MediaType.TEXT_PLAIN);
        }

      } else {
        response.setStatus(Status.CLIENT_ERROR_METHOD_NOT_ALLOWED);
      }
    } finally {
      request.release();
    }
  }
  /**
   * Redirects a given call on the server-side to a next Restlet with a given target reference. In
   * the default implementation, the request HTTP headers, stored in the request's attributes, are
   * removed before dispatching. After dispatching, the response HTTP headers are also removed to
   * prevent conflicts with the main call.
   *
   * @param next The next Restlet to forward the call to.
   * @param targetRef The target reference with URI variables resolved.
   * @param request The request to handle.
   * @param response The response to update.
   */
  protected void serverRedirect(
      Restlet next, Reference targetRef, Request request, Response response) {
    if (next == null) {
      getLogger().warning("No next Restlet provided for server redirection to " + targetRef);
    } else {
      // Save the base URI if it exists as we might need it for
      // redirections
      Reference resourceRef = request.getResourceRef();
      Reference baseRef = resourceRef.getBaseRef();

      // Reset the protocol and let the dispatcher handle the protocol
      request.setProtocol(null);

      // Update the request to cleanly go to the target URI
      request.setResourceRef(targetRef);
      request.getAttributes().remove(HeaderConstants.ATTRIBUTE_HEADERS);
      next.handle(request, response);

      // Allow for response rewriting and clean the headers
      response.setEntity(rewrite(response.getEntity()));
      response.getAttributes().remove(HeaderConstants.ATTRIBUTE_HEADERS);
      request.setResourceRef(resourceRef);

      // In case of redirection, we may have to rewrite the redirect URI
      if (response.getLocationRef() != null) {
        Template rt = new Template(this.targetTemplate);
        rt.setLogger(getLogger());
        int matched = rt.parse(response.getLocationRef().toString(), request);

        if (matched > 0) {
          String remainingPart = (String) request.getAttributes().get("rr");

          if (remainingPart != null) {
            response.setLocationRef(baseRef.toString() + remainingPart);
          }
        }
      }
    }
  }
Пример #9
0
  public void dispatched(Request request, Response response, Restlet restlet) {
    RequestData data = monitor.current();
    if (data == null) {
      // will happen in cases where the filter is not active
      return;
    }

    if (restlet instanceof Route) {
      restlet = ((Route) restlet).getNext();
    }

    if (restlet instanceof BeanDelegatingRestlet) {
      restlet = ((BeanDelegatingRestlet) restlet).getBean();
    }

    if (restlet != null) {
      if (restlet.getClass().getPackage().getName().startsWith("org.geoserver.catalog.rest")) {
        data.setService("RESTConfig");
      }
    }

    monitor.update();
  }
Пример #10
0
 /**
  * Effectively handles the call using the selected next {@link Restlet}, typically the selected
  * {@link Route}. By default, it just invokes the next Restlet.
  *
  * @param next The next Restlet to invoke.
  * @param request The request.
  * @param response The response.
  */
 protected void doHandle(Restlet next, Request request, Response response) {
   next.handle(request, response);
 }
 /** Constructor with a parent Restlet. */
 public SpringBeanRouter(Restlet parent) {
   super(parent.getContext());
 }