/** * Handles a call by first verifying the optional request conditions and continue the processing * if possible. Note that in order to evaluate those conditions, {@link #getInfo()} or {@link * #getInfo(Variant)} methods might be invoked. * * @return The response entity. * @throws ResourceException */ protected Representation doConditionalHandle() throws ResourceException { Representation result = null; if (getConditions().hasSome()) { RepresentationInfo resultInfo = null; if (existing) { if (isNegotiated()) { resultInfo = doGetInfo(getPreferredVariant(getVariants(Method.GET))); } else { resultInfo = doGetInfo(); } if (resultInfo == null) { if ((getStatus() == null) || (getStatus().isSuccess() && !Status.SUCCESS_NO_CONTENT.equals(getStatus()))) { setStatus(Status.CLIENT_ERROR_NOT_FOUND); } else { // Keep the current status as the developer might prefer // a special status like 'method not authorized'. } } else { Status status = getConditions().getStatus(getMethod(), resultInfo); if (status != null) { setStatus(status); } } } else { Status status = getConditions().getStatus(getMethod(), resultInfo); if (status != null) { setStatus(status); } } if ((Method.GET.equals(getMethod()) || Method.HEAD.equals(getMethod())) && resultInfo instanceof Representation) { result = (Representation) resultInfo; } else if ((getStatus() != null) && getStatus().isSuccess()) { // Conditions were passed successfully, continue the normal // processing. if (isNegotiated()) { // Reset the list of variants, as the method differs. getVariants().clear(); result = doNegotiatedHandle(); } else { result = doHandle(); } } } else { if (isNegotiated()) { result = doNegotiatedHandle(); } else { result = doHandle(); } } return result; }
/** * Looks up a {@link LayerInfo} or {@link LayerGroupInfo} named after the {@code <layer>} in the * requested resource {@code <layer>.kml} name * * @see org.restlet.Finder#findTarget(org.restlet.data.Request, org.restlet.data.Response) */ @Override public Resource findTarget(final Request request, Response response) { if (!Method.GET.equals(request.getMethod())) { response.setStatus(Status.CLIENT_ERROR_METHOD_NOT_ALLOWED); return null; } final String name = RESTUtils.getAttribute(request, "layer"); if (name == null) { throw new RestletException("No layer name specified", Status.CLIENT_ERROR_BAD_REQUEST); } final Catalog catalog = geoserver.getCatalog(); CatalogInfo layer = catalog.getLayerByName(name); MetadataMap mdmap; if (layer == null) { layer = catalog.getLayerGroupByName(name); if (layer == null) { throw new RestletException("Layer " + name + " not found", Status.CLIENT_ERROR_NOT_FOUND); } mdmap = ((LayerGroupInfo) layer).getMetadata(); } else { mdmap = ((LayerInfo) layer).getMetadata(); } Boolean enabled = mdmap.get(Properties.INDEXING_ENABLED, Boolean.class); if (enabled == null || !enabled.booleanValue()) { throw new RestletException("Layer " + name + " not found", Status.CLIENT_ERROR_NOT_FOUND); } final Context context = getContext(); return new GeoSearchLayer(context, request, response, layer, geoserver); }
/** * Handles a call for a local entity. By default, only GET and HEAD methods are implemented. * * @param request The request to handle. * @param response The response to update. * @param decodedPath The URL decoded entity path. */ @Override protected void handleLocal(Request request, Response response, String decodedPath) { int spi = decodedPath.indexOf("!/"); String fileUri; String entryName; if (spi != -1) { fileUri = decodedPath.substring(0, spi); entryName = decodedPath.substring(spi + 2); } else { fileUri = decodedPath; entryName = ""; } LocalReference fileRef = new LocalReference(fileUri); if (Protocol.FILE.equals(fileRef.getSchemeProtocol())) { final File file = fileRef.getFile(); if (Method.GET.equals(request.getMethod()) || Method.HEAD.equals(request.getMethod())) { handleGet(request, response, file, entryName, getMetadataService()); } else if (Method.PUT.equals(request.getMethod())) { handlePut(request, response, file, entryName); } else { response.setStatus(Status.CLIENT_ERROR_METHOD_NOT_ALLOWED); response.getAllowedMethods().add(Method.GET); response.getAllowedMethods().add(Method.HEAD); response.getAllowedMethods().add(Method.PUT); } } else { response.setStatus(Status.SERVER_ERROR_NOT_IMPLEMENTED, "Only works on local files."); } }
@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); } }
public Response sendRequest(Method method, String url, Representation representation) { this.logger.debug("Method: " + method.getName() + " url: " + url); Request request = new Request(); request.setResourceRef(url); request.setMethod(method); if (!Method.GET.equals(method) && !Method.DELETE.equals(method)) { request.setEntity(representation); } request.setChallengeResponse(this.challenge); return this.restClient.handle(request); }
/** * Handles any call to this resource. The default implementation check the {@link * #isConditional()} and {@link #isNegotiated()} method to determine which one of the {@link * #doConditionalHandle()}, {@link #doNegotiatedHandle()} and {@link #doHandle()} methods should * be invoked. It also catches any {@link ResourceException} thrown and updates the response * status using the {@link #setStatus(Status, Throwable, String)} method.<br> * <br> * After handling, if the status is set to {@link Status#CLIENT_ERROR_METHOD_NOT_ALLOWED}, then * {@link #updateAllowedMethods()} is invoked to give the resource a chance to inform the client * about the allowed methods. * * @return The response entity. */ @Override public Representation handle() { Representation result = null; // If the resource is not available after initialization and if this a // retrieval method, then return a "not found" response. if (!isExisting() && getMethod().isSafe()) { setStatus(Status.CLIENT_ERROR_NOT_FOUND); } else { try { if (isConditional()) { result = doConditionalHandle(); } else if (isNegotiated()) { result = doNegotiatedHandle(); } else { result = doHandle(); } if (!getResponse().isEntityAvailable()) { // If the user manually set the entity, keep it getResponse().setEntity(result); } if (Status.CLIENT_ERROR_METHOD_NOT_ALLOWED.equals(getStatus())) { updateAllowedMethods(); } else if (Method.GET.equals(getMethod()) && Status.SUCCESS_OK.equals(getStatus()) && (getResponseEntity() == null || !getResponseEntity().isAvailable())) { getLogger() .fine( "A response with a 200 (Ok) status should have an entity. Changing the status to 204 (No content)."); setStatus(Status.SUCCESS_NO_CONTENT); } } catch (Throwable t) { doCatch(t); } } return result; }
@Override public boolean supports(final Method method) { return Method.POST.equals(method) || Method.GET.equals(method) || super.supports(method); }
/** * Constructor. * * @param helper The parent HTTP client helper. * @param method The method name. * @param requestUri The request URI. * @param hasEntity Indicates if the call will have an entity to send to the server. * @throws IOException */ public HttpMethodCall( HttpClientHelper helper, final String method, String requestUri, boolean hasEntity) throws IOException { super(helper, method, requestUri); this.clientHelper = helper; if (requestUri.startsWith("http")) { if (method.equalsIgnoreCase(Method.GET.getName())) { this.httpMethod = new GetMethod(requestUri); } else if (method.equalsIgnoreCase(Method.POST.getName())) { this.httpMethod = new PostMethod(requestUri); } else if (method.equalsIgnoreCase(Method.PUT.getName())) { this.httpMethod = new PutMethod(requestUri); } else if (method.equalsIgnoreCase(Method.HEAD.getName())) { this.httpMethod = new HeadMethod(requestUri); } else if (method.equalsIgnoreCase(Method.DELETE.getName())) { this.httpMethod = new DeleteMethod(requestUri); } else if (method.equalsIgnoreCase(Method.CONNECT.getName())) { final HostConfiguration host = new HostConfiguration(); host.setHost(new URI(requestUri, false)); this.httpMethod = new ConnectMethod(host); } else if (method.equalsIgnoreCase(Method.OPTIONS.getName())) { this.httpMethod = new OptionsMethod(requestUri); } else if (method.equalsIgnoreCase(Method.TRACE.getName())) { this.httpMethod = new TraceMethod(requestUri); } else { this.httpMethod = new EntityEnclosingMethod(requestUri) { @Override public String getName() { return method; } }; } this.httpMethod.setFollowRedirects(this.clientHelper.isFollowRedirects()); this.httpMethod.setDoAuthentication(false); if (this.clientHelper.getRetryHandler() != null) { try { this.httpMethod .getParams() .setParameter( HttpMethodParams.RETRY_HANDLER, Engine.loadClass(this.clientHelper.getRetryHandler()).newInstance()); } catch (Exception e) { this.clientHelper .getLogger() .log( Level.WARNING, "An error occurred during the instantiation of the retry handler.", e); } } this.responseHeadersAdded = false; setConfidential( this.httpMethod.getURI().getScheme().equalsIgnoreCase(Protocol.HTTPS.getSchemeName())); } else { throw new IllegalArgumentException("Only HTTP or HTTPS resource URIs are allowed here"); } }
private Representation handle(ParameterList request) { Logger log = getLogger(); log.info("Handle on OP"); ConcurrentMap<String, Object> attribs = getContext().getAttributes(); ServerManager manager = (ServerManager) attribs.get("openid_manager"); log.info("OP endpoint = " + manager.getOPEndpointUrl()); String mode = request.hasParameter("openid.mode") ? request.getParameterValue("openid.mode") : null; Message response; String responseText; if ("associate".equals(mode)) { // --- process an association request --- response = manager.associationResponse(request); responseText = response.keyValueFormEncoding(); } else if ("checkid_setup".equals(mode) || "checkid_immediate".equals(mode)) { // interact with the user and obtain data needed to continue List<?> userData = userInteraction(request, manager.getOPEndpointUrl()); String userSelectedId = (String) userData.get(0); String userSelectedClaimedId = (String) userData.get(1); Boolean authenticatedAndApproved = (Boolean) userData.get(2); // --- process an authentication request --- response = manager.authResponse( request, userSelectedId, userSelectedClaimedId, authenticatedAndApproved.booleanValue()); if (response instanceof DirectError) { Form f = new Form(); @SuppressWarnings("unchecked") Map<String, String> m = (Map<String, String>) response.getParameterMap(); for (String key : m.keySet()) { f.add(key, m.get(key)); } return f.getWebRepresentation(); } else { // caller will need to decide which of the following to use: // option1: GET HTTP-redirect to the return_to URL // return new // StringRepresentation(response.getDestinationUrl(true)); redirectSeeOther(response.getDestinationUrl(true)); return new EmptyRepresentation(); // option2: HTML FORM Redirection // RequestDispatcher dispatcher = // getServletContext().getRequestDispatcher("formredirection.jsp"); // httpReq.setAttribute("prameterMap", // response.getParameterMap()); // httpReq.setAttribute("destinationUrl", // response.getDestinationUrl(false)); // dispatcher.forward(request, response); // return null; } } else if ("check_authentication".equals(mode)) { // --- processing a verification request --- response = manager.verify(request); log.info("OpenID : " + response.keyValueFormEncoding()); responseText = response.keyValueFormEncoding(); } else if (Method.GET.equals(getMethod())) { // Could be a discovery request sendXRDSLocation(); return new StringRepresentation("XRDS Discovery Information"); } else { // --- error response --- response = DirectError.createDirectError("Unknown request"); responseText = response.keyValueFormEncoding(); } // return the result to the user return new StringRepresentation(responseText); }