Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.jackrabbit.core.persistence.xml; import org.apache.commons.io.IOUtils; import org.apache.jackrabbit.core.id.NodeId; import org.apache.jackrabbit.core.id.PropertyId; import org.apache.jackrabbit.core.fs.BasedFileSystem; import org.apache.jackrabbit.core.fs.FileSystem; import org.apache.jackrabbit.core.fs.FileSystemException; import org.apache.jackrabbit.core.fs.FileSystemResource; import org.apache.jackrabbit.core.fs.local.LocalFileSystem; import org.apache.jackrabbit.core.persistence.AbstractPersistenceManager; import org.apache.jackrabbit.core.state.ItemStateException; import org.apache.jackrabbit.core.state.NoSuchItemStateException; import org.apache.jackrabbit.core.state.NodeReferences; import org.apache.jackrabbit.core.state.NodeState; import org.apache.jackrabbit.core.persistence.PMContext; import org.apache.jackrabbit.core.state.PropertyState; import org.apache.jackrabbit.core.state.ChildNodeEntry; import org.apache.jackrabbit.core.persistence.util.BLOBStore; import org.apache.jackrabbit.core.persistence.util.FileSystemBLOBStore; import org.apache.jackrabbit.core.persistence.util.ResourceBasedBLOBStore; import org.apache.jackrabbit.core.util.DOMWalker; import org.apache.jackrabbit.core.value.InternalValue; import org.apache.jackrabbit.spi.Name; import org.apache.jackrabbit.spi.NameFactory; import org.apache.jackrabbit.util.Text; import org.apache.jackrabbit.spi.commons.name.NameFactoryImpl; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import javax.jcr.PropertyType; import java.io.BufferedWriter; import java.io.File; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.io.OutputStreamWriter; import java.io.UnsupportedEncodingException; import java.io.Writer; import java.security.MessageDigest; import java.security.NoSuchAlgorithmException; import java.util.ArrayList; import java.util.HashSet; import java.util.Set; /** * <code>XMLPersistenceManager</code> is a <code>FileSystem</code>-based * <code>PersistenceManager</code> that persists <code>ItemState</code> * and <code>NodeReferences</code> objects in XML format. * * @deprecated Please migrate to a bundle persistence manager * (<a href="https://issues.apache.org/jira/browse/JCR-2802">JCR-2802</a>) */ @Deprecated public class XMLPersistenceManager extends AbstractPersistenceManager { private static Logger log = LoggerFactory.getLogger(XMLPersistenceManager.class); /** * hexdigits for toString */ private static final char[] HEXDIGITS = "0123456789abcdef".toCharArray(); /** * The default encoding used in serialization */ public static final String DEFAULT_ENCODING = "UTF-8"; /** * The XML elements and attributes used in serialization */ private static final String NODE_ELEMENT = "node"; private static final String UUID_ATTRIBUTE = "uuid"; private static final String NODETYPE_ATTRIBUTE = "nodeType"; private static final String PARENTUUID_ATTRIBUTE = "parentUUID"; private static final String MODCOUNT_ATTRIBUTE = "modCount"; private static final String MIXINTYPES_ELEMENT = "mixinTypes"; private static final String MIXINTYPE_ELEMENT = "mixinType"; private static final String PROPERTIES_ELEMENT = "properties"; private static final String PROPERTY_ELEMENT = "property"; private static final String NAME_ATTRIBUTE = "name"; private static final String TYPE_ATTRIBUTE = "type"; private static final String MULTIVALUED_ATTRIBUTE = "multiValued"; private static final String VALUES_ELEMENT = "values"; private static final String VALUE_ELEMENT = "value"; private static final String NODES_ELEMENT = "nodes"; private static final String NODEREFERENCES_ELEMENT = "references"; private static final String TARGETID_ATTRIBUTE = "targetId"; private static final String NODEREFERENCE_ELEMENT = "reference"; private static final String PROPERTYID_ATTRIBUTE = "propertyId"; private static final String NODEFILENAME = ".node.xml"; private static final String NODEREFSFILENAME = ".references.xml"; private boolean initialized; // file system where the item state is stored private FileSystem itemStateFS; // file system where BLOB data is stored private FileSystem blobFS; // BLOBStore that manages BLOB data in the file system private BLOBStore blobStore; /** * Template for the subdirectory path for the files associated with * a single node. The template is processed by replacing each * "<code>x</code>" with the next hex digit in the UUID string. * All other characters in the template are used as-is. */ private String nodePathTemplate = "xxxx/xxxx/xxxxxxxxxxxxxxxxxxxxxxxx"; private final NameFactory factory; /** * Creates a new <code>XMLPersistenceManager</code> instance. */ public XMLPersistenceManager() { initialized = false; factory = NameFactoryImpl.getInstance(); } /** * Returns the node path template. * * @return node path template */ public String getNodePathTemplate() { return nodePathTemplate; } /** * Sets the node path template. * * @param template node path template */ public void setNodePathTemplate(String template) { nodePathTemplate = template; } /** * Builds the path of the node folder for the given node identifier * based on the configured node path template. * * @param id node identifier * @return node folder path */ private String buildNodeFolderPath(NodeId id) { StringBuilder sb = new StringBuilder(); char[] chars = id.toString().toCharArray(); int cnt = 0; for (int i = 0; i < nodePathTemplate.length(); i++) { char ch = nodePathTemplate.charAt(i); if (ch == 'x' && cnt < chars.length) { ch = chars[cnt++]; if (ch == '-') { ch = chars[cnt++]; } } sb.append(ch); } return sb.toString(); } private String buildPropFilePath(PropertyId id) { String fileName; try { MessageDigest md5 = MessageDigest.getInstance("MD5"); md5.update(id.getName().getNamespaceURI().getBytes()); md5.update(id.getName().getLocalName().getBytes()); byte[] bytes = md5.digest(); char[] chars = new char[32]; for (int i = 0, j = 0; i < 16; i++) { chars[j++] = HEXDIGITS[(bytes[i] >> 4) & 0x0f]; chars[j++] = HEXDIGITS[bytes[i] & 0x0f]; } fileName = new String(chars) + ".xml"; } catch (NoSuchAlgorithmException nsae) { // should never get here as MD5 should always be available in the JRE String msg = "MD5 not available"; log.error(msg, nsae); throw new InternalError(msg + nsae); } return buildNodeFolderPath(id.getParentId()) + "/" + fileName; } private String buildNodeFilePath(NodeId id) { return buildNodeFolderPath(id) + "/" + NODEFILENAME; } private String buildNodeReferencesFilePath(NodeId id) { return buildNodeFolderPath(id) + "/" + NODEREFSFILENAME; } private void readState(DOMWalker walker, NodeState state) throws ItemStateException { // first do some paranoid sanity checks if (!walker.getName().equals(NODE_ELEMENT)) { String msg = "invalid serialization format (unexpected element: " + walker.getName() + ")"; log.debug(msg); throw new ItemStateException(msg); } // check uuid if (!state.getNodeId().toString().equals(walker.getAttribute(UUID_ATTRIBUTE))) { String msg = "invalid serialized state: uuid mismatch"; log.debug(msg); throw new ItemStateException(msg); } // check nodetype String ntName = walker.getAttribute(NODETYPE_ATTRIBUTE); if (!factory.create(ntName).equals(state.getNodeTypeName())) { String msg = "invalid serialized state: nodetype mismatch"; log.debug(msg); throw new ItemStateException(msg); } // now we're ready to read state // primary parent String parentUUID = walker.getAttribute(PARENTUUID_ATTRIBUTE); if (parentUUID.length() > 0) { state.setParentId(NodeId.valueOf(parentUUID)); } // modification count String modCount = walker.getAttribute(MODCOUNT_ATTRIBUTE); state.setModCount(Short.parseShort(modCount)); // mixin types if (walker.enterElement(MIXINTYPES_ELEMENT)) { Set<Name> mixins = new HashSet<Name>(); while (walker.iterateElements(MIXINTYPE_ELEMENT)) { mixins.add(factory.create(walker.getAttribute(NAME_ATTRIBUTE))); } if (mixins.size() > 0) { state.setMixinTypeNames(mixins); } walker.leaveElement(); } // property entries if (walker.enterElement(PROPERTIES_ELEMENT)) { while (walker.iterateElements(PROPERTY_ELEMENT)) { String propName = walker.getAttribute(NAME_ATTRIBUTE); // @todo deserialize type and values state.addPropertyName(factory.create(propName)); } walker.leaveElement(); } // child node entries if (walker.enterElement(NODES_ELEMENT)) { while (walker.iterateElements(NODE_ELEMENT)) { String childName = walker.getAttribute(NAME_ATTRIBUTE); String childUUID = walker.getAttribute(UUID_ATTRIBUTE); state.addChildNodeEntry(factory.create(childName), NodeId.valueOf(childUUID)); } walker.leaveElement(); } } private void readState(DOMWalker walker, PropertyState state) throws ItemStateException { // first do some paranoid sanity checks if (!walker.getName().equals(PROPERTY_ELEMENT)) { String msg = "invalid serialization format (unexpected element: " + walker.getName() + ")"; log.debug(msg); throw new ItemStateException(msg); } // check name if (!state.getName().equals(factory.create(walker.getAttribute(NAME_ATTRIBUTE)))) { String msg = "invalid serialized state: name mismatch"; log.debug(msg); throw new ItemStateException(msg); } // check parentUUID NodeId parentId = NodeId.valueOf(walker.getAttribute(PARENTUUID_ATTRIBUTE)); if (!parentId.equals(state.getParentId())) { String msg = "invalid serialized state: parentUUID mismatch"; log.debug(msg); throw new ItemStateException(msg); } // now we're ready to read state // type String typeName = walker.getAttribute(TYPE_ATTRIBUTE); int type; try { type = PropertyType.valueFromName(typeName); } catch (IllegalArgumentException iae) { // should never be getting here throw new ItemStateException("unexpected property-type: " + typeName, iae); } state.setType(type); // multiValued String multiValued = walker.getAttribute(MULTIVALUED_ATTRIBUTE); state.setMultiValued(Boolean.parseBoolean(multiValued)); // modification count String modCount = walker.getAttribute(MODCOUNT_ATTRIBUTE); state.setModCount(Short.parseShort(modCount)); // values ArrayList<InternalValue> values = new ArrayList<InternalValue>(); if (walker.enterElement(VALUES_ELEMENT)) { while (walker.iterateElements(VALUE_ELEMENT)) { // read serialized value String content = walker.getContent(); if (PropertyType.STRING == type) { // STRING value can be empty; ignore length values.add(InternalValue.valueOf(content, type)); } else if (content.length() > 0) { // non-empty non-STRING value if (type == PropertyType.BINARY) { try { // special handling required for binary value: // the value stores the id of the BLOB data // in the BLOB store if (blobStore instanceof ResourceBasedBLOBStore) { // optimization: if the BLOB store is resource-based // retrieve the resource directly rather than having // to read the BLOB from an input stream FileSystemResource fsRes = ((ResourceBasedBLOBStore) blobStore) .getResource(content); values.add(InternalValue.create(fsRes)); } else { InputStream in = blobStore.get(content); try { values.add(InternalValue.create(in)); } finally { IOUtils.closeQuietly(in); } } } catch (Exception e) { String msg = "error while reading serialized binary value"; log.debug(msg); throw new ItemStateException(msg, e); } } else { // non-empty non-STRING non-BINARY value values.add(InternalValue.valueOf(content, type)); } } else { // empty non-STRING value log.warn(state.getPropertyId() + ": ignoring empty value of type " + PropertyType.nameFromValue(type)); } } walker.leaveElement(); } state.setValues((InternalValue[]) values.toArray(new InternalValue[values.size()])); } private void readState(DOMWalker walker, NodeReferences refs) throws ItemStateException { // first do some paranoid sanity checks if (!walker.getName().equals(NODEREFERENCES_ELEMENT)) { String msg = "invalid serialization format (unexpected element: " + walker.getName() + ")"; log.debug(msg); throw new ItemStateException(msg); } // check targetId if (!refs.getTargetId().equals(NodeId.valueOf(walker.getAttribute(TARGETID_ATTRIBUTE)))) { String msg = "invalid serialized state: targetId mismatch"; log.debug(msg); throw new ItemStateException(msg); } // now we're ready to read the references data // property id's refs.clearAllReferences(); while (walker.iterateElements(NODEREFERENCE_ELEMENT)) { refs.addReference(PropertyId.valueOf(walker.getAttribute(PROPERTYID_ATTRIBUTE))); } } //---------------------------------------------------< PersistenceManager > /** * {@inheritDoc} */ public void init(PMContext context) throws Exception { if (initialized) { throw new IllegalStateException("already initialized"); } itemStateFS = new BasedFileSystem(context.getFileSystem(), "/data"); /** * store BLOB data in local file system in a sub directory * of the workspace home directory */ LocalFileSystem blobFS = new LocalFileSystem(); blobFS.setRoot(new File(context.getHomeDir(), "blobs")); blobFS.init(); this.blobFS = blobFS; blobStore = new FileSystemBLOBStore(blobFS); initialized = true; } /** * {@inheritDoc} */ public synchronized void close() throws Exception { if (!initialized) { throw new IllegalStateException("not initialized"); } try { // close BLOB file system blobFS.close(); blobFS = null; blobStore = null; /** * there's no need close the item state store because it * is based in the workspace's file system which is * closed by the repository */ } finally { initialized = false; } } /** * {@inheritDoc} */ public synchronized NodeState load(NodeId id) throws NoSuchItemStateException, ItemStateException { if (!initialized) { throw new IllegalStateException("not initialized"); } Exception e = null; String nodeFilePath = buildNodeFilePath(id); try { if (!itemStateFS.isFile(nodeFilePath)) { throw new NoSuchItemStateException(id.toString()); } InputStream in = itemStateFS.getInputStream(nodeFilePath); try { DOMWalker walker = new DOMWalker(in); String ntName = walker.getAttribute(NODETYPE_ATTRIBUTE); NodeState state = createNew(id); state.setNodeTypeName(factory.create(ntName)); readState(walker, state); return state; } finally { in.close(); } } catch (IOException ioe) { e = ioe; // fall through } catch (FileSystemException fse) { e = fse; // fall through } String msg = "failed to read node state: " + id; log.debug(msg); throw new ItemStateException(msg, e); } /** * {@inheritDoc} */ public synchronized PropertyState load(PropertyId id) throws NoSuchItemStateException, ItemStateException { if (!initialized) { throw new IllegalStateException("not initialized"); } Exception e = null; String propFilePath = buildPropFilePath(id); try { if (!itemStateFS.isFile(propFilePath)) { throw new NoSuchItemStateException(id.toString()); } InputStream in = itemStateFS.getInputStream(propFilePath); try { DOMWalker walker = new DOMWalker(in); PropertyState state = createNew(id); readState(walker, state); return state; } finally { in.close(); } } catch (IOException ioe) { e = ioe; // fall through } catch (FileSystemException fse) { e = fse; // fall through } String msg = "failed to read property state: " + id.toString(); log.debug(msg); throw new ItemStateException(msg, e); } /** * {@inheritDoc} */ protected void store(NodeState state) throws ItemStateException { if (!initialized) { throw new IllegalStateException("not initialized"); } NodeId id = state.getNodeId(); String nodeFilePath = buildNodeFilePath(id); FileSystemResource nodeFile = new FileSystemResource(itemStateFS, nodeFilePath); try { nodeFile.makeParentDirs(); OutputStream os = nodeFile.getOutputStream(); Writer writer = null; try { String encoding = DEFAULT_ENCODING; try { writer = new BufferedWriter(new OutputStreamWriter(os, encoding)); } catch (UnsupportedEncodingException e) { // should never get here! OutputStreamWriter osw = new OutputStreamWriter(os); encoding = osw.getEncoding(); writer = new BufferedWriter(osw); } String parentId = (state.getParentId() == null) ? "" : state.getParentId().toString(); String encodedNodeType = Text.encodeIllegalXMLCharacters(state.getNodeTypeName().toString()); writer.write("<?xml version=\"1.0\" encoding=\"" + encoding + "\"?>\n"); writer.write("<" + NODE_ELEMENT + " " + UUID_ATTRIBUTE + "=\"" + id + "\" " + PARENTUUID_ATTRIBUTE + "=\"" + parentId + "\" " + MODCOUNT_ATTRIBUTE + "=\"" + state.getModCount() + "\" " + NODETYPE_ATTRIBUTE + "=\"" + encodedNodeType + "\">\n"); // mixin types writer.write("\t<" + MIXINTYPES_ELEMENT + ">\n"); for (Name mixin : state.getMixinTypeNames()) { writer.write("\t\t<" + MIXINTYPE_ELEMENT + " " + NAME_ATTRIBUTE + "=\"" + Text.encodeIllegalXMLCharacters(mixin.toString()) + "\"/>\n"); } writer.write("\t</" + MIXINTYPES_ELEMENT + ">\n"); // properties writer.write("\t<" + PROPERTIES_ELEMENT + ">\n"); for (Name propName : state.getPropertyNames()) { writer.write("\t\t<" + PROPERTY_ELEMENT + " " + NAME_ATTRIBUTE + "=\"" + Text.encodeIllegalXMLCharacters(propName.toString()) + "\">\n"); // @todo serialize type, definition id and values writer.write("\t\t</" + PROPERTY_ELEMENT + ">\n"); } writer.write("\t</" + PROPERTIES_ELEMENT + ">\n"); // child nodes writer.write("\t<" + NODES_ELEMENT + ">\n"); for (ChildNodeEntry entry : state.getChildNodeEntries()) { writer.write("\t\t<" + NODE_ELEMENT + " " + NAME_ATTRIBUTE + "=\"" + Text.encodeIllegalXMLCharacters(entry.getName().toString()) + "\" " + UUID_ATTRIBUTE + "=\"" + entry.getId() + "\">\n"); writer.write("\t\t</" + NODE_ELEMENT + ">\n"); } writer.write("\t</" + NODES_ELEMENT + ">\n"); writer.write("</" + NODE_ELEMENT + ">\n"); } finally { writer.close(); } } catch (Exception e) { String msg = "failed to write node state: " + id; log.debug(msg); throw new ItemStateException(msg, e); } } /** * {@inheritDoc} */ protected void store(PropertyState state) throws ItemStateException { if (!initialized) { throw new IllegalStateException("not initialized"); } String propFilePath = buildPropFilePath(state.getPropertyId()); FileSystemResource propFile = new FileSystemResource(itemStateFS, propFilePath); try { propFile.makeParentDirs(); OutputStream os = propFile.getOutputStream(); // write property state to xml file Writer writer = null; try { String encoding = DEFAULT_ENCODING; try { writer = new BufferedWriter(new OutputStreamWriter(os, encoding)); } catch (UnsupportedEncodingException e) { // should never get here! OutputStreamWriter osw = new OutputStreamWriter(os); encoding = osw.getEncoding(); writer = new BufferedWriter(osw); } String typeName; int type = state.getType(); try { typeName = PropertyType.nameFromValue(type); } catch (IllegalArgumentException iae) { // should never be getting here throw new ItemStateException("unexpected property-type ordinal: " + type, iae); } writer.write("<?xml version=\"1.0\" encoding=\"" + encoding + "\"?>\n"); writer.write("<" + PROPERTY_ELEMENT + " " + NAME_ATTRIBUTE + "=\"" + Text.encodeIllegalXMLCharacters(state.getName().toString()) + "\" " + PARENTUUID_ATTRIBUTE + "=\"" + state.getParentId() + "\" " + MULTIVALUED_ATTRIBUTE + "=\"" + Boolean.toString(state.isMultiValued()) + "\" " + MODCOUNT_ATTRIBUTE + "=\"" + state.getModCount() + "\" " + TYPE_ATTRIBUTE + "=\"" + typeName + "\">\n"); // values writer.write("\t<" + VALUES_ELEMENT + ">\n"); InternalValue[] values = state.getValues(); if (values != null) { for (int i = 0; i < values.length; i++) { writer.write("\t\t<" + VALUE_ELEMENT + ">"); InternalValue val = values[i]; if (val != null) { if (type == PropertyType.BINARY) { // special handling required for binary value: // put binary value in BLOB store InputStream in = val.getStream(); String blobId = blobStore.createId(state.getPropertyId(), i); try { blobStore.put(blobId, in, val.getLength()); } finally { IOUtils.closeQuietly(in); } // store id of BLOB as property value writer.write(blobId); // replace value instance with value backed by resource // in BLOB store and discard old value instance (e.g. temp file) if (blobStore instanceof ResourceBasedBLOBStore) { // optimization: if the BLOB store is resource-based // retrieve the resource directly rather than having // to read the BLOB from an input stream FileSystemResource fsRes = ((ResourceBasedBLOBStore) blobStore) .getResource(blobId); values[i] = InternalValue.create(fsRes); } else { in = blobStore.get(blobId); try { values[i] = InternalValue.create(in); } finally { try { in.close(); } catch (IOException e) { // ignore } } } val.discard(); } else { writer.write(Text.encodeIllegalXMLCharacters(val.toString())); } } writer.write("</" + VALUE_ELEMENT + ">\n"); } } writer.write("\t</" + VALUES_ELEMENT + ">\n"); writer.write("</" + PROPERTY_ELEMENT + ">\n"); } finally { writer.close(); } } catch (Exception e) { String msg = "failed to store property state: " + state.getParentId() + "/" + state.getName(); log.debug(msg); throw new ItemStateException(msg, e); } } /** * {@inheritDoc} */ protected void destroy(NodeState state) throws ItemStateException { if (!initialized) { throw new IllegalStateException("not initialized"); } NodeId id = state.getNodeId(); String nodeFilePath = buildNodeFilePath(id); FileSystemResource nodeFile = new FileSystemResource(itemStateFS, nodeFilePath); try { if (nodeFile.exists()) { // delete resource and prune empty parent folders nodeFile.delete(true); } } catch (FileSystemException fse) { String msg = "failed to delete node state: " + id; log.debug(msg); throw new ItemStateException(msg, fse); } } /** * {@inheritDoc} */ protected void destroy(PropertyState state) throws ItemStateException { if (!initialized) { throw new IllegalStateException("not initialized"); } // delete binary values (stored as files) InternalValue[] values = state.getValues(); if (values != null) { for (int i = 0; i < values.length; i++) { InternalValue val = values[i]; if (val != null) { val.deleteBinaryResource(); } } } // delete property file String propFilePath = buildPropFilePath(state.getPropertyId()); FileSystemResource propFile = new FileSystemResource(itemStateFS, propFilePath); try { if (propFile.exists()) { // delete resource and prune empty parent folders propFile.delete(true); } } catch (FileSystemException fse) { String msg = "failed to delete property state: " + state.getParentId() + "/" + state.getName(); log.debug(msg); throw new ItemStateException(msg, fse); } } /** * {@inheritDoc} */ public synchronized NodeReferences loadReferencesTo(NodeId id) throws NoSuchItemStateException, ItemStateException { if (!initialized) { throw new IllegalStateException("not initialized"); } Exception e = null; String refsFilePath = buildNodeReferencesFilePath(id); try { if (!itemStateFS.isFile(refsFilePath)) { throw new NoSuchItemStateException(id.toString()); } InputStream in = itemStateFS.getInputStream(refsFilePath); try { DOMWalker walker = new DOMWalker(in); NodeReferences refs = new NodeReferences(id); readState(walker, refs); return refs; } finally { in.close(); } } catch (IOException ioe) { e = ioe; // fall through } catch (FileSystemException fse) { e = fse; // fall through } String msg = "failed to load references: " + id; log.debug(msg); throw new ItemStateException(msg, e); } /** * {@inheritDoc} */ protected void store(NodeReferences refs) throws ItemStateException { if (!initialized) { throw new IllegalStateException("not initialized"); } String refsFilePath = buildNodeReferencesFilePath(refs.getTargetId()); FileSystemResource refsFile = new FileSystemResource(itemStateFS, refsFilePath); try { refsFile.makeParentDirs(); OutputStream os = refsFile.getOutputStream(); BufferedWriter writer = null; try { String encoding = DEFAULT_ENCODING; try { writer = new BufferedWriter(new OutputStreamWriter(os, encoding)); } catch (UnsupportedEncodingException e) { // should never get here! OutputStreamWriter osw = new OutputStreamWriter(os); encoding = osw.getEncoding(); writer = new BufferedWriter(osw); } writer.write("<?xml version=\"1.0\" encoding=\"" + encoding + "\"?>\n"); writer.write("<" + NODEREFERENCES_ELEMENT + " " + TARGETID_ATTRIBUTE + "=\"" + refs.getTargetId() + "\">\n"); // write references (i.e. the id's of the REFERENCE properties) for (PropertyId propId : refs.getReferences()) { writer.write( "\t<" + NODEREFERENCE_ELEMENT + " " + PROPERTYID_ATTRIBUTE + "=\"" + propId + "\"/>\n"); } writer.write("</" + NODEREFERENCES_ELEMENT + ">\n"); } finally { writer.close(); } } catch (Exception e) { String msg = "failed to store " + refs; log.debug(msg); throw new ItemStateException(msg, e); } } /** * {@inheritDoc} */ protected void destroy(NodeReferences refs) throws ItemStateException { if (!initialized) { throw new IllegalStateException("not initialized"); } String refsFilePath = buildNodeReferencesFilePath(refs.getTargetId()); FileSystemResource refsFile = new FileSystemResource(itemStateFS, refsFilePath); try { if (refsFile.exists()) { // delete resource and prune empty parent folders refsFile.delete(true); } } catch (FileSystemException fse) { String msg = "failed to delete " + refs; log.debug(msg); throw new ItemStateException(msg, fse); } } /** * {@inheritDoc} */ public synchronized boolean exists(NodeId id) throws ItemStateException { if (!initialized) { throw new IllegalStateException("not initialized"); } try { String nodeFilePath = buildNodeFilePath(id); FileSystemResource nodeFile = new FileSystemResource(itemStateFS, nodeFilePath); return nodeFile.exists(); } catch (FileSystemException fse) { String msg = "failed to check existence of item state: " + id; log.debug(msg); throw new ItemStateException(msg, fse); } } /** * {@inheritDoc} */ public synchronized boolean exists(PropertyId id) throws ItemStateException { if (!initialized) { throw new IllegalStateException("not initialized"); } try { String propFilePath = buildPropFilePath(id); FileSystemResource propFile = new FileSystemResource(itemStateFS, propFilePath); return propFile.exists(); } catch (FileSystemException fse) { String msg = "failed to check existence of item state: " + id; log.error(msg, fse); throw new ItemStateException(msg, fse); } } /** * {@inheritDoc} */ public synchronized boolean existsReferencesTo(NodeId id) throws ItemStateException { if (!initialized) { throw new IllegalStateException("not initialized"); } try { String refsFilePath = buildNodeReferencesFilePath(id); FileSystemResource refsFile = new FileSystemResource(itemStateFS, refsFilePath); return refsFile.exists(); } catch (FileSystemException fse) { String msg = "failed to check existence of references: " + id; log.debug(msg); throw new ItemStateException(msg, fse); } } }