/**
* 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);
}
