Java tutorial
/* * 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.atmos.api.jersey; import com.emc.atmos.AtmosException; import com.emc.atmos.api.*; import com.emc.atmos.api.bean.*; import com.emc.atmos.api.request.*; import com.emc.esu.api.Acl; import com.emc.esu.api.BufferSegment; import com.emc.esu.api.*; import com.emc.esu.api.DirectoryEntry; import com.emc.esu.api.Metadata; import com.emc.esu.api.ObjectId; import com.emc.esu.api.ObjectInfo; import com.emc.esu.api.ObjectMetadata; import com.emc.esu.api.ObjectPath; import com.emc.esu.api.ServiceInformation; import com.emc.esu.api.rest.AbstractEsuRestApi; import com.emc.util.StreamUtil; import org.apache.commons.codec.binary.Base64; import javax.xml.bind.JAXBContext; import javax.xml.bind.JAXBException; import javax.xml.bind.Marshaller; import java.io.*; import java.net.URISyntaxException; import java.util.*; public class EsuApiJerseyAdapter extends AbstractEsuRestApi { private JAXBContext jaxbContext; private ThreadLocal<Marshaller> marshaller = new ThreadLocal<Marshaller>(); private AtmosApi adaptee; public EsuApiJerseyAdapter(AtmosConfig config) throws URISyntaxException, UnsupportedEncodingException, JAXBException { super(config.getEndpoints()[0].getHost(), config.getEndpoints()[0].getPort(), config.getTokenId(), new String(Base64.encodeBase64(config.getSecretKey()), "UTF-8")); adaptee = new AtmosApiClient(config); jaxbContext = JAXBContext.newInstance(com.emc.atmos.api.bean.ObjectInfo.class); } @Override public long calculateServerOffset() { return adaptee.calculateServerClockSkew(); } @Override public ObjectId createObjectFromStream(Acl acl, MetadataList metadata, InputStream data, long length, String mimeType) { try { CreateObjectRequest request = new CreateObjectRequest(); request.acl(adaptAcl(acl)).userMetadata(adaptMetadata(metadata)).content(data).contentLength(length) .contentType(mimeType); return (ObjectId) adaptIdentifier(adaptee.createObject(request).getObjectId()); } catch (AtmosException e) { throw adaptException(e); } } @Override public ObjectId createObjectFromStreamOnPath(ObjectPath path, Acl acl, MetadataList metadata, InputStream data, long length, String mimeType) { try { CreateObjectRequest request = new CreateObjectRequest(); request.identifier(adaptIdentifier(path)).acl(adaptAcl(acl)).userMetadata(adaptMetadata(metadata)) .content(data).contentLength(length).contentType(mimeType); return (ObjectId) adaptIdentifier(adaptee.createObject(request).getObjectId()); } catch (AtmosException e) { throw adaptException(e); } } @Override public ObjectId createObjectFromSegment(Acl acl, MetadataList metadata, BufferSegment data, String mimeType, Checksum checksum) { try { CreateObjectRequest request = new CreateObjectRequest(); request.acl(adaptAcl(acl)).userMetadata(adaptMetadata(metadata)).content(adaptBuffer(data)) .contentType(mimeType).wsChecksum(adaptChecksum(checksum, data)); return (ObjectId) adaptIdentifier(adaptee.createObject(request).getObjectId()); } catch (AtmosException e) { throw adaptException(e); } } @Override public ObjectId createObjectFromSegmentOnPath(ObjectPath path, Acl acl, MetadataList metadata, BufferSegment data, String mimeType, Checksum checksum) { try { CreateObjectRequest request = new CreateObjectRequest(); request.identifier(adaptIdentifier(path)).acl(adaptAcl(acl)).userMetadata(adaptMetadata(metadata)) .content(adaptBuffer(data)).contentType(mimeType).wsChecksum(adaptChecksum(checksum, data)); return (ObjectId) adaptIdentifier(adaptee.createObject(request).getObjectId()); } catch (AtmosException e) { throw adaptException(e); } } @Override public void updateObjectFromStream(Identifier id, Acl acl, MetadataList metadata, Extent extent, InputStream data, long length, String mimeType) { try { UpdateObjectRequest request = new UpdateObjectRequest(); request.identifier(adaptIdentifier(id)).acl(adaptAcl(acl)).userMetadata(adaptMetadata(metadata)) .range(adaptExtent(extent)).content(data).contentLength(length).contentType(mimeType); adaptee.updateObject(request); } catch (AtmosException e) { throw adaptException(e); } } @Override public void updateObjectFromSegment(Identifier id, Acl acl, MetadataList metadata, Extent extent, BufferSegment data, String mimeType, Checksum checksum) { try { UpdateObjectRequest request = new UpdateObjectRequest(); request.identifier(adaptIdentifier(id)).acl(adaptAcl(acl)).userMetadata(adaptMetadata(metadata)) .range(adaptExtent(extent)).content(adaptBuffer(data)).contentType(mimeType) .wsChecksum(adaptChecksum(checksum, data)); adaptee.updateObject(request); } catch (AtmosException e) { throw adaptException(e); } } @Override public void setUserMetadata(Identifier id, MetadataList metadata) { try { adaptee.setUserMetadata(adaptIdentifier(id), adaptMetadata(metadata)); } catch (AtmosException e) { throw adaptException(e); } } @Override public void setAcl(Identifier id, Acl acl) { try { adaptee.setAcl(adaptIdentifier(id), adaptAcl(acl)); } catch (AtmosException e) { throw adaptException(e); } } @Override public void deleteObject(Identifier id) { try { adaptee.delete(adaptIdentifier(id)); } catch (AtmosException e) { throw adaptException(e); } } @Override public void deleteVersion(ObjectId id) { try { adaptee.deleteVersion((com.emc.atmos.api.ObjectId) adaptIdentifier(id)); } catch (AtmosException e) { throw adaptException(e); } } @Override public MetadataList getUserMetadata(Identifier id, MetadataTags tags) { try { return adaptMetadata(adaptee.getUserMetadata(adaptIdentifier(id), adaptNames(tags))); } catch (AtmosException e) { throw adaptException(e); } } @Override public MetadataList getSystemMetadata(Identifier id, MetadataTags tags) { try { return adaptMetadata(adaptee.getSystemMetadata(adaptIdentifier(id), adaptNames(tags))); } catch (AtmosException e) { throw adaptException(e); } } @Override public byte[] readObject(Identifier id, Extent extent, byte[] buffer, Checksum checksum) { try { return readObject(adaptIdentifier(id), extent, buffer, checksum); } catch (AtmosException e) { throw adaptException(e); } } @Override public InputStream readObjectStream(Identifier id, Extent extent) { try { return adaptee.readObjectStream(adaptIdentifier(id), adaptExtent(extent)).getObject(); } catch (AtmosException e) { throw adaptException(e); } } @Override public Acl getAcl(Identifier id) { try { return adaptAcl(adaptee.getAcl(adaptIdentifier(id))); } catch (AtmosException e) { throw adaptException(e); } } @Override public void deleteUserMetadata(Identifier id, MetadataTags tags) { try { adaptee.deleteUserMetadata(adaptIdentifier(id), adaptNames(tags)); } catch (AtmosException e) { throw adaptException(e); } } @Override public List<Identifier> listVersions(Identifier id) { try { List<Identifier> identifiers = new ArrayList<Identifier>(); List<Version> versions = listVersions((ObjectId) id, null); for (Version version : versions) { identifiers.add(version.getId()); } return identifiers; } catch (AtmosException e) { throw adaptException(e); } } @Override public List<Version> listVersions(ObjectId id, ListOptions options) { try { List<Version> versions = new ArrayList<Version>(); ListVersionsRequest request = new ListVersionsRequest(); request.setObjectId((com.emc.atmos.api.ObjectId) adaptIdentifier(id)); if (options != null) request.limit(options.getLimit()).token(options.getToken()); ListVersionsResponse response = adaptee.listVersions(request); if (response.getVersions() != null) { for (ObjectVersion version : response.getVersions()) { versions.add(adaptVersion(version)); } } if (options != null) options.setToken(request.getToken()); return versions; } catch (AtmosException e) { throw adaptException(e); } } @Override public ObjectId versionObject(Identifier id) { try { return (ObjectId) adaptIdentifier(adaptee.createVersion(adaptIdentifier(id))); } catch (AtmosException e) { throw adaptException(e); } } @Override public List<ObjectResult> listObjects(String tag, ListOptions options) { try { List<ObjectResult> results = new ArrayList<ObjectResult>(); ListObjectsRequest request = new ListObjectsRequest().metadataName(tag); if (options != null) { request.limit(options.getLimit()); request.token(options.getToken()).includeMetadata(options.isIncludeMetadata()); if (options.getUserMetadata() != null) request.userMetadataNames( options.getUserMetadata().toArray(new String[options.getUserMetadata().size()])); if (options.getSystemMetadata() != null) request.systemMetadataNames( options.getSystemMetadata().toArray(new String[options.getSystemMetadata().size()])); } for (ObjectEntry entry : adaptee.listObjects(request).getEntries()) { results.add(adaptObjectEntry(entry)); } if (options != null) options.setToken(request.getToken()); return results; } catch (AtmosException e) { throw adaptException(e); } } @Override public MetadataTags getListableTags(MetadataTag tag) { try { return getListableTags(tag.getName()); } catch (AtmosException e) { throw adaptException(e); } } @Override public MetadataTags getListableTags(String tag) { try { return adaptTags(adaptee.listMetadata(tag)); } catch (AtmosException e) { throw adaptException(e); } } @Override public MetadataTags listUserMetadataTags(Identifier id) { try { return adaptTags(adaptee.getUserMetadataNames(adaptIdentifier(id))); } catch (AtmosException e) { throw adaptException(e); } } @Override public List<ObjectId> queryObjects(String xquery) { throw new UnsupportedOperationException("This implementation does not support object query"); } @Override public List<DirectoryEntry> listDirectory(ObjectPath path, ListOptions options) { try { List<DirectoryEntry> entries = new ArrayList<DirectoryEntry>(); ListDirectoryRequest request = new ListDirectoryRequest(); request.path((com.emc.atmos.api.ObjectPath) adaptIdentifier(path)); if (options != null) { request.limit(options.getLimit()).token(options.getToken()) .includeMetadata(options.isIncludeMetadata()); if (options.getUserMetadata() != null) request.userMetadataNames( options.getUserMetadata().toArray(new String[options.getUserMetadata().size()])); if (options.getSystemMetadata() != null) request.systemMetadataNames( options.getSystemMetadata().toArray(new String[options.getSystemMetadata().size()])); } for (com.emc.atmos.api.bean.DirectoryEntry entry : adaptee.listDirectory(request).getEntries()) { entries.add(adaptDirectoryEntry(entry, (com.emc.atmos.api.ObjectPath) adaptIdentifier(path))); } if (options != null) options.setToken(request.getToken()); return entries; } catch (AtmosException e) { throw adaptException(e); } } @Override public ObjectMetadata getAllMetadata(Identifier id) { try { return adaptObjectMetadata(adaptee.getObjectMetadata(adaptIdentifier(id))); } catch (AtmosException e) { throw adaptException(e); } } @Override public void rename(ObjectPath source, ObjectPath destination, boolean force) { try { adaptee.move((com.emc.atmos.api.ObjectPath) adaptIdentifier(source), (com.emc.atmos.api.ObjectPath) adaptIdentifier(destination), force); } catch (AtmosException e) { throw adaptException(e); } } @Override public void restoreVersion(ObjectId id, ObjectId vId) { try { adaptee.restoreVersion((com.emc.atmos.api.ObjectId) adaptIdentifier(id), (com.emc.atmos.api.ObjectId) adaptIdentifier(vId)); } catch (AtmosException e) { throw adaptException(e); } } @Override public ServiceInformation getServiceInformation() { try { return adaptServiceInformation(adaptee.getServiceInformation()); } catch (AtmosException e) { throw adaptException(e); } } @Override public ObjectInfo getObjectInfo(Identifier id) { try { return adaptObjectInfo(adaptee.getObjectInfo(adaptIdentifier(id))); } catch (AtmosException e) { throw adaptException(e); } catch (JAXBException e) { throw new RuntimeException("Could not marshall result to XML", e); } } @Override public void hardLink(ObjectPath source, ObjectPath target) { throw new UnsupportedOperationException("This implementation does not support hard link"); } @Override public ObjectId createObjectWithKeyFromSegment(String keyPool, String key, Acl acl, MetadataList metadata, BufferSegment data, String mimeType, Checksum checksum) { try { CreateObjectRequest request = new CreateObjectRequest().identifier(new ObjectKey(keyPool, key)); request.acl(adaptAcl(acl)).userMetadata(adaptMetadata(metadata)).content(adaptBuffer(data)); request.contentType(mimeType).wsChecksum(adaptChecksum(checksum, data)); return (ObjectId) adaptIdentifier(adaptee.createObject(request).getObjectId()); } catch (AtmosException e) { throw adaptException(e); } } @Override public ObjectId createObjectWithKeyFromStream(String keyPool, String key, Acl acl, MetadataList metadata, InputStream data, long length, String mimeType) { try { CreateObjectRequest request = new CreateObjectRequest().identifier(new ObjectKey(keyPool, key)); request.acl(adaptAcl(acl)).userMetadata(adaptMetadata(metadata)).content(data); request.contentLength(length).contentType(mimeType); return (ObjectId) adaptIdentifier(adaptee.createObject(request).getObjectId()); } catch (AtmosException e) { throw adaptException(e); } } @Override public void deleteObjectWithKey(String keyPool, String key) { try { adaptee.delete(new ObjectKey(keyPool, key)); } catch (AtmosException e) { throw adaptException(e); } } @Override public ObjectMetadata getAllMetadata(String keyPool, String key) { try { return adaptObjectMetadata(adaptee.getObjectMetadata(new ObjectKey(keyPool, key))); } catch (AtmosException e) { throw adaptException(e); } } @Override public MetadataList getSystemMetadata(String keyPool, String key, MetadataTags tags) { try { return adaptMetadata(adaptee.getSystemMetadata(new ObjectKey(keyPool, key), adaptNames(tags))); } catch (AtmosException e) { throw adaptException(e); } } @Override public byte[] readObjectWithKey(String keyPool, String key, Extent extent, byte[] buffer, Checksum checksum) { try { return readObject(new ObjectKey(keyPool, key), extent, buffer, checksum); } catch (AtmosException e) { throw adaptException(e); } } @Override public InputStream readObjectStreamWithKey(String keyPool, String key, Extent extent) { try { return adaptee.readObjectStream(new ObjectKey(keyPool, key), adaptExtent(extent)).getObject(); } catch (AtmosException e) { throw adaptException(e); } } @Override public void updateObjectWithKeyFromStream(String keyPool, String key, Acl acl, MetadataList metadata, Extent extent, InputStream data, long length, String mimeType) { try { UpdateObjectRequest request = new UpdateObjectRequest(); request.identifier(new ObjectKey(keyPool, key)).acl(adaptAcl(acl)).userMetadata(adaptMetadata(metadata)) .range(adaptExtent(extent)).content(data).contentLength(length).contentType(mimeType); adaptee.updateObject(request); } catch (AtmosException e) { throw adaptException(e); } } @Override public void updateObjectWithKeyFromSegment(String keyPool, String key, Acl acl, MetadataList metadata, Extent extent, BufferSegment data, String mimeType, Checksum checksum) { try { UpdateObjectRequest request = new UpdateObjectRequest(); request.identifier(new ObjectKey(keyPool, key)).acl(adaptAcl(acl)).userMetadata(adaptMetadata(metadata)) .range(adaptExtent(extent)).content(adaptBuffer(data)).contentType(mimeType) .wsChecksum(adaptChecksum(checksum, data)); adaptee.updateObject(request); } catch (AtmosException e) { throw adaptException(e); } } private byte[] readObject(ObjectIdentifier identifier, Extent extent, byte[] buffer, Checksum checksum) { try { if (buffer != null && extent != null && extent.getSize() > (long) buffer.length) { throw new IllegalArgumentException("The buffer is smaller than the requested extent"); } ReadObjectResponse<InputStream> response = adaptee.readObjectStream(identifier, adaptExtent(extent)); long contentLength = response.getContentLength(); if (buffer != null && contentLength > -1) { if ((long) buffer.length < contentLength) { throw new EsuException("The response buffer was not long enough to hold the response: " + buffer.length + "<" + contentLength); } int read, c = 0; InputStream in = response.getObject(); while (c < contentLength) { read = in.read(buffer, c, (int) contentLength - c); if (read == -1) { throw new EOFException( "EOF reading response at position " + c + " size " + (contentLength - c)); } c += read; } } else { if (contentLength > Integer.MAX_VALUE) throw new EsuException("Object is too large to hold in a byte array"); buffer = StreamUtil.readAsBytes(response.getObject()); } if (checksum != null && response.getWsChecksum() != null) { checksum.setExpectedValue(response.getWsChecksum().toString()); if (contentLength > -1) checksum.update(buffer, 0, (int) contentLength); else checksum.update(buffer, 0, buffer.length); } return buffer; } catch (IOException e) { throw new EsuException("Error connecting to server", e); } } private ObjectIdentifier adaptIdentifier(Identifier identifier) { if (identifier == null) return null; if (identifier instanceof ObjectId) return new com.emc.atmos.api.ObjectId(identifier.toString()); if (identifier instanceof ObjectPath) return new com.emc.atmos.api.ObjectPath(identifier.toString()); throw new RuntimeException( "Unable to convert identifier " + identifier + " (" + identifier.getClass().getName() + ")"); } private Identifier adaptIdentifier(ObjectIdentifier identifier) { if (identifier == null) return null; if (identifier instanceof com.emc.atmos.api.ObjectId) return new ObjectId(identifier.toString()); if (identifier instanceof com.emc.atmos.api.ObjectPath) return new ObjectPath(identifier.toString()); throw new RuntimeException( "Unable to convert identifier " + identifier + " (" + identifier.getClass().getName() + ")"); } private com.emc.atmos.api.Acl adaptAcl(Acl acl) { if (acl == null) return null; com.emc.atmos.api.Acl newAcl = new com.emc.atmos.api.Acl(); for (Grant grant : acl) { switch (grant.getGrantee().getType()) { case GROUP: newAcl.addGroupGrant(grant.getGrantee().getName(), com.emc.atmos.api.bean.Permission.valueOf(grant.getPermission())); break; case USER: newAcl.addUserGrant(grant.getGrantee().getName(), com.emc.atmos.api.bean.Permission.valueOf(grant.getPermission())); break; } } return newAcl; } private Acl adaptAcl(com.emc.atmos.api.Acl acl) { if (acl == null) return null; Acl newAcl = new Acl(); for (String name : acl.getGroupAcl().keySet()) { newAcl.addGrant( new Grant(new Grantee(name, Grantee.GRANT_TYPE.GROUP), acl.getGroupAcl().get(name).toString())); } for (String name : acl.getUserAcl().keySet()) { newAcl.addGrant( new Grant(new Grantee(name, Grantee.GRANT_TYPE.USER), acl.getUserAcl().get(name).toString())); } return newAcl; } private com.emc.atmos.api.bean.Metadata[] adaptMetadata(MetadataList metadataList) { if (metadataList == null) return null; List<com.emc.atmos.api.bean.Metadata> newMetadata = new ArrayList<com.emc.atmos.api.bean.Metadata>(); for (Metadata metadata : metadataList) { newMetadata.add(new com.emc.atmos.api.bean.Metadata(metadata.getName(), metadata.getValue(), metadata.isListable())); } return newMetadata.toArray(new com.emc.atmos.api.bean.Metadata[newMetadata.size()]); } private MetadataList adaptMetadata(Map<String, com.emc.atmos.api.bean.Metadata> metadataMap) { if (metadataMap == null) return null; MetadataList metadataList = new MetadataList(); for (com.emc.atmos.api.bean.Metadata oneMetadata : metadataMap.values()) { metadataList.addMetadata( new Metadata(oneMetadata.getName(), oneMetadata.getValue(), oneMetadata.isListable())); } return metadataList; } private String[] adaptNames(MetadataTags tags) { if (tags == null) return null; List<String> names = new ArrayList<String>(); for (MetadataTag tag : tags) { names.add(tag.getName()); } return names.toArray(new String[names.size()]); } private MetadataTags adaptTags(Set<String> names) { if (names == null) return null; MetadataTags newTags = new MetadataTags(); for (String name : names) { newTags.addTag(new MetadataTag(name, false)); } return newTags; } private MetadataTags adaptTags(Map<String, Boolean> tags) { if (tags == null) return null; MetadataTags newTags = new MetadataTags(); for (String name : tags.keySet()) { newTags.addTag(new MetadataTag(name, tags.get(name))); } return newTags; } private Range adaptExtent(Extent extent) { if (extent == null) return null; return new Range(extent.getOffset(), extent.getOffset() + extent.getSize() - 1); } private com.emc.atmos.api.BufferSegment adaptBuffer(BufferSegment bufferSegment) { if (bufferSegment == null) return null; return new com.emc.atmos.api.BufferSegment(bufferSegment.getBuffer(), bufferSegment.getOffset(), bufferSegment.getSize()); } private ChecksumValue adaptChecksum(Checksum checksum, BufferSegment bufferSegment) { if (checksum == null) return null; checksum.update(bufferSegment.getBuffer(), bufferSegment.getOffset(), bufferSegment.getSize()); return new ChecksumValueImpl(checksum.toString()); } private Version adaptVersion(ObjectVersion version) { if (version == null) return null; return new Version((ObjectId) adaptIdentifier(version.getVersionId()), version.getVersionNumber(), version.getItime()); } private ObjectResult adaptObjectEntry(ObjectEntry entry) { if (entry == null) return null; ObjectResult result = new ObjectResult(); result.setId((ObjectId) adaptIdentifier(entry.getObjectId())); Map<String, com.emc.atmos.api.bean.Metadata> allMetadata = new TreeMap<String, com.emc.atmos.api.bean.Metadata>(); if (entry.getSystemMetadata() != null) allMetadata.putAll(entry.getSystemMetadataMap()); if (entry.getUserMetadata() != null) allMetadata.putAll(entry.getUserMetadataMap()); if (!allMetadata.isEmpty()) result.setMetadata(adaptMetadata(allMetadata)); return result; } private DirectoryEntry adaptDirectoryEntry(com.emc.atmos.api.bean.DirectoryEntry entry, com.emc.atmos.api.ObjectPath parentPath) { if (entry == null) return null; String path = parentPath.getPath() + entry.getFilename(); if (entry.isDirectory()) path += "/"; DirectoryEntry newEntry = new DirectoryEntry(); newEntry.setId((ObjectId) adaptIdentifier(entry.getObjectId())); newEntry.setPath(new ObjectPath(path)); newEntry.setType(entry.getFileType().toString()); newEntry.setSystemMetadata(adaptMetadata(entry.getSystemMetadataMap())); newEntry.setUserMetadata(adaptMetadata(entry.getUserMetadataMap())); return newEntry; } private ObjectMetadata adaptObjectMetadata(com.emc.atmos.api.bean.ObjectMetadata objectMetadata) { if (objectMetadata == null) return null; ObjectMetadata newMetadata = new ObjectMetadata(); newMetadata.setAcl(adaptAcl(objectMetadata.getAcl())); newMetadata.setMimeType(objectMetadata.getContentType()); newMetadata.setMetadata(adaptMetadata(objectMetadata.getMetadata())); return newMetadata; } private ObjectInfo adaptObjectInfo(com.emc.atmos.api.bean.ObjectInfo objectInfo) throws JAXBException { if (objectInfo == null) return null; ObjectInfo newObjectInfo = new ObjectInfo(); newObjectInfo.setObjectId((ObjectId) adaptIdentifier(objectInfo.getObjectId())); newObjectInfo.setSelection(objectInfo.getSelection()); if (objectInfo.getExpiration() != null) { ObjectExpiration objectExpiration = new ObjectExpiration(); objectExpiration.setEnabled(objectInfo.getExpiration().isEnabled()); objectExpiration.setEndAt(objectInfo.getExpiration().getEndAt()); newObjectInfo.setExpiration(objectExpiration); } if (objectInfo.getRetention() != null) { ObjectRetention objectRetention = new ObjectRetention(); objectRetention.setEnabled(objectInfo.getRetention().isEnabled()); objectRetention.setEndAt(objectInfo.getRetention().getEndAt()); newObjectInfo.setRetention(objectRetention); } if (objectInfo.getReplicas() != null) { List<ObjectReplica> replicas = new ArrayList<ObjectReplica>(); for (Replica replica : objectInfo.getReplicas()) { ObjectReplica newReplica = new ObjectReplica(); newReplica.setId("" + replica.getId()); newReplica.setCurrent(replica.isCurrent()); newReplica.setLocation(replica.getLocation()); newReplica.setReplicaType(replica.getType()); newReplica.setStorageType(replica.getStorageType()); replicas.add(newReplica); } newObjectInfo.setReplicas(replicas); } StringWriter xmlString = new StringWriter(); getMarshaller().marshal(objectInfo, xmlString); newObjectInfo.setRawXml(xmlString.toString()); return newObjectInfo; } private ServiceInformation adaptServiceInformation( com.emc.atmos.api.bean.ServiceInformation serviceInformation) { if (serviceInformation == null) return null; ServiceInformation newServiceInformation = new ServiceInformation(); newServiceInformation.setAtmosVersion(serviceInformation.getAtmosVersion()); newServiceInformation.setUnicodeMetadataSupported( serviceInformation.hasFeature(com.emc.atmos.api.bean.ServiceInformation.Feature.Utf8)); for (com.emc.atmos.api.bean.ServiceInformation.Feature feature : serviceInformation.getFeatures()) { newServiceInformation.addFeature(feature.getHeaderName()); } return newServiceInformation; } private EsuException adaptException(AtmosException e) { return new EsuException(e.getMessage(), e.getCause(), e.getHttpCode(), e.getErrorCode()); } private Marshaller getMarshaller() throws JAXBException { Marshaller m = marshaller.get(); if (m == null) { m = jaxbContext.createMarshaller(); marshaller.set(m); } return m; } }