org.ovirt.engine.sdk.web.HttpProxy Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of ovirt-engine-sdk-java Show documentation
Show all versions of ovirt-engine-sdk-java Show documentation
This is Java SDK for the oVirt virtualization
//
// Copyright (c) 2012 Red Hat, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
package org.ovirt.engine.sdk.web;
import java.io.IOException;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;
import org.apache.http.Header;
import org.apache.http.HttpResponse;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpPut;
import org.apache.http.client.methods.HttpUriRequest;
import org.apache.http.client.protocol.ClientContext;
import org.apache.http.protocol.BasicHttpContext;
import org.ovirt.engine.sdk.exceptions.ServerException;
import org.ovirt.engine.sdk.utils.HttpHeaderUtils;
import org.ovirt.engine.sdk.utils.HttpResponseHelper;
import org.ovirt.engine.sdk.utils.StringUtils;
/**
* Proxy in to transport layer
*/
public class HttpProxy {
private static final String SESSION_TTL_HEADER = "Session-TTL";
private static final String COOKIE_HEADER = "Cookie";
private static final String CONTENT_TYPE_HEADER = "Content-type";
private static final String PERSISTENT_AUTH_HEADER_CONTENT = "persistent-auth";
private static final String PERSISTENT_AUTH_HEADER = "Prefer";
private static final String FILTER_HEADER = "Filter";
private static final String EXPECT_HEADER = "Expect";
private static final String ALTERNATIVE_EXPECT_HEADER = "X-Ovirt-Expect";
private static final String STATIC_HEADERS[] = new String[] { "Content-type:application/xml" };
private static final int BAD_REQUEST = 400;
private ConnectionsPool pool;
private List staticHeaders;
private boolean persistentAuth = true;
private boolean filter = false;
private boolean debug = false;
private String sessionid;
/**
*
* @param pool
* ConnectionsPool
* @param persistent_auth
* persistent authetication
* @param sessionid
* oVirt api sessionid to authenticate the user with
* (used as SSO solution instead of username+password)
* @param insecure
* flag
* @param filter
* flag
* @param debug
* flag
*/
public HttpProxy(ConnectionsPool pool, boolean persistent_auth,
String sessionid, boolean filter, boolean debug) {
super();
this.pool = pool;
this.staticHeaders = HttpHeaderUtils.toHeaders(STATIC_HEADERS);
this.persistentAuth = persistent_auth;
this.sessionid = sessionid;
this.filter = filter;
this.debug = debug;
}
/**
* @return oVirt API url
*/
public URL getUrl() {
return pool.getUrl();
}
/**
* Executes HTTP request
*
* @param request
* HTTP request
* @param headers
* HTTP headers
* @param last
* flags if persistanet auth. should be closed
*
* @return XML
*
* @throws IOException
* @throws ClientProtocolException
* @throws ServerException
*/
public String execute(HttpUriRequest request, List headers, Boolean last)
throws IOException, ClientProtocolException, ServerException {
injectHeaders(request, headers);
HttpResponse response = this.pool.execute(request, getContext());
if (response.getStatusLine().getStatusCode() < BAD_REQUEST) {
return HttpResponseHelper.getEntity(response.getEntity());
}
throw new ServerException(response);
}
/**
* Generates peer hit context
*
* @return {@link BasicHttpContext}
*/
private BasicHttpContext getContext() {
BasicHttpContext context = new BasicHttpContext();
if (this.persistentAuth && StringUtils.isNulOrEmpty(this.sessionid)) {
context.setAttribute(ClientContext.COOKIE_STORE, this.pool.getCookieStore());
}
return context;
}
/**
* Removes headers with NULL value
*
* @param headers
*
* @return List of {@link Header} where value != null
*/
private List excludeNullHeaders(List headers) {
if (headers != null && !headers.isEmpty()) {
List updated = new ArrayList();
for (Header header : headers) {
if (header.getValue() != null) {
updated.add(header);
}
}
return updated;
}
return headers;
}
/**
* Injects HTTP headers in to request
*
* @param request
* @param headers
*/
private void injectHeaders(HttpUriRequest request, List headers) {
List updated = excludeNullHeaders(headers);
if (updated != null && !updated.isEmpty()) {
request.setHeaders(updated.toArray(new Header[updated.size()]));
}
// The Apache web server ignores the "Expect" header, so if this header was explicitly added by the user, then
// we need to add the alternative "X-Ovirt-Expect" as well:
if (headers != null) {
for (Header header : headers) {
if (EXPECT_HEADER.equalsIgnoreCase(header.getName())) {
request.setHeader(ALTERNATIVE_EXPECT_HEADER, header.getValue());
}
}
}
// inject .ctr defined static parameters
for (Header header : this.staticHeaders) {
if (header.getName().equals(CONTENT_TYPE_HEADER)) {
if ((request instanceof HttpDelete) &&
((HttpDelete) request).getEntity() == null) {
continue;
} else if ((request instanceof HttpPut) &&
((HttpPut) request).getEntity() == null) {
continue;
} else if ((request instanceof HttpPost) &&
((HttpPost) request).getEntity() == null) {
continue;
}
}
request.addHeader(header);
}
// inject FILTER_HEADER
request.addHeader(FILTER_HEADER, Boolean.toString(isFilter()));
if (this.persistentAuth) {
// inject PERSISTENT_AUTH_HEADER
request.addHeader(PERSISTENT_AUTH_HEADER, PERSISTENT_AUTH_HEADER_CONTENT);
// inject COOKIE_HEADER if JSESSION provided explicitly
if (!StringUtils.isNulOrEmpty(this.sessionid)) {
request.addHeader(COOKIE_HEADER, this.sessionid);
}
// inject authentication session inactivity timeout
if (this.pool.getSessionTimeout() != null) {
request.addHeader(SESSION_TTL_HEADER,
String.valueOf(this.pool.getSessionTimeout()));
}
}
}
/**
* @return persistent authentication flag
*/
public boolean isPersistentAuth() {
return persistentAuth;
}
/**
* @param sets
* persistent authentication flag
*/
public void setPersistentAuth(boolean persistentAuth) {
this.persistentAuth = persistentAuth;
}
/**
* @param sessionid
* oVirt api sessionid to authenticate the user with
* (used as SSO solution instead of username+password)
*/
public void setSessionid(String sessionid) {
this.sessionid = sessionid;
}
/**
* oVirt api sessionid to authenticate the user with
* (used as SSO solution instead of username+password)
*/
public boolean isSetSessionid() {
return !StringUtils.isNulOrEmpty(this.sessionid);
}
/**
* @return Filter flag
*/
public boolean isFilter() {
return filter;
}
/**
* @param filter
* sets Filter flag
*/
public void setFilter(boolean filter) {
this.filter = filter;
}
/**
* @return Debug flag
*/
public boolean isDebug() {
return debug;
}
/**
* @param debug
* sets Debug flag
*/
public void setDebug(boolean debug) {
this.debug = debug;
}
/**
* When HttpProxy instance is no longer needed, shut down
* the connection manager to ensure immediate deallocation of
* all system resources.
*/
public void shutdown() {
this.pool.shutdown();
}
}