@Override public void registerMethods() { Method.register(Method.ALL); Method.register(Method.CONNECT); Method.register(Method.DELETE); Method.register(Method.GET); Method.register(Method.HEAD); Method.register(Method.OPTIONS); Method.register(Method.POST); Method.register(Method.PUT); Method.register(Method.TRACE); }
/** * Constructor. * * @param context The context of the parent connector. * @param connection The associated network connection. * @param methodName The protocol method name. * @param resourceUri The target resource URI. * @param protocol The protocol name and version. */ public SipInboundRequest( Context context, Connection<Server> connection, String methodName, String resourceUri, String protocol) { super(); this.context = context; this.cacheDirectivesAdded = false; this.clientAdded = false; this.conditionAdded = false; this.connection = connection; this.cookiesAdded = false; this.referrerAdded = false; this.securityAdded = false; this.userPrincipal = null; this.proxySecurityAdded = false; this.recipientsInfoAdded = false; this.resourceUri = resourceUri; this.protocol = protocol; this.warningsAdded = false; // SIP specific initialization this.alertInfoAdded = false; this.allowedEventTypesAdded = false; this.callerInfoAdded = false; this.contactAdded = false; this.eventAdded = false; this.inReplyToAdded = false; this.priorityAdded = false; // Set the properties setMethod(Method.valueOf(methodName)); }
/** * Issue a request with the given {@link Method} to the provided resource URI. * * @param method the http method to use * @param resourceUri the uri to issue the request to * @return the response to the request */ public MockHttpServletResponse callInternal(Method method, String resourceUri) throws Exception { MockHttpServletRequest request = super.createRequest(resourceUri); request.setMethod(method.getName()); return dispatch(request, null); }
public MethodNotAllowedException(Reference uri, Method method) { super( Status.CLIENT_ERROR_METHOD_NOT_ALLOWED.getCode(), String.format("Method %s not allowed", method), String.format("Method %s not allowed to %s", method.getName(), uri), null); }
// Update the endpointUri with the restlet method information protected void updateEndpointUri() { String endpointUri = getEndpointUri(); CollectionStringBuffer methods = new CollectionStringBuffer(","); if (getRestletMethods() != null && getRestletMethods().length > 0) { // list the method(s) as a comma seperated list for (Method method : getRestletMethods()) { methods.append(method.getName()); } } else { // otherwise consider the single method we own methods.append(getRestletMethod()); } // update the uri endpointUri = endpointUri + "?restletMethods=" + methods; setEndpointUri(endpointUri); }
/** * Returns the target method according to a list of properties. * * @param resolver The resolver. * @return The target method. */ protected Method getTargetMethod(Resolver<String> resolver) { Method method = Method.valueOf(resolver.resolve("method")); if (method == null) { method = getTargetMethod(); } return method; }
/** * Effectively handles a call without content negotiation of the response entity. The default * behavior is to dispatch the call to one of the {@link #get()}, {@link #post(Representation)}, * {@link #put(Representation)}, {@link #delete()}, {@link #head()} or {@link #options()} methods. * * @return The response entity. * @throws ResourceException */ protected Representation doHandle() throws ResourceException { Representation result = null; Method method = getMethod(); if (method == null) { setStatus(Status.CLIENT_ERROR_BAD_REQUEST, "No method specified"); } else { if (method.equals(Method.PUT)) { result = put(getRequestEntity()); } else if (isExisting()) { if (method.equals(Method.GET)) { result = get(); } else if (method.equals(Method.POST)) { result = post(getRequestEntity()); } else if (method.equals(Method.DELETE)) { result = delete(); } else if (method.equals(Method.HEAD)) { result = head(); } else if (method.equals(Method.OPTIONS)) { result = options(); } else { result = doHandle(method, getRequestEntity()); } } else { setStatus(Status.CLIENT_ERROR_NOT_FOUND); } } return result; }
public MockHttpServletResponse callInternal(Method method, String resourceUri, Form form) throws Exception { MockHttpServletRequest request = super.createRequest(resourceUri); request.setMethod(method.getName()); // set the JSON payload request.setContent(form.encode().getBytes()); request.setContentType("application/x-www-form-urlencoded"); return dispatch(request, null); }
public MockHttpServletResponse callInternal( Method method, String resourceUri, JSONObject payload) throws Exception { MockHttpServletRequest request = super.createRequest(resourceUri); request.setMethod(method.getName()); // set the JSON payload request.setContent(payload.toString().getBytes()); request.setContentType("application/json"); return dispatch(request, null); }
/** * Constructor. * * @param context The context of the HTTP server connector that issued the call. * @param httpCall The low-level HTTP server call. */ public HttpRequest(Context context, ServerCall httpCall) { this.context = context; this.clientAdded = false; this.conditionAdded = false; this.cookiesAdded = false; this.entityAdded = false; this.referrerAdded = false; this.securityAdded = false; this.proxySecurityAdded = false; this.recipientsInfoAdded = false; this.warningsAdded = false; this.httpCall = httpCall; // Set the properties setMethod(Method.valueOf(httpCall.getMethod())); // Set the host reference StringBuilder sb = new StringBuilder(); sb.append(httpCall.getProtocol().getSchemeName()).append("://"); sb.append(httpCall.getHostDomain()); if ((httpCall.getHostPort() != -1) && (httpCall.getHostPort() != httpCall.getProtocol().getDefaultPort())) { sb.append(':').append(httpCall.getHostPort()); } setHostRef(sb.toString()); // Set the resource reference if (httpCall.getRequestUri() != null) { setResourceRef(new Reference(getHostRef(), httpCall.getRequestUri())); if (getResourceRef().isRelative()) { // Take care of the "/" between the host part and the segments. if (!httpCall.getRequestUri().startsWith("/")) { setResourceRef(new Reference(getHostRef().toString() + "/" + httpCall.getRequestUri())); } else { setResourceRef(new Reference(getHostRef().toString() + httpCall.getRequestUri())); } } setOriginalRef(getResourceRef().getTargetRef()); } // Set the request date String dateHeader = httpCall.getRequestHeaders().getFirstValue(HeaderConstants.HEADER_DATE); Date date = null; if (dateHeader != null) { date = DateUtils.parse(dateHeader); } if (date == null) { date = new Date(); } setDate(date); }
public void handle(Request request, Response response) { Method met = request.getMethod(); try { if (met.equals(Method.GET)) { doGet(request, response); } else if (met.equals(Method.POST)) { doPost(request, response); } else { throw new RestletException("Method not allowed", Status.CLIENT_ERROR_METHOD_NOT_ALLOWED); } } catch (RestletException re) { response.setEntity(re.getRepresentation()); response.setStatus(re.getStatus()); } catch (IOException ioe) { StringBuilder strBld = new StringBuilder(); strBld.append("<?xml version=\"1.0\" encoding=\"utf-8\"?>"); strBld.append("\n<GeoWebCacheException>"); strBld.append("\nEncountered IO error " + ioe.getMessage()); strBld.append("\n</GeoWebCacheException>"); response.setEntity(strBld.toString(), MediaType.TEXT_XML); response.setStatus(Status.SERVER_ERROR_INTERNAL); } }
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); }
/** * Effectively handles a call with content negotiation of the response entity. The default * behavior is to dispatch the call to one of the {@link #get(Variant)}, {@link * #post(Representation,Variant)}, {@link #put(Representation,Variant)}, {@link #delete(Variant)}, * {@link #head(Variant)} or {@link #options(Variant)} methods. * * @param variant The response variant expected. * @return The response entity. * @throws ResourceException */ protected Representation doHandle(Variant variant) throws ResourceException { Representation result = null; Method method = getMethod(); if (method == null) { setStatus(Status.CLIENT_ERROR_BAD_REQUEST, "No method specified"); } else { if (method.equals(Method.PUT)) { result = put(getRequestEntity(), variant); } else if (isExisting()) { if (method.equals(Method.GET)) { if (variant instanceof Representation) { result = (Representation) variant; } else { result = get(variant); } } else if (method.equals(Method.POST)) { result = post(getRequestEntity(), variant); } else if (method.equals(Method.DELETE)) { result = delete(variant); } else if (method.equals(Method.HEAD)) { if (variant instanceof Representation) { result = (Representation) variant; } else { result = head(variant); } } else if (method.equals(Method.OPTIONS)) { if (variant instanceof Representation) { result = (Representation) variant; } else { result = options(variant); } } else if (variant instanceof VariantInfo) { result = doHandle(((VariantInfo) variant).getAnnotationInfo(), variant); } else { setStatus(Status.CLIENT_ERROR_METHOD_NOT_ALLOWED); } } else { setStatus(Status.CLIENT_ERROR_NOT_FOUND); } } return result; }
private static Operation getOperationFromMethod(Method method) { Operation operation = new Operation(); operation.setMethod(method.getName()); return operation; }