com.emc.esu.api.rest.EsuRestApiApache Maven / Gradle / Ivy
The newest version!
/*
* Copyright 2013 EMC Corporation. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://www.apache.org/licenses/LICENSE-2.0.txt
*
* or in the "license" file accompanying this file. This file 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 com.emc.esu.api.rest;
import com.emc.esu.api.*;
import org.apache.http.*;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.methods.*;
import org.apache.http.conn.params.ConnRoutePNames;
import org.apache.http.conn.scheme.PlainSocketFactory;
import org.apache.http.conn.scheme.Scheme;
import org.apache.http.conn.scheme.SchemeRegistry;
import org.apache.http.conn.ssl.SSLSocketFactory;
import org.apache.http.entity.ByteArrayEntity;
import org.apache.http.entity.InputStreamEntity;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.impl.conn.PoolingClientConnectionManager;
import org.apache.http.impl.cookie.DateParseException;
import org.apache.http.impl.cookie.DateUtils;
import org.apache.http.message.AbstractHttpMessage;
import org.apache.http.util.EntityUtils;
import org.apache.log4j.Logger;
import org.jdom.Document;
import org.jdom.JDOMException;
import org.jdom.input.SAXBuilder;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.net.MalformedURLException;
import java.net.URISyntaxException;
import java.net.URL;
import java.security.GeneralSecurityException;
import java.util.*;
/**
* This is an enhanced version of the REST API that uses the Apache Commons
* HTTP Client as its transport layer instead of the built-in Java HTTP
* client. It should perform better at the expense of a slightly larger
* footprint. See the JARs in the commons-httpclient directory in the
* project's root folder.
*
* @author Jason Cwik
*
*/
public class EsuRestApiApache extends AbstractEsuRestApi {
private static final Logger l4j = Logger.getLogger( EsuRestApiApache.class );
private DefaultHttpClient httpClient;
/**
* Creates a new EsuRestApiApache object.
*
* @param host the hostname or IP address of the ESU server
* @param port the port on the server to communicate with. Generally this is
* 80 for HTTP and 443 for HTTPS.
* @param uid the username to use when connecting to the server
* @param sharedSecret the Base64 encoded shared secret to use to sign
* requests to the server.
*/
public EsuRestApiApache(String host, int port, String uid, String sharedSecret) {
super(host, port, uid, sharedSecret);
SchemeRegistry schemeRegistry = new SchemeRegistry();
schemeRegistry.register(new Scheme("https", port, SSLSocketFactory.getSocketFactory()));
schemeRegistry.register(new Scheme("http", port, PlainSocketFactory.getSocketFactory()));
PoolingClientConnectionManager cm = new PoolingClientConnectionManager(schemeRegistry);
// Increase max total connection to 200
cm.setMaxTotal(200);
// Increase default max connection per route to 20
cm.setDefaultMaxPerRoute(200);
httpClient = new DefaultHttpClient( cm, null );
}
public void setProxy( String host, int port, boolean https ) {
setProxy( host, port, https, null, null );
}
public void setProxy( String host, int port, boolean https, String username,
String password ) {
HttpHost proxyHost = new HttpHost( host, port, https?"https":"http" );
httpClient.getParams().setParameter( ConnRoutePNames.DEFAULT_PROXY,
proxyHost );
if( username != null ) {
httpClient.getCredentialsProvider().setCredentials(
new AuthScope(host, port),
new UsernamePasswordCredentials(username, password));
}
}
/**
* Creates a new object in the cloud.
* @param path The path to create the object on.
* @param acl Access control list for the new object. May be null
* to use a default ACL
* @param metadata Metadata for the new object. May be null for
* no metadata.
* @param data The initial contents of the object. May be appended
* to later. The stream will NOT be closed at the end of the request.
* @param length The length of the stream in bytes. If the stream
* is longer than the length, only length bytes will be written. If
* the stream is shorter than the length, an error will occur.
* @param mimeType the MIME type of the content. Optional,
* may be null. If data is non-null and mimeType is null, the MIME
* type will default to application/octet-stream.
* @return Identifier of the newly created object.
* @throws EsuException if the request fails.
*/
public ObjectId createObjectFromStreamOnPath( ObjectPath path, Acl acl, MetadataList metadata,
InputStream data, long length, String mimeType ) {
try {
String resource = getResourcePath(context, path);
URL u = buildUrl(resource, null);
if (data == null) {
throw new IllegalArgumentException("Input stream is required");
}
// Build headers
Map headers = new HashMap();
// Figure out the mimetype
if (mimeType == null) {
mimeType = "application/octet-stream";
}
headers.put("Content-Type", mimeType);
headers.put("x-emc-uid", uid);
// Process metadata
if (metadata != null) {
processMetadata(metadata, headers);
}
l4j.debug("meta " + headers.get("x-emc-meta"));
// Add acl
if (acl != null) {
processAcl(acl, headers);
}
// Add date
headers.put("Date", getDateHeader());
// Sign request
signRequest("POST", resource, null, headers);
HttpResponse response = restPost( u, headers, data, length );
// Check response
handleError( response );
// The new object ID is returned in the location response header
String location = response.getFirstHeader("location").getValue();
// Cleanup the connection
cleanup( response );
// Parse the value out of the URL
return getObjectId( location );
} catch (MalformedURLException e) {
throw new EsuException("Invalid URL", e);
} catch (IOException e) {
throw new EsuException("Error connecting to server", e);
} catch (GeneralSecurityException e) {
throw new EsuException("Error computing request signature", e);
} catch (URISyntaxException e) {
throw new EsuException("Invalid URL", e);
}
}
/**
* Creates a new object in the cloud.
*
* @param acl Access control list for the new object. May be null to use a
* default ACL
* @param metadata Metadata for the new object. May be null for no metadata.
* @param data The initial contents of the object. May be appended to later.
* The stream will NOT be closed at the end of the request.
* @param length The length of the stream in bytes. If the stream is longer
* than the length, only length bytes will be written. If the
* stream is shorter than the length, an error will occur.
* @param mimeType the MIME type of the content. Optional, may be null. If
* data is non-null and mimeType is null, the MIME type will
* default to application/octet-stream.
* @return Identifier of the newly created object.
* @throws EsuException if the request fails.
*/
public ObjectId createObjectFromStream(Acl acl, MetadataList metadata,
InputStream data, long length, String mimeType) {
try {
String resource = context + "/objects";
URL u = buildUrl(resource, null);
if (data == null) {
throw new IllegalArgumentException("Input stream is required");
}
// Build headers
Map headers = new HashMap();
// Figure out the mimetype
if (mimeType == null) {
mimeType = "application/octet-stream";
}
headers.put("Content-Type", mimeType);
headers.put("x-emc-uid", uid);
// Process metadata
if (metadata != null) {
processMetadata(metadata, headers);
}
l4j.debug("meta " + headers.get("x-emc-meta"));
// Add acl
if (acl != null) {
processAcl(acl, headers);
}
// Add date
headers.put("Date", getDateHeader());
// Sign request
signRequest("POST", resource, null, headers);
HttpResponse response = restPost( u, headers, data, length );
// Check response
handleError( response );
// The new object ID is returned in the location response header
String location = response.getFirstHeader("location").getValue();
// Cleanup the connection
cleanup( response );
// Parse the value out of the URL
return getObjectId( location );
} catch (MalformedURLException e) {
throw new EsuException("Invalid URL", e);
} catch (IOException e) {
throw new EsuException("Error connecting to server", e);
} catch (GeneralSecurityException e) {
throw new EsuException("Error computing request signature", e);
} catch (URISyntaxException e) {
throw new EsuException("Invalid URL", e);
}
}
/**
* Creates a new object in the cloud using a BufferSegment.
*
* @param acl Access control list for the new object. May be null to use a
* default ACL
* @param metadata Metadata for the new object. May be null for no metadata.
* @param data The initial contents of the object. May be appended to later.
* May be null to create an object with no content.
* @param mimeType the MIME type of the content. Optional, may be null. If
* data is non-null and mimeType is null, the MIME type will
* default to application/octet-stream.
* @param checksum if not null, use the Checksum object to compute
* the checksum for the create object request. If appending
* to the object with subsequent requests, use the same
* checksum object for each request.
* @return Identifier of the newly created object.
* @throws EsuException if the request fails.
*/
public ObjectId createObjectFromSegment(Acl acl, MetadataList metadata,
BufferSegment data, String mimeType, Checksum checksum) {
try {
String resource = context + "/objects";
URL u = buildUrl(resource, null);
// Build headers
Map headers = new HashMap();
// Figure out the mimetype
if (mimeType == null) {
mimeType = "application/octet-stream";
}
headers.put("Content-Type", mimeType);
headers.put("x-emc-uid", uid);
// Process metadata
if (metadata != null) {
processMetadata(metadata, headers);
}
l4j.debug("meta " + headers.get("x-emc-meta"));
// Add acl
if (acl != null) {
processAcl(acl, headers);
}
// Process data
if (data == null) {
data = new BufferSegment(new byte[0]);
}
// Add date
headers.put("Date", getDateHeader());
// Compute checksum
if( checksum != null ) {
checksum.update( data.getBuffer(), data.getOffset(), data.getSize() );
headers.put( "x-emc-wschecksum", checksum.toString() );
}
// Sign request
signRequest("POST", resource, null, headers);
HttpResponse response = restPost( u, headers, data );
// Check response
handleError( response );
// The new object ID is returned in the location response header
String location = response.getFirstHeader("location").getValue();
// Cleanup the connection
cleanup( response );
// Parse the value out of the URL
return getObjectId( location );
} catch (MalformedURLException e) {
throw new EsuException("Invalid URL", e);
} catch (IOException e) {
throw new EsuException("Error connecting to server", e);
} catch (GeneralSecurityException e) {
throw new EsuException("Error computing request signature", e);
} catch (URISyntaxException e) {
throw new EsuException("Invalid URL", e);
}
}
/**
* Creates a new object in the cloud using a BufferSegment on the given
* path.
*
* @param path the path to create the object on.
* @param acl Access control list for the new object. May be null to use a
* default ACL
* @param metadata Metadata for the new object. May be null for no metadata.
* @param data The initial contents of the object. May be appended to later.
* May be null to create an object with no content.
* @param mimeType the MIME type of the content. Optional, may be null. If
* data is non-null and mimeType is null, the MIME type will
* default to application/octet-stream.
* @param checksum if not null, use the Checksum object to compute
* the checksum for the create object request. If appending
* to the object with subsequent requests, use the same
* checksum object for each request.
* @return the ObjectId of the newly-created object for references by ID.
* @throws EsuException if the request fails.
*/
public ObjectId createObjectFromSegmentOnPath(ObjectPath path, Acl acl,
MetadataList metadata, BufferSegment data, String mimeType, Checksum checksum) {
try {
String resource = getResourcePath(context, path);
URL u = buildUrl(resource, null);
// Build headers
Map headers = new HashMap();
// Figure out the mimetype
if (mimeType == null) {
mimeType = "application/octet-stream";
}
headers.put("Content-Type", mimeType);
headers.put("x-emc-uid", uid);
// Process metadata
if (metadata != null) {
processMetadata(metadata, headers);
}
l4j.debug("meta " + headers.get("x-emc-meta"));
// Add acl
if (acl != null) {
processAcl(acl, headers);
}
// Process data
if (data == null) {
data = new BufferSegment(new byte[0]);
}
// Add date
headers.put("Date", getDateHeader());
// Compute checksum
if( checksum != null ) {
checksum.update( data.getBuffer(), data.getOffset(), data.getSize() );
headers.put( "x-emc-wschecksum", checksum.toString() );
}
// Sign request
signRequest("POST", resource, null, headers);
HttpResponse response = restPost( u, headers, data );
// Check response
handleError( response );
// The new object ID is returned in the location response header
String location = response.getFirstHeader("location").getValue();
// Cleanup the connection
cleanup( response );
// Parse the value out of the URL
return getObjectId( location );
} catch (MalformedURLException e) {
throw new EsuException("Invalid URL", e);
} catch (IOException e) {
throw new EsuException("Error connecting to server", e);
} catch (GeneralSecurityException e) {
throw new EsuException("Error computing request signature", e);
} catch (URISyntaxException e) {
throw new EsuException("Invalid URL", e);
}
}
/**
* Deletes an object from the cloud.
*
* @param id the identifier of the object to delete.
*/
public void deleteObject(Identifier id) {
try {
String resource = getResourcePath(context, id);
URL u = buildUrl(resource, null);
// Build headers
Map headers = new HashMap();
headers.put("x-emc-uid", uid);
// Add date
headers.put("Date", getDateHeader());
// Sign request
signRequest("DELETE", resource, null, headers);
HttpResponse response = restDelete( u, headers );
handleError( response );
cleanup( response );
} catch (MalformedURLException e) {
throw new EsuException("Invalid URL", e);
} catch (IOException e) {
throw new EsuException("Error connecting to server", e);
} catch (GeneralSecurityException e) {
throw new EsuException("Error computing request signature", e);
} catch (URISyntaxException e) {
throw new EsuException("Invalid URL", e);
}
}
/**
* Deletes a version of an object from the cloud.
*
* @param id the identifier of the object to delete.
*/
public void deleteVersion(ObjectId id) {
try {
String resource = getResourcePath(context, id);
String query = "versions";
URL u = buildUrl(resource, query);
// Build headers
Map headers = new HashMap();
headers.put("x-emc-uid", uid);
// Add date
headers.put("Date", getDateHeader());
// Sign request
signRequest("DELETE", resource, query, headers);
HttpResponse response = restDelete( u, headers );
handleError( response );
cleanup( response );
} catch (MalformedURLException e) {
throw new EsuException("Invalid URL", e);
} catch (IOException e) {
throw new EsuException("Error connecting to server", e);
} catch (GeneralSecurityException e) {
throw new EsuException("Error computing request signature", e);
} catch (URISyntaxException e) {
throw new EsuException("Invalid URL", e);
}
}
/**
* Deletes metadata items from an object.
*
* @param id the identifier of the object whose metadata to delete.
* @param tags the list of metadata tags to delete.
*/
public void deleteUserMetadata(Identifier id, MetadataTags tags) {
if (tags == null) {
throw new EsuException("Must specify tags to delete");
}
try {
String resource = getResourcePath(context, id);
String query = "metadata/user";
URL u = buildUrl(resource, query );
// Build headers
Map headers = new HashMap();
headers.put("x-emc-uid", uid);
// process tags
if (tags != null) {
processTags(tags, headers);
}
// Add date
headers.put("Date", getDateHeader());
// Sign request
signRequest("DELETE", resource, query, headers);
HttpResponse response = restDelete( u, headers );
handleError( response );
finishRequest( response );
} catch (MalformedURLException e) {
throw new EsuException("Invalid URL", e);
} catch (IOException e) {
throw new EsuException("Error connecting to server", e);
} catch (GeneralSecurityException e) {
throw new EsuException("Error computing request signature", e);
} catch (URISyntaxException e) {
throw new EsuException("Invalid URL", e);
}
}
/**
* Returns an object's ACL
*
* @param id the identifier of the object whose ACL to read
* @return the object's ACL
*/
public Acl getAcl(Identifier id) {
try {
String resource = getResourcePath(context, id);
String query = "acl";
URL u = buildUrl(resource, query);
// Build headers
Map headers = new HashMap();
headers.put("x-emc-uid", uid);
// Add date
headers.put("Date", getDateHeader());
// Sign request
signRequest("GET", resource, query, headers);
HttpResponse response = restGet( u, headers );
handleError(response);
// Parse return headers. User grants are in x-emc-useracl and
// group grants are in x-emc-groupacl
Acl acl = new Acl();
readAcl(acl, response.getFirstHeader("x-emc-useracl").getValue(),
Grantee.GRANT_TYPE.USER);
readAcl(acl, response.getFirstHeader("x-emc-groupacl").getValue(),
Grantee.GRANT_TYPE.GROUP);
finishRequest( response );
return acl;
} catch (MalformedURLException e) {
throw new EsuException("Invalid URL", e);
} catch (IOException e) {
throw new EsuException("Error connecting to server", e);
} catch (GeneralSecurityException e) {
throw new EsuException("Error computing request signature", e);
} catch (URISyntaxException e) {
throw new EsuException("Invalid URL", e);
}
}
/**
* Returns a list of the tags that are listable the current user's tennant.
*
* @param tag optional. If specified, the list will be limited to the tags
* under the specified tag. If null, only top level tags will be
* returned.
* @return the list of listable tags.
*/
public MetadataTags getListableTags(MetadataTag tag) {
return getListableTags(tag == null ? null : tag.getName());
}
/**
* Returns a list of the tags that are listable the current user's tennant.
*
* @param tag optional. If specified, the list will be limited to the tags
* under the specified tag. If null, only top level tags will be
* returned.
* @return the list of listable tags.
*/
public MetadataTags getListableTags(String tag) {
try {
String resource = context + "/objects";
String query = "listabletags";
URL u = buildUrl(resource, query);
// Build headers
Map headers = new HashMap();
headers.put("x-emc-uid", uid);
if(unicodeEnabled) {
headers.put("x-emc-utf8", "true");
}
// Add tag
if (tag != null) {
headers.put("x-emc-tags", unicodeEnabled ? encodeUtf8(tag) : tag);
}
// Add date
headers.put("Date", getDateHeader());
// Sign request
signRequest("GET", resource, query, headers);
HttpResponse response = restGet( u, headers );
handleError( response );
Header header = response.getFirstHeader("x-emc-listable-tags");
MetadataTags tags = new MetadataTags();
if (header != null) {
l4j.debug("x-emc-listable-tags: " + header);
readTags(tags, header.getValue(), true);
}
finishRequest( response );
return tags;
} catch (MalformedURLException e) {
throw new EsuException("Invalid URL", e);
} catch (IOException e) {
throw new EsuException("Error connecting to server", e);
} catch (GeneralSecurityException e) {
throw new EsuException("Error computing request signature", e);
} catch (URISyntaxException e) {
throw new EsuException("Invalid URL", e);
}
}
/**
* Fetches the system metadata for the object.
*
* @param id the identifier of the object whose system metadata to fetch.
* @param tags A list of system metadata tags to fetch. Optional. Default
* value is null to fetch all system metadata.
* @return The list of system metadata for the object.
*/
public MetadataList getSystemMetadata(Identifier id, MetadataTags tags) {
try {
String resource = getResourcePath(context, id);
String query = "metadata/system";
URL u = buildUrl(resource, query);
// Build headers
Map headers = new HashMap();
headers.put("x-emc-uid", uid);
// process tags
if (tags != null) {
processTags(tags, headers);
}
// Add date
headers.put("Date", getDateHeader());
// Sign request
signRequest("GET", resource, query, headers);
HttpResponse response = restGet( u, headers );
handleError( response );
// Parse return headers. Regular metadata is in x-emc-meta and
// listable metadata is in x-emc-listable-meta
MetadataList meta = new MetadataList();
readMetadata(meta, response.getFirstHeader("x-emc-meta"), false);
readMetadata(meta, response.getFirstHeader("x-emc-listable-meta"), true);
finishRequest( response );
return meta;
} catch (MalformedURLException e) {
throw new EsuException("Invalid URL", e);
} catch (IOException e) {
throw new EsuException("Error connecting to server", e);
} catch (GeneralSecurityException e) {
throw new EsuException("Error computing request signature", e);
} catch (URISyntaxException e) {
throw new EsuException("Invalid URL", e);
}
}
/**
* Fetches the user metadata for the object.
*
* @param id the identifier of the object whose user metadata to fetch.
* @param tags A list of user metadata tags to fetch. Optional. If null, all
* user metadata will be fetched.
* @return The list of user metadata for the object.
*/
public MetadataList getUserMetadata(Identifier id, MetadataTags tags) {
try {
String resource = getResourcePath(context, id);
String query = "metadata/user";
URL u = buildUrl(resource, query);
// Build headers
Map headers = new HashMap();
headers.put("x-emc-uid", uid);
if(unicodeEnabled) {
headers.put("x-emc-utf8", "true");
}
// process tags
if (tags != null) {
processTags(tags, headers);
}
// Add date
headers.put("Date", getDateHeader());
// Sign request
signRequest("GET", resource, query, headers);
HttpResponse response = restGet( u, headers );
handleError( response );
// Parse return headers. Regular metadata is in x-emc-meta and
// listable metadata is in x-emc-listable-meta
MetadataList meta = new MetadataList();
readMetadata(meta, response.getFirstHeader("x-emc-meta"), false);
readMetadata(meta, response.getFirstHeader("x-emc-listable-meta"), true);
finishRequest( response );
return meta;
} catch (MalformedURLException e) {
throw new EsuException("Invalid URL", e);
} catch (IOException e) {
throw new EsuException("Error connecting to server", e);
} catch (GeneralSecurityException e) {
throw new EsuException("Error computing request signature", e);
} catch (URISyntaxException e) {
throw new EsuException("Invalid URL", e);
}
}
/**
* Lists all objects with the given tag.
*
* @param tag the tag to search for
* @return The list of objects with the given tag. If no objects are found
* the List will be empty.
*/
public List listObjects(String tag, ListOptions options) {
try {
String resource = context + "/objects";
URL u = buildUrl(resource, null);
// Build headers
Map headers = new HashMap();
headers.put("x-emc-uid", uid);
if(unicodeEnabled) {
headers.put("x-emc-utf8", "true");
}
// Add tag
if (tag != null) {
headers.put("x-emc-tags", unicodeEnabled ? encodeUtf8(tag) : tag);
} else {
throw new EsuException("Tag cannot be null");
}
// Process options
if( options != null ) {
if( options.isIncludeMetadata() ) {
headers.put( "x-emc-include-meta", "1" );
if( options.getSystemMetadata() != null ) {
headers.put( "x-emc-system-tags",
join( options.getSystemMetadata(), "," ) );
}
if( options.getUserMetadata() != null ) {
headers.put( "x-emc-user-tags",
join( options.getUserMetadata(), "," ) );
}
}
if( options.getLimit() > 0 ) {
headers.put( "x-emc-limit", ""+options.getLimit() );
}
if( options.getToken() != null ) {
headers.put( "x-emc-token", options.getToken() );
}
}
// Add date
headers.put("Date", getDateHeader());
// Sign request
signRequest("GET", resource, null, headers);
HttpResponse response = restGet( u, headers );
try {
handleError( response );
} catch( EsuException e ) {
if( e.getAtmosCode() == 1003 ) {
return Collections.emptyList();
}
throw e;
}
if( options != null ) {
// Update the token for listing more results. If there are no
// more results, the header will not be set and the token will
// be cleared in the options object.
Header token = response.getFirstHeader("x-emc-token");
if( token != null ) {
options.setToken( token.getValue() );
} else {
options.setToken( null );
}
} else {
Header token = response.getFirstHeader("x-emc-token");
if( token != null ) {
l4j.warn( "Result set truncated. Use ListOptions to " +
"retrieve token for next page of results." );
}
}
// Get object id list from response
byte[] data = readStream( response.getEntity().getContent(),
(int) response.getEntity().getContentLength() );
if( l4j.isDebugEnabled() ) {
l4j.debug("Response: " + new String(data, "UTF-8"));
}
finishRequest( response );
return parseObjectListWithMetadata(data);
} catch (MalformedURLException e) {
throw new EsuException("Invalid URL", e);
} catch (IOException e) {
throw new EsuException("Error connecting to server", e);
} catch (GeneralSecurityException e) {
throw new EsuException("Error computing request signature", e);
} catch (URISyntaxException e) {
throw new EsuException("Invalid URL", e);
}
}
/**
* Returns the list of user metadata tags assigned to the object.
*
* @param id the object whose metadata tags to list
* @return the list of user metadata tags assigned to the object
*/
public MetadataTags listUserMetadataTags(Identifier id) {
try {
String resource = getResourcePath(context, id);
String query = "metadata/tags";
URL u = buildUrl(resource, query);
// Build headers
Map headers = new HashMap();
headers.put("x-emc-uid", uid);
if(unicodeEnabled) {
headers.put("x-emc-utf8", "true");
}
// Add date
headers.put("Date", getDateHeader());
// Sign request
signRequest("GET", resource, query, headers);
HttpResponse response = restGet( u, headers );
handleError( response );
// Get the user metadata tags out of x-emc-listable-tags and
// x-emc-tags
MetadataTags tags = new MetadataTags();
Header listableHeader = response.getFirstHeader( "x-emc-listable-tags" );
Header metaHeader = response.getFirstHeader( "x-emc-tags" );
if (listableHeader != null) readTags(tags, listableHeader.getValue(), true);
if (metaHeader != null) readTags(tags, metaHeader.getValue(), false);
finishRequest( response );
return tags;
} catch (MalformedURLException e) {
throw new EsuException("Invalid URL", e);
} catch (IOException e) {
throw new EsuException("Error connecting to server", e);
} catch (GeneralSecurityException e) {
throw new EsuException("Error computing request signature", e);
} catch (URISyntaxException e) {
throw new EsuException("Invalid URL", e);
}
}
/**
* Lists the versions of an object.
*
* @param id the object whose versions to list.
* @return The list of versions of the object. If the object does not have
* any versions, the array will be empty.
*/
public List listVersions(Identifier id) {
try {
String resource = getResourcePath(context, id);
String query = "versions";
URL u = buildUrl(resource, query);
// Build headers
Map headers = new HashMap();
headers.put("x-emc-uid", uid);
// Add date
headers.put("Date", getDateHeader());
// Sign request
signRequest("GET", resource, query, headers);
HttpResponse response = restGet( u, headers );
handleError( response );
// Get object id list from response
byte[] data = readStream( response.getEntity().getContent(),
(int) response.getEntity().getContentLength() );
if( l4j.isDebugEnabled() ) {
l4j.debug("Response: " + new String(data, "UTF-8"));
}
finishRequest( response );
return parseVersionList(data);
} catch (MalformedURLException e) {
throw new EsuException("Invalid URL", e);
} catch (IOException e) {
throw new EsuException("Error connecting to server", e);
} catch (GeneralSecurityException e) {
throw new EsuException("Error computing request signature", e);
} catch (URISyntaxException e) {
throw new EsuException("Invalid URL", e);
}
}
public List listVersions(ObjectId id, ListOptions options) {
try {
String resource = getResourcePath(context, id);
String query = "versions";
URL u = buildUrl(resource, query);
// Build headers
Map headers = new HashMap();
headers.put("x-emc-uid", uid);
// Process options
if( options != null ) {
if( options.isIncludeMetadata() ) {
l4j.warn("Include metadata is not supported for listVersions");
}
if( options.getLimit() > 0 ) {
headers.put( "x-emc-limit", ""+options.getLimit() );
}
if( options.getToken() != null ) {
headers.put( "x-emc-token", options.getToken() );
}
}
// Add date
headers.put("Date", getDateHeader());
// Sign request
signRequest("GET", resource, query, headers);
HttpResponse response = restGet( u, headers );
handleError( response );
if( options != null ) {
// Update the token for listing more results. If there are no
// more results, the header will not be set and the token will
// be cleared in the options object.
Header token = response.getFirstHeader("x-emc-token");
if( token != null ) {
options.setToken( token.getValue() );
} else {
options.setToken( null );
}
} else {
Header token = response.getFirstHeader("x-emc-token");
if( token != null ) {
l4j.warn( "Result set truncated. Use ListOptions to " +
"retrieve token for next page of results." );
}
}
// Get object id list from response
byte[] data = readStream( response.getEntity().getContent(),
(int) response.getEntity().getContentLength() );
if( l4j.isDebugEnabled() ) {
l4j.debug("Response: " + new String(data, "UTF-8"));
}
finishRequest( response );
return parseVersionListLong(data);
} catch (MalformedURLException e) {
throw new EsuException("Invalid URL", e);
} catch (IOException e) {
throw new EsuException("Error connecting to server", e);
} catch (GeneralSecurityException e) {
throw new EsuException("Error computing request signature", e);
} catch (URISyntaxException e) {
throw new EsuException("Invalid URL", e);
}
}
/**
* Executes a query for objects matching the specified XQuery string.
*
* @param xquery the XQuery string to execute against the cloud.
* @return the list of objects matching the query. If no objects are found,
* the array will be empty.
*/
public List queryObjects(String xquery) {
try {
String resource = context + "/objects";
URL u = buildUrl(resource, null);
// Build headers
Map headers = new HashMap();
headers.put("x-emc-uid", uid);
// Add query
if (xquery != null) {
headers.put("x-emc-xquery", xquery);
} else {
throw new EsuException("Query cannot be null");
}
// Add date
headers.put("Date", getDateHeader());
// Sign request
signRequest("GET", resource, null, headers);
HttpResponse response = restGet( u, headers );
handleError( response );
// Get object id list from response
byte[] data = readStream( response.getEntity().getContent(),
(int) response.getEntity().getContentLength() );
if( l4j.isDebugEnabled() ) {
l4j.debug("Response: " + new String(data, "UTF-8"));
}
finishRequest( response );
return parseObjectList(data);
} catch (MalformedURLException e) {
throw new EsuException("Invalid URL", e);
} catch (IOException e) {
throw new EsuException("Error connecting to server", e);
} catch (GeneralSecurityException e) {
throw new EsuException("Error computing request signature", e);
} catch (URISyntaxException e) {
throw new EsuException("Invalid URL", e);
}
}
/**
* Reads an object's content.
*
* @param id the identifier of the object whose content to read.
* @param extent the portion of the object data to read. Optional. Default
* is null to read the entire object.
* @param buffer the buffer to use to read the extent. Must be large enough
* to read the response or an error will be thrown. If null, a
* buffer will be allocated to hold the response data. If you
* pass a buffer that is larger than the extent, only
* extent.getSize() bytes will be valid.
* @param checksum if not null, the given checksum object will be used
* to verify checksums during the read operation. Note that only erasure
* coded objects will return checksums *and* if you're reading the object
* in chunks, you'll have to read the data back sequentially to keep
* the checksum consistent. If the read operation does not return
* a checksum from the server, the checksum operation will be skipped.
* @return the object data read as a byte array.
*/
public byte[] readObject(Identifier id, Extent extent, byte[] buffer, Checksum checksum) {
try {
String resource = getResourcePath(context, id);
URL u = buildUrl(resource, null);
// Build headers
Map headers = new HashMap();
headers.put("x-emc-uid", uid);
// Add date
headers.put("Date", getDateHeader());
// Add extent if needed
if (extent != null && !extent.equals(Extent.ALL_CONTENT)) {
headers.put(extent.getHeaderName(), extent.toString());
}
// Sign request
signRequest("GET", resource, null, headers);
HttpResponse response = restGet( u, headers );
handleError( response );
// The requested content is in the response body.
byte[] data = readStream( response.getEntity().getContent(),
(int) response.getEntity().getContentLength() );
finishRequest( response );
// See if a checksum was returned.
Header checksumHeader = response.getFirstHeader("x-emc-wschecksum");
if( checksumHeader != null && checksum != null ) {
String checksumStr = checksumHeader.getValue();
l4j.debug( "Checksum header: " + checksumStr );
checksum.setExpectedValue( checksumStr );
if( response.getEntity().getContentLength() != -1 ) {
checksum.update( data, 0, (int)response.getEntity().getContentLength() );
} else {
checksum.update( data, 0, data.length );
}
}
return data;
} catch (MalformedURLException e) {
throw new EsuException("Invalid URL", e);
} catch (IOException e) {
throw new EsuException("Error connecting to server", e);
} catch (GeneralSecurityException e) {
throw new EsuException("Error computing request signature", e);
} catch (URISyntaxException e) {
throw new EsuException("Invalid URL", e);
}
}
/**
* Reads an object's content and returns an InputStream to read the content.
* Since the input stream is linked to the HTTP connection, it is imperative
* that you close the input stream as soon as you are done with the stream
* to release the underlying connection.
*
* @param id the identifier of the object whose content to read.
* @param extent the portion of the object data to read. Optional. Default
* is null to read the entire object.
* @return an InputStream to read the object data.
*/
public InputStream readObjectStream(Identifier id, Extent extent) {
try {
String resource = getResourcePath(context, id);
URL u = buildUrl(resource, null);
// Build headers
Map headers = new HashMap();
headers.put("x-emc-uid", uid);
// Add date
headers.put("Date", getDateHeader());
// Add extent if needed
if (extent != null && !extent.equals(Extent.ALL_CONTENT)) {
headers.put(extent.getHeaderName(), extent.toString());
}
// Sign request
signRequest("GET", resource, null, headers);
HttpResponse response = restGet( u, headers );
handleError( response );
return new CommonsInputStreamWrapper( response );
} catch (MalformedURLException e) {
throw new EsuException("Invalid URL", e);
} catch (IOException e) {
throw new EsuException("Error connecting to server", e);
} catch (GeneralSecurityException e) {
throw new EsuException("Error computing request signature", e);
} catch (URISyntaxException e) {
throw new EsuException("Invalid URL", e);
}
}
/**
* Updates an object in the cloud and optionally its metadata and ACL.
*
* @param id The ID of the object to update
* @param acl Access control list for the new object. Optional, default is
* NULL to leave the ACL unchanged.
* @param metadata Metadata list for the new object. Optional, default is
* NULL for no changes to the metadata.
* @param data The new contents of the object. May be appended to later.
* Optional, default is NULL (no content changes).
* @param extent portion of the object to update. May be null to indicate
* the whole object is to be replaced. If not null, the extent
* size must match the data size.
* @param mimeType the MIME type of the content. Optional, may be null. If
* data is non-null and mimeType is null, the MIME type will
* default to application/octet-stream.
* @param checksum if not null, use the Checksum object to compute
* the checksum for the update object request. If appending
* to the object with subsequent requests, use the same
* checksum object for each request.
* @throws EsuException if the request fails.
*/
public void updateObjectFromSegment(Identifier id, Acl acl,
MetadataList metadata, Extent extent, BufferSegment data,
String mimeType, Checksum checksum) {
try {
String resource = getResourcePath(context, id);
URL u = buildUrl(resource, null);
// Build headers
Map headers = new HashMap();
// Figure out the mimetype
if (mimeType == null) {
mimeType = "application/octet-stream";
}
headers.put("Content-Type", mimeType);
headers.put("x-emc-uid", uid);
// Process metadata
if (metadata != null) {
processMetadata(metadata, headers);
}
l4j.debug("meta " + headers.get("x-emc-meta"));
// Add acl
if (acl != null) {
processAcl(acl, headers);
}
// Add extent if needed
if (extent != null && !extent.equals(Extent.ALL_CONTENT)) {
headers.put(extent.getHeaderName(), extent.toString());
}
// Process data
if (data == null) {
data = new BufferSegment(new byte[0]);
}
// Add date
headers.put("Date", getDateHeader());
// Compute checksum
if( checksum != null ) {
checksum.update( data.getBuffer(), data.getOffset(), data.getSize() );
headers.put( "x-emc-wschecksum", checksum.toString() );
}
// Sign request
signRequest("PUT", resource, null, headers);
HttpResponse response = restPut( u, headers, data );
handleError( response );
finishRequest( response );
} catch (MalformedURLException e) {
throw new EsuException("Invalid URL", e);
} catch (IOException e) {
throw new EsuException("Error connecting to server", e);
} catch (GeneralSecurityException e) {
throw new EsuException("Error computing request signature", e);
} catch (URISyntaxException e) {
throw new EsuException("Invalid URL", e);
}
}
/**
* Updates an object in the cloud.
*
* @param id The ID of the object to update
* @param acl Access control list for the new object. Optional, default is
* NULL to leave the ACL unchanged.
* @param metadata Metadata list for the new object. Optional, default is
* NULL for no changes to the metadata.
* @param data The updated data to apply to the object. Requred. Note that
* the input stream is NOT closed at the end of the request.
* @param extent portion of the object to update. May be null to indicate
* the whole object is to be replaced. If not null, the extent
* size must match the data size.
* @param length The length of the stream in bytes. If the stream is longer
* than the length, only length bytes will be written. If the
* stream is shorter than the length, an error will occur.
* @param mimeType the MIME type of the content. Optional, may be null. If
* data is non-null and mimeType is null, the MIME type will
* default to application/octet-stream.
* @throws EsuException if the request fails.
*/
public void updateObjectFromStream(Identifier id, Acl acl,
MetadataList metadata, Extent extent, InputStream data, long length,
String mimeType) {
try {
String resource = getResourcePath(context, id);
URL u = buildUrl(resource, null);
// Build headers
Map headers = new HashMap();
// Figure out the mimetype
if (mimeType == null) {
mimeType = "application/octet-stream";
}
headers.put("Content-Type", mimeType);
headers.put("x-emc-uid", uid);
// Process metadata
if (metadata != null) {
processMetadata(metadata, headers);
}
l4j.debug("meta " + headers.get("x-emc-meta"));
// Add acl
if (acl != null) {
processAcl(acl, headers);
}
// Add extent if needed
if (extent != null && !extent.equals(Extent.ALL_CONTENT)) {
headers.put(extent.getHeaderName(), extent.toString());
}
// Add date
headers.put("Date", getDateHeader());
// Sign request
signRequest("PUT", resource, null, headers);
HttpResponse response = restPut( u, headers, data, length );
handleError( response );
finishRequest( response );
} catch (MalformedURLException e) {
throw new EsuException("Invalid URL", e);
} catch (IOException e) {
throw new EsuException("Error connecting to server", e);
} catch (GeneralSecurityException e) {
throw new EsuException("Error computing request signature", e);
} catch (URISyntaxException e) {
throw new EsuException("Invalid URL", e);
}
}
/**
* Writes the metadata into the object. If the tag does not exist, it is
* created and set to the corresponding value. If the tag exists, the
* existing value is replaced.
*
* @param id the identifier of the object to update
* @param metadata metadata to write to the object.
*/
public void setUserMetadata(Identifier id, MetadataList metadata) {
try {
String resource = getResourcePath(context, id);
String query = "metadata/user";
URL u = buildUrl(resource, query);
// Build headers
Map headers = new HashMap();
headers.put("x-emc-uid", uid);
// Process metadata
if (metadata != null) {
processMetadata(metadata, headers);
}
// Add date
headers.put("Date", getDateHeader());
// Sign request
signRequest("POST", resource, query, headers);
HttpResponse response = restPost( u, headers, null );
handleError( response );
finishRequest( response );
} catch (MalformedURLException e) {
throw new EsuException("Invalid URL", e);
} catch (IOException e) {
throw new EsuException("Error connecting to server", e);
} catch (GeneralSecurityException e) {
throw new EsuException("Error computing request signature", e);
} catch (URISyntaxException e) {
throw new EsuException("Invalid URL", e);
}
}
/**
* Sets (overwrites) the ACL on the object.
*
* @param id the identifier of the object to change the ACL on.
* @param acl the new ACL for the object.
*/
public void setAcl(Identifier id, Acl acl) {
try {
String resource = getResourcePath(context, id);
String query = "acl";
URL u = buildUrl(resource, query);
// Build headers
Map headers = new HashMap();
headers.put("x-emc-uid", uid);
// Add acl
if (acl != null) {
processAcl(acl, headers);
}
// Add date
headers.put("Date", getDateHeader());
// Sign request
signRequest("POST", resource, query, headers);
HttpResponse response = restPost( u, headers, null );
handleError( response );
finishRequest( response );
} catch (MalformedURLException e) {
throw new EsuException("Invalid URL", e);
} catch (IOException e) {
throw new EsuException("Error connecting to server", e);
} catch (GeneralSecurityException e) {
throw new EsuException("Error computing request signature", e);
} catch (URISyntaxException e) {
throw new EsuException("Invalid URL", e);
}
}
/**
* Creates a new immutable version of an object.
*
* @param id the object to version
* @return the id of the newly created version
*/
public ObjectId versionObject(Identifier id) {
try {
String resource = getResourcePath(context, id);
String query = "versions";
URL u = buildUrl(resource, query);
// Build headers
Map headers = new HashMap();
headers.put("x-emc-uid", uid);
// Add date
headers.put("Date", getDateHeader());
// Sign request
signRequest("POST", resource, query, headers);
HttpResponse response = restPost( u, headers, null );
handleError( response );
// The new object ID is returned in the location response header
String location = response.getFirstHeader("location").getValue();
finishRequest( response );
// Parse the value out of the URL
return getObjectId( location );
} catch (MalformedURLException e) {
throw new EsuException("Invalid URL", e);
} catch (IOException e) {
throw new EsuException("Error connecting to server", e);
} catch (GeneralSecurityException e) {
throw new EsuException("Error computing request signature", e);
} catch (URISyntaxException e) {
throw new EsuException("Invalid URL", e);
}
}
/**
* Lists the contents of a directory.
*
* @param path the path to list. Must be a directory.
* @return the directory entries in the directory.
*/
public List listDirectory(ObjectPath path,
ListOptions options) {
if (!path.isDirectory()) {
throw new EsuException(
"listDirectory must be called with a directory path");
}
// Read out the directory's contents
byte[] data = null;
try {
String resource = getResourcePath(context, path);
URL u = buildUrl(resource, null);
// Build headers
Map headers = new HashMap();
headers.put("x-emc-uid", uid);
// Process options
if( options != null ) {
if( options.isIncludeMetadata() ) {
headers.put( "x-emc-include-meta", "1" );
if( options.getSystemMetadata() != null ) {
headers.put( "x-emc-system-tags",
join( options.getSystemMetadata(), "," ) );
}
if( options.getUserMetadata() != null ) {
headers.put( "x-emc-user-tags",
join( options.getUserMetadata(), "," ) );
}
}
if( options.getLimit() > 0 ) {
headers.put( "x-emc-limit", ""+options.getLimit() );
}
if( options.getToken() != null ) {
headers.put( "x-emc-token", options.getToken() );
}
}
// Add date
headers.put("Date", getDateHeader());
// Sign request
signRequest("GET", resource, null, headers);
HttpResponse response = restGet( u, headers );
handleError( response );
if( options != null ) {
// Update the token for listing more results. If there are no
// more results, the header will not be set and the token will
// be cleared in the options object.
Header token = response.getFirstHeader("x-emc-token");
if( token != null ) {
options.setToken( token.getValue() );
} else {
options.setToken( null );
}
} else {
Header token = response.getFirstHeader("x-emc-token");
if( token != null ) {
l4j.warn( "Result set truncated. Use ListOptions to " +
"retrieve token for next page of results." );
}
}
// The requested content is in the response body.
data = readStream( response.getEntity().getContent(),
(int) response.getEntity().getContentLength() );
finishRequest( response );
} catch (MalformedURLException e) {
throw new EsuException("Invalid URL", e);
} catch (IOException e) {
throw new EsuException("Error connecting to server", e);
} catch (GeneralSecurityException e) {
throw new EsuException("Error computing request signature", e);
} catch (URISyntaxException e) {
throw new EsuException("Invalid URL", e);
}
return parseDirectoryListing( data, path );
}
public ObjectMetadata getAllMetadata(Identifier id) {
try {
String resource = getResourcePath(context, id);
URL u = buildUrl(resource, null);
// Build headers
Map headers = new HashMap();
headers.put("x-emc-uid", uid);
if(unicodeEnabled) {
headers.put("x-emc-utf8", "true");
}
// Add date
headers.put("Date", getDateHeader());
// Sign request
signRequest("HEAD", resource, null, headers);
HttpResponse response = restHead( u, headers );
handleError( response );
// Parse return headers. User grants are in x-emc-useracl and
// group grants are in x-emc-groupacl
Acl acl = new Acl();
readAcl(acl, response.getFirstHeader("x-emc-useracl").getValue(),
Grantee.GRANT_TYPE.USER);
readAcl(acl, response.getFirstHeader("x-emc-groupacl").getValue(),
Grantee.GRANT_TYPE.GROUP);
// Parse return headers. Regular metadata is in x-emc-meta and
// listable metadata is in x-emc-listable-meta
MetadataList meta = new MetadataList();
readMetadata(meta, response.getFirstHeader("x-emc-meta"), false);
readMetadata(meta, response.getFirstHeader("x-emc-listable-meta"), true);
ObjectMetadata om = new ObjectMetadata();
om.setAcl(acl);
om.setMetadata(meta);
om.setMimeType(response.getFirstHeader( "Content-Type").getValue());
finishRequest( response );
return om;
} catch (MalformedURLException e) {
throw new EsuException("Invalid URL", e);
} catch (IOException e) {
throw new EsuException("Error connecting to server", e);
} catch (GeneralSecurityException e) {
throw new EsuException("Error computing request signature", e);
} catch (URISyntaxException e) {
throw new EsuException("Invalid URL", e);
}
}
public ServiceInformation getServiceInformation() {
try {
String resource = context + "/service";
URL u = buildUrl(resource, null);
// Build headers
Map headers = new HashMap();
headers.put("x-emc-uid", uid);
// Add date
headers.put("Date", getDateHeader());
// Sign request
signRequest("GET", resource, null, headers);
HttpResponse response = restGet( u, headers );
handleError( response );
// Get object id list from response
byte[] data = readStream( response.getEntity().getContent(),
(int) response.getEntity().getContentLength() );
if( l4j.isDebugEnabled() ) {
l4j.debug("Response: " + new String(data, "UTF-8"));
}
finishRequest( response );
Map> rHeaders = getResponseHeaders(response);
return parseServiceInformation(data, rHeaders);
} catch (MalformedURLException e) {
throw new EsuException("Invalid URL", e);
} catch (IOException e) {
throw new EsuException("Error connecting to server", e);
} catch (GeneralSecurityException e) {
throw new EsuException("Error computing request signature", e);
} catch (URISyntaxException e) {
throw new EsuException("Invalid URL", e);
}
}
/**
* Renames a file or directory within the namespace.
* @param source The file or directory to rename
* @param destination The new path for the file or directory
* @param force If true, the desination file or
* directory will be overwritten. Directories must be empty to be
* overwritten. Also note that overwrite operations on files are
* not synchronous; a delay may be required before the object is
* available at its destination.
*/
public void rename(ObjectPath source, ObjectPath destination, boolean force) {
try {
String resource = getResourcePath(context, source);
String query = "rename";
URL u = buildUrl(resource, query);
// Build headers
Map headers = new HashMap();
headers.put("x-emc-uid", uid);
if(unicodeEnabled) {
headers.put("x-emc-utf8", "true");
}
String destPath = destination.toString();
if (destPath.startsWith("/"))
{
destPath = destPath.substring(1);
}
headers.put("x-emc-path", unicodeEnabled ? encodeUtf8(destPath) : destPath);
if (force) {
headers.put("x-emc-force", "true");
}
// Add date
headers.put("Date", getDateHeader());
// Sign request
signRequest("POST", resource, query, headers);
HttpResponse response = restPost( u, headers, null );
handleError( response );
finishRequest( response );
} catch (MalformedURLException e) {
throw new EsuException("Invalid URL", e);
} catch (IOException e) {
throw new EsuException("Error connecting to server", e);
} catch (GeneralSecurityException e) {
throw new EsuException("Error computing request signature", e);
} catch (URISyntaxException e) {
throw new EsuException("Invalid URL", e);
}
}
/**
* Restores a version of an object to the base version (i.e. "promote" an
* old version to the current version).
* @param id Base object ID (target of the restore)
* @param vId Version object ID to restore
*/
public void restoreVersion( ObjectId id, ObjectId vId ) {
try {
String resource = getResourcePath(context, id);
String query = "versions";
URL u = buildUrl(resource, query);
// Build headers
Map headers = new HashMap();
headers.put("x-emc-uid", uid);
// Version to promote
headers.put("x-emc-version-oid", vId.toString());
// Add date
headers.put("Date", getDateHeader());
// Sign request
signRequest("PUT", resource, query, headers);
HttpResponse response = restPut( u, headers, null );
handleError( response );
cleanup( response );
} catch (MalformedURLException e) {
throw new EsuException("Invalid URL", e);
} catch (IOException e) {
throw new EsuException("Error connecting to server", e);
} catch (GeneralSecurityException e) {
throw new EsuException("Error computing request signature", e);
} catch (URISyntaxException e) {
throw new EsuException("Invalid URL", e);
}
}
/**
* Get information about an object's state including
* replicas, expiration, and retention.
* @param id the object identifier
* @return and ObjectInfo object containing the state information
*/
public ObjectInfo getObjectInfo( Identifier id ) {
try {
String resource = getResourcePath(context, id);
String query = "info";
URL u = buildUrl(resource, query);
// Build headers
Map headers = new HashMap();
headers.put("x-emc-uid", uid);
// Add date
headers.put("Date", getDateHeader());
// Sign request
signRequest("GET", resource, query, headers);
HttpResponse response = restGet( u, headers );
handleError( response );
// Get object id list from response
byte[] data = readStream( response.getEntity().getContent(),
(int) response.getEntity().getContentLength() );
String responseXml = new String(data, "UTF-8");
if( l4j.isDebugEnabled() ) {
l4j.debug("Response: " + responseXml);
}
finishRequest( response );
return new ObjectInfo(responseXml);
} catch (MalformedURLException e) {
throw new EsuException("Invalid URL", e);
} catch (IOException e) {
throw new EsuException("Error connecting to server", e);
} catch (GeneralSecurityException e) {
throw new EsuException("Error computing request signature", e);
} catch (URISyntaxException e) {
throw new EsuException("Invalid URL", e);
}
}
@Override
public long calculateServerOffset() {
try {
String resource = context + "/service";
URL u = buildUrl(resource, null);
// Build headers
Map headers = new HashMap();
headers.put("x-emc-uid", uid);
// Add date
headers.put("Date", getDateHeader());
// Sign request
signRequest("GET", resource, null, headers);
HttpResponse response = restGet( u, headers );
Header responseDate = response.getFirstHeader(HttpHeaders.DATE);
if(responseDate == null) {
throw new EsuException("Could not get date from response: " +
response.getStatusLine().getStatusCode() + ": " +
response.getStatusLine().getReasonPhrase());
}
Date serverDate = null;
try {
serverDate = DateUtils.parseDate(responseDate.getValue());
} catch (DateParseException e) {
throw new EsuException("Failed to parse date: " + responseDate.getValue(), e);
}
return System.currentTimeMillis() - serverDate.getTime();
} catch (MalformedURLException e) {
throw new EsuException("Invalid URL", e);
} catch (IOException e) {
throw new EsuException("Error connecting to server", e);
} catch (GeneralSecurityException e) {
throw new EsuException("Error computing request signature", e);
} catch (URISyntaxException e) {
throw new EsuException("Invalid URL", e);
}
}
/////////////////////
// Private Methods //
/////////////////////
private void handleError(HttpResponse resp) {
StatusLine status = resp.getStatusLine();
if( status.getStatusCode() > 299 ) {
try {
HttpEntity body = resp.getEntity();
if( body == null ) {
throw new EsuException( status.getReasonPhrase(), status.getStatusCode() );
}
byte[] response = readStream( body.getContent(), (int) body.getContentLength() );
l4j.debug("Error response: " + new String(response, "UTF-8"));
SAXBuilder sb = new SAXBuilder();
Document d = sb.build(new ByteArrayInputStream(response));
String code = d.getRootElement().getChildText("Code");
String message = d.getRootElement().getChildText("Message");
if (code == null && message == null) {
// not an error from ESU
throw new EsuException( status.getReasonPhrase(), status.getStatusCode() );
}
l4j.debug("Error: " + code + " message: " + message);
throw new EsuException(message, status.getStatusCode(), Integer.parseInt(code));
} catch (IOException e) {
l4j.debug("Could not read error response body", e);
// Just throw what we know from the response
throw new EsuException(status.getReasonPhrase(), status.getStatusCode());
} catch (JDOMException e) {
l4j.debug("Could not parse response body for " + status.getStatusCode()
+ ": " + status.getReasonPhrase(), e);
throw new EsuException("Could not parse response body for "
+ status.getStatusCode() + ": " + status.getReasonPhrase(), e,
status.getStatusCode());
} finally {
if( resp.getEntity() != null ) {
try {
EntityUtils.consume( resp.getEntity() );
} catch (IOException e) {
l4j.warn( "Error finishing error response", e );
}
}
}
}
}
private HttpResponse restPost( URL url, Map headers, InputStream in, long contentLength ) throws URISyntaxException, ClientProtocolException, IOException {
HttpPost post = new HttpPost( url.toURI() );
setHeaders( post, headers );
if( in != null ) {
post.setEntity( new InputStreamEntity( in, contentLength ) );
} else {
post.setEntity( new ByteArrayEntity( new byte[0] ) );
}
return httpClient.execute( post );
}
private HttpResponse restPost( URL url, Map headers, BufferSegment data ) throws URISyntaxException, ClientProtocolException, IOException {
HttpPost post = new HttpPost( url.toURI() );
setHeaders( post, headers );
if( data != null ) {
if( data.getOffset() == 0 && (data.getSize() == data.getBuffer().length ) ) {
// use the native byte array
post.setEntity( new ByteArrayEntity( data.getBuffer() ) );
} else {
post.setEntity( new InputStreamEntity(
new ByteArrayInputStream(data.getBuffer(), data.getOffset(), data.getSize()),
data.getSize() ) );
}
} else {
post.setEntity( new ByteArrayEntity( new byte[0] ) );
}
return httpClient.execute( post );
}
private HttpResponse restDelete(URL url, Map headers) throws URISyntaxException, ClientProtocolException, IOException {
HttpDelete delete = new HttpDelete( url.toURI() );
setHeaders(delete, headers);
return httpClient.execute( delete );
}
private HttpResponse restGet(URL url, Map headers) throws URISyntaxException, ClientProtocolException, IOException {
HttpGet get = new HttpGet( url.toURI() );
setHeaders(get, headers);
return httpClient.execute( get );
}
private HttpResponse restPut(URL url, Map headers,
BufferSegment data) throws ClientProtocolException, IOException, URISyntaxException {
HttpPut put = new HttpPut( url.toURI() );
setHeaders( put, headers );
if( data != null ) {
if( data.getOffset() == 0 && (data.getSize() == data.getBuffer().length ) ) {
// use the native byte array
put.setEntity( new ByteArrayEntity( data.getBuffer() ) );
} else {
put.setEntity( new InputStreamEntity(
new ByteArrayInputStream(data.getBuffer(), data.getOffset(), data.getSize()),
data.getSize() ) );
}
} else {
put.setEntity( new ByteArrayEntity( new byte[0] ) );
}
return httpClient.execute( put );
}
private HttpResponse restPut(URL url, Map headers,
InputStream in, long contentLength) throws URISyntaxException, ClientProtocolException, IOException {
HttpPut put = new HttpPut( url.toURI() );
setHeaders( put, headers );
if( in != null ) {
put.setEntity( new InputStreamEntity( in, contentLength ) );
} else {
put.setEntity( new ByteArrayEntity( new byte[0] ) );
}
return httpClient.execute( put );
}
private HttpResponse restHead(URL url, Map headers) throws URISyntaxException, ClientProtocolException, IOException {
HttpHead head = new HttpHead( url.toURI() );
setHeaders( head, headers );
return httpClient.execute( head );
}
private void setHeaders( AbstractHttpMessage request, Map headers ) {
for( String headerName : headers.keySet() ) {
request.addHeader( headerName, headers.get( headerName ) );
}
}
private void finishRequest(HttpResponse response) throws IOException {
if( response.getEntity() != null ) {
cleanup( response );
}
}
private void readMetadata(MetadataList meta, Header firstHeader,
boolean listable) throws UnsupportedEncodingException {
if( firstHeader != null ) {
super.readMetadata(meta, firstHeader.getValue(), listable );
}
}
private void cleanup( HttpResponse response ) throws IOException {
if( response.getEntity() != null ) {
EntityUtils.consume( response.getEntity() );
}
}
/**
* Generates the HMAC-SHA1 signature used to authenticate the request using
* the Java security APIs.
*
* @param method the HTTP method used
* @param resource the resource path
* @param query the URL querystring (if present)
* @param headers the HTTP headers for the request
* @throws IOException if character data cannot be encoded.
* @throws GeneralSecurityException If errors occur generating the HMAC-SHA1
* signature.
*/
private void signRequest(String method, String resource, String query, Map headers) throws IOException,
GeneralSecurityException {
// Build the string to hash.
StringBuffer hashStr = new StringBuffer();
hashStr.append(method + "\n");
// If content type exists, add it. Otherwise add a blank line.
if (headers.containsKey("Content-Type")) {
l4j.debug("Content-Type: " + headers.get("Content-Type"));
hashStr.append(headers.get("Content-Type") + "\n");
} else {
hashStr.append("\n");
}
// If the range header exists, add it. Otherwise add a blank line.
if (headers.containsKey("Range")) {
hashStr.append(headers.get("Range") + "\n");
} else if (headers.containsKey("Content-Range")) {
hashStr.append(headers.get("Content-Range") + "\n");
} else {
hashStr.append("\n");
}
// Add the current date and the resource.
hashStr.append(headers.get("Date") + "\n" );
hashStr.append( resource.toLowerCase() );
if ( query != null) {
hashStr.append("?" + query + "\n");
} else {
hashStr.append("\n");
}
// Do the 'x-emc' headers. The headers must be hashed in alphabetic
// order and the values must be stripped of whitespace and newlines.
List keys = new ArrayList();
Map newheaders = new HashMap();
// Extract the keys and values
for (Iterator i = headers.keySet().iterator(); i.hasNext();) {
String key = i.next();
if (key.indexOf("x-emc") == 0) {
keys.add(key.toLowerCase());
newheaders.put(key.toLowerCase(), headers.get(key).replace(
"\n", ""));
}
}
// Sort the keys and add the headers to the hash string.
Collections.sort(keys);
boolean first = true;
for (Iterator i = keys.iterator(); i.hasNext();) {
String key = i.next();
if (!first) {
hashStr.append("\n");
} else {
first = false;
}
// this.trace( "xheader: " . k . "." . newheaders[k] );
hashStr.append(key + ':' + normalizeSpace(newheaders.get(key)));
}
String hashOut = sign(hashStr.toString());
headers.put( "x-emc-signature", hashOut );
}
/**
* Extracts the values of the response headers into a Map>
* @param response the HttpResponse to parse.
*/
private Map> getResponseHeaders(HttpResponse response) {
Map> rHeaders = new HashMap>();
Header[] headers = response.getAllHeaders();
for(Header h : headers) {
String name = h.getName();
String value = h.getValue();
List hValues = null;
if(rHeaders.containsKey(name)) {
hValues = rHeaders.get(name);
} else {
hValues = new ArrayList();
rHeaders.put(name, hValues);
}
hValues.add(value);
}
return Collections.unmodifiableMap(rHeaders);
}
//---------- Features supported by the Atmos 2.0 REST API. ----------\\
@Override
public ObjectId createObjectWithKeyFromSegment( String keyPool, String key, Acl acl, MetadataList metadata,
BufferSegment data, String mimeType, Checksum checksum ) {
try {
String resource = context + "/namespace/" + key;
URL u = buildUrl(resource, null);
// Build headers
Map headers = new HashMap();
// Figure out the mimetype
if (mimeType == null) {
mimeType = "application/octet-stream";
}
headers.put("Content-Type", mimeType);
headers.put("x-emc-uid", uid);
headers.put("x-emc-pool", keyPool);
// Process metadata
if (metadata != null) {
processMetadata(metadata, headers);
}
l4j.debug("meta " + headers.get("x-emc-meta"));
// Add acl
if (acl != null) {
processAcl(acl, headers);
}
// Process data
if (data == null) {
data = new BufferSegment(new byte[0]);
}
// Add date
headers.put("Date", getDateHeader());
// Compute checksum
if( checksum != null ) {
checksum.update( data.getBuffer(), data.getOffset(), data.getSize() );
headers.put( "x-emc-wschecksum", checksum.toString() );
}
// Sign request
signRequest("POST", resource, null, headers);
HttpResponse response = restPost( u, headers, data );
// Check response
handleError( response );
// The new object ID is returned in the location response header
String location = response.getFirstHeader("location").getValue();
// Cleanup the connection
cleanup( response );
// Parse the value out of the URL
return getObjectId( location );
} catch (MalformedURLException e) {
throw new EsuException("Invalid URL", e);
} catch (IOException e) {
throw new EsuException("Error connecting to server", e);
} catch (GeneralSecurityException e) {
throw new EsuException("Error computing request signature", e);
} catch (URISyntaxException e) {
throw new EsuException("Invalid URL", e);
}
}
@Override
public void hardLink( ObjectPath source, ObjectPath target ) {
try {
String resource = getResourcePath( context, source );
String query = "hardlink";
URL u = buildUrl( resource, query );
// Build headers
Map headers = new HashMap();
headers.put( "x-emc-uid", uid );
String destPath = target.toString();
if ( destPath.startsWith( "/" ) ) {
destPath = destPath.substring( 1 );
}
headers.put( "x-emc-path", destPath );
// Add date
headers.put( "Date", getDateHeader() );
// Compute checksum
// Sign request
signRequest( "POST", resource, query, headers );
HttpResponse response = restPost( u, headers, null );
// Check response
handleError( response );
// Cleanup the connection
cleanup( response );
} catch ( MalformedURLException e ) {
throw new EsuException( "Invalid URL", e );
} catch ( IOException e ) {
throw new EsuException( "Error connecting to server", e );
} catch ( GeneralSecurityException e ) {
throw new EsuException( "Error computing request signature", e );
} catch ( URISyntaxException e ) {
throw new EsuException( "Invalid URL", e );
}
}
@Override
public ObjectId createObjectWithKeyFromStream( String keyPool, String key, Acl acl, MetadataList metadata,
InputStream data, long length, String mimeType ) {
try {
String resource = context + "/namespace/" + key;
URL u = buildUrl(resource, null);
if (data == null) {
throw new IllegalArgumentException("Input stream is required");
}
// Build headers
Map headers = new HashMap();
// Figure out the mimetype
if (mimeType == null) {
mimeType = "application/octet-stream";
}
headers.put("Content-Type", mimeType);
headers.put("x-emc-uid", uid);
headers.put("x-emc-pool", keyPool);
// Process metadata
if (metadata != null) {
processMetadata(metadata, headers);
}
l4j.debug("meta " + headers.get("x-emc-meta"));
// Add acl
if (acl != null) {
processAcl(acl, headers);
}
// Add date
headers.put("Date", getDateHeader());
// Sign request
signRequest("POST", resource, null, headers);
HttpResponse response = restPost( u, headers, data, length );
// Check response
handleError( response );
// The new object ID is returned in the location response header
String location = response.getFirstHeader("location").getValue();
// Cleanup the connection
cleanup( response );
// Parse the value out of the URL
return getObjectId( location );
} catch (MalformedURLException e) {
throw new EsuException("Invalid URL", e);
} catch (IOException e) {
throw new EsuException("Error connecting to server", e);
} catch (GeneralSecurityException e) {
throw new EsuException("Error computing request signature", e);
} catch (URISyntaxException e) {
throw new EsuException("Invalid URL", e);
}
}
@Override
public void deleteObjectWithKey( String keyPool, String key ) {
try {
String resource = context + "/namespace/" + key;
URL u = buildUrl(resource, null);
// Build headers
Map headers = new HashMap();
headers.put("x-emc-uid", uid);
headers.put("x-emc-pool", keyPool);
// Add date
headers.put("Date", getDateHeader());
// Sign request
signRequest("DELETE", resource, null, headers);
HttpResponse response = restDelete( u, headers );
handleError( response );
cleanup( response );
} catch (MalformedURLException e) {
throw new EsuException("Invalid URL", e);
} catch (IOException e) {
throw new EsuException("Error connecting to server", e);
} catch (GeneralSecurityException e) {
throw new EsuException("Error computing request signature", e);
} catch (URISyntaxException e) {
throw new EsuException("Invalid URL", e);
}
}
@Override
public ObjectMetadata getAllMetadata( String keyPool, String key ) {
try {
String resource = context + "/namespace/" + key;
URL u = buildUrl(resource, null);
// Build headers
Map headers = new HashMap();
headers.put("x-emc-uid", uid);
headers.put("x-emc-pool", keyPool);
if(unicodeEnabled) {
headers.put("x-emc-utf8", "true");
}
// Add date
headers.put("Date", getDateHeader());
// Sign request
signRequest("HEAD", resource, null, headers);
HttpResponse response = restHead( u, headers );
handleError( response );
// Parse return headers. User grants are in x-emc-useracl and
// group grants are in x-emc-groupacl
Acl acl = new Acl();
readAcl(acl, response.getFirstHeader("x-emc-useracl").getValue(),
Grantee.GRANT_TYPE.USER);
readAcl(acl, response.getFirstHeader("x-emc-groupacl").getValue(),
Grantee.GRANT_TYPE.GROUP);
// Parse return headers. Regular metadata is in x-emc-meta and
// listable metadata is in x-emc-listable-meta
MetadataList meta = new MetadataList();
readMetadata(meta, response.getFirstHeader("x-emc-meta"), false);
readMetadata(meta, response.getFirstHeader("x-emc-listable-meta"), true);
ObjectMetadata om = new ObjectMetadata();
om.setAcl(acl);
om.setMetadata(meta);
om.setMimeType(response.getFirstHeader( "Content-Type").getValue());
finishRequest( response );
return om;
} catch (MalformedURLException e) {
throw new EsuException("Invalid URL", e);
} catch (IOException e) {
throw new EsuException("Error connecting to server", e);
} catch (GeneralSecurityException e) {
throw new EsuException("Error computing request signature", e);
} catch (URISyntaxException e) {
throw new EsuException("Invalid URL", e);
}
}
@Override
public MetadataList getSystemMetadata( String keyPool, String key, MetadataTags tags ) {
try {
String resource = context + "/namespace/" + key;
String query = "metadata/system";
URL u = buildUrl(resource, query);
// Build headers
Map headers = new HashMap();
headers.put("x-emc-uid", uid);
headers.put("x-emc-pool", keyPool);
// process tags
if (tags != null) {
processTags(tags, headers);
}
// Add date
headers.put("Date", getDateHeader());
// Sign request
signRequest("GET", resource, query, headers);
HttpResponse response = restGet( u, headers );
handleError( response );
// Parse return headers. Regular metadata is in x-emc-meta and
// listable metadata is in x-emc-listable-meta
MetadataList meta = new MetadataList();
readMetadata(meta, response.getFirstHeader("x-emc-meta"), false);
readMetadata(meta, response.getFirstHeader("x-emc-listable-meta"), true);
finishRequest( response );
return meta;
} catch (MalformedURLException e) {
throw new EsuException("Invalid URL", e);
} catch (IOException e) {
throw new EsuException("Error connecting to server", e);
} catch (GeneralSecurityException e) {
throw new EsuException("Error computing request signature", e);
} catch (URISyntaxException e) {
throw new EsuException("Invalid URL", e);
}
}
@Override
public byte[] readObjectWithKey( String keyPool, String key, Extent extent, byte[] buffer, Checksum checksum ) {
try {
String resource = context + "/namespace/" + key;
URL u = buildUrl(resource, null);
// Build headers
Map headers = new HashMap();
headers.put("x-emc-uid", uid);
headers.put("x-emc-pool", keyPool);
// Add date
headers.put("Date", getDateHeader());
// Add extent if needed
if (extent != null && !extent.equals(Extent.ALL_CONTENT)) {
headers.put(extent.getHeaderName(), extent.toString());
}
// Sign request
signRequest("GET", resource, null, headers);
HttpResponse response = restGet( u, headers );
handleError( response );
// The requested content is in the response body.
byte[] data = readStream( response.getEntity().getContent(),
(int) response.getEntity().getContentLength() );
finishRequest( response );
// See if a checksum was returned.
Header checksumHeader = response.getFirstHeader("x-emc-wschecksum");
if( checksumHeader != null && checksum != null ) {
String checksumStr = checksumHeader.getValue();
l4j.debug( "Checksum header: " + checksumStr );
checksum.setExpectedValue( checksumStr );
if( response.getEntity().getContentLength() != -1 ) {
checksum.update( data, 0, (int)response.getEntity().getContentLength() );
} else {
checksum.update( data, 0, data.length );
}
}
return data;
} catch (MalformedURLException e) {
throw new EsuException("Invalid URL", e);
} catch (IOException e) {
throw new EsuException("Error connecting to server", e);
} catch (GeneralSecurityException e) {
throw new EsuException("Error computing request signature", e);
} catch (URISyntaxException e) {
throw new EsuException("Invalid URL", e);
}
}
@Override
public InputStream readObjectStreamWithKey( String keyPool, String key, Extent extent ) {
try {
String resource = context + "/namespace/" + key;
URL u = buildUrl(resource, null);
// Build headers
Map headers = new HashMap();
headers.put("x-emc-uid", uid);
headers.put("x-emc-pool", keyPool);
// Add date
headers.put("Date", getDateHeader());
// Add extent if needed
if (extent != null && !extent.equals(Extent.ALL_CONTENT)) {
headers.put(extent.getHeaderName(), extent.toString());
}
// Sign request
signRequest("GET", resource, null, headers);
HttpResponse response = restGet( u, headers );
handleError( response );
return new CommonsInputStreamWrapper( response );
} catch (MalformedURLException e) {
throw new EsuException("Invalid URL", e);
} catch (IOException e) {
throw new EsuException("Error connecting to server", e);
} catch (GeneralSecurityException e) {
throw new EsuException("Error computing request signature", e);
} catch (URISyntaxException e) {
throw new EsuException("Invalid URL", e);
}
}
@Override
public void updateObjectWithKeyFromStream( String keyPool, String key, Acl acl, MetadataList metadata,
Extent extent, InputStream data, long length, String mimeType ) {
try {
String resource = context + "/namespace/" + key;
URL u = buildUrl(resource, null);
// Build headers
Map headers = new HashMap();
// Figure out the mimetype
if (mimeType == null) {
mimeType = "application/octet-stream";
}
headers.put("Content-Type", mimeType);
headers.put("x-emc-uid", uid);
headers.put("x-emc-pool", keyPool);
// Process metadata
if (metadata != null) {
processMetadata(metadata, headers);
}
l4j.debug("meta " + headers.get("x-emc-meta"));
// Add acl
if (acl != null) {
processAcl(acl, headers);
}
// Add extent if needed
if (extent != null && !extent.equals(Extent.ALL_CONTENT)) {
headers.put(extent.getHeaderName(), extent.toString());
}
// Add date
headers.put("Date", getDateHeader());
// Sign request
signRequest("PUT", resource, null, headers);
HttpResponse response = restPut( u, headers, data, length );
handleError( response );
finishRequest( response );
} catch (MalformedURLException e) {
throw new EsuException("Invalid URL", e);
} catch (IOException e) {
throw new EsuException("Error connecting to server", e);
} catch (GeneralSecurityException e) {
throw new EsuException("Error computing request signature", e);
} catch (URISyntaxException e) {
throw new EsuException("Invalid URL", e);
}
}
@Override
public void updateObjectWithKeyFromSegment( String keyPool, String key, Acl acl, MetadataList metadata,
Extent extent, BufferSegment data, String mimeType,
Checksum checksum ) {
try {
String resource = context + "/namespace/" + key;
URL u = buildUrl(resource, null);
// Build headers
Map headers = new HashMap();
// Figure out the mimetype
if (mimeType == null) {
mimeType = "application/octet-stream";
}
headers.put("Content-Type", mimeType);
headers.put("x-emc-uid", uid);
headers.put("x-emc-pool", keyPool);
// Process metadata
if (metadata != null) {
processMetadata(metadata, headers);
}
l4j.debug("meta " + headers.get("x-emc-meta"));
// Add acl
if (acl != null) {
processAcl(acl, headers);
}
// Add extent if needed
if (extent != null && !extent.equals(Extent.ALL_CONTENT)) {
headers.put(extent.getHeaderName(), extent.toString());
}
// Process data
if (data == null) {
data = new BufferSegment(new byte[0]);
}
// Add date
headers.put("Date", getDateHeader());
// Compute checksum
if( checksum != null ) {
checksum.update( data.getBuffer(), data.getOffset(), data.getSize() );
headers.put( "x-emc-wschecksum", checksum.toString() );
}
// Sign request
signRequest("PUT", resource, null, headers);
HttpResponse response = restPut( u, headers, data );
handleError( response );
finishRequest( response );
} catch (MalformedURLException e) {
throw new EsuException("Invalid URL", e);
} catch (IOException e) {
throw new EsuException("Error connecting to server", e);
} catch (GeneralSecurityException e) {
throw new EsuException("Error computing request signature", e);
} catch (URISyntaxException e) {
throw new EsuException("Invalid URL", e);
}
}
}