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.bundle; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.apache.commons.io.IOUtils; import org.apache.jackrabbit.core.fs.FileSystem; import org.apache.jackrabbit.core.fs.BasedFileSystem; import org.apache.jackrabbit.core.fs.FileSystemException; import org.apache.jackrabbit.core.fs.local.LocalFileSystem; import org.apache.jackrabbit.core.persistence.PMContext; import org.apache.jackrabbit.core.persistence.util.BLOBStore; import org.apache.jackrabbit.core.persistence.util.BundleBinding; import org.apache.jackrabbit.core.persistence.util.ErrorHandling; import org.apache.jackrabbit.core.persistence.util.FileSystemBLOBStore; import org.apache.jackrabbit.core.persistence.util.NodePropBundle; import org.apache.jackrabbit.core.persistence.util.Serializer; import org.apache.jackrabbit.core.id.NodeId; import org.apache.jackrabbit.core.id.PropertyId; import org.apache.jackrabbit.core.state.ItemStateException; import org.apache.jackrabbit.core.state.NoSuchItemStateException; import org.apache.jackrabbit.core.state.NodeReferences; import java.io.File; import java.io.InputStream; import java.io.OutputStream; import java.sql.SQLException; import java.util.ArrayList; import java.util.Arrays; import java.util.List; /** * This is a generic persistence manager that stores the {@link NodePropBundle}s * in a filesystem. * <p/> * Configuration:<br> * <ul> * <li><param name="{@link #setBlobFSBlockSize(String) blobFSBlockSize}" value="0"/> * <li><param name="{@link #setMinBlobSize(String) minBlobSize}" value="4096"/> * <li><param name="{@link #setErrorHandling(String) errorHandling}" value=""/> * </ul> */ public class BundleFsPersistenceManager extends AbstractBundlePersistenceManager { /** the default logger */ private static Logger log = LoggerFactory.getLogger(BundleFsPersistenceManager.class); /** flag indicating if this manager was initialized */ protected boolean initialized; /** file system where BLOB data is stored */ protected BundleFsPersistenceManager.CloseableBLOBStore blobStore; /** * Default blocksize for BLOB filesystem: * @see #setBlobFSBlockSize(String) */ private int blobFSBlockSize; /** * the minimum size of a property until it gets written to the blob store * @see #setMinBlobSize(String) */ private int minBlobSize = 0x1000; /** * the filesystem where the items are stored */ private FileSystem itemFs; /** * flag for error handling */ protected ErrorHandling errorHandling = new ErrorHandling(); /** * the bundle binding */ protected BundleBinding binding; /** * the name of this persistence manager */ private String name = super.toString(); /** * Returns the configured block size of the blob cqfs * @return the block size. */ public String getBlobFSBlockSize() { return String.valueOf(blobFSBlockSize); } /** * Sets the block size of the blob fs and controls how blobs are handled. * <br> * If the size is 0, the blobs are stored within the workspace's physical filesystem. * <br> * Otherwise, the blobs are stored within the item filesystem. * <br> * Please note that not all binary properties are considered as blobs. They * are only stored in the respective blob store, if their size exceeds * {@link #getMinBlobSize()}. * * @param size the block size */ public void setBlobFSBlockSize(String size) { this.blobFSBlockSize = Integer.decode(size).intValue(); } /** * Returns <code>true</code> if the blobs are stored in the local fs. * @return <code>true</code> if the blobs are stored in the local fs. */ public boolean useLocalFsBlobStore() { return blobFSBlockSize == 0; } /** * Returns the mininum blob size. * @return the mininum blob size. */ public String getMinBlobSize() { return String.valueOf(minBlobSize); } /** * Sets the minimum blob size. This size defines the threshold of which * size a property is included in the bundle or is stored in the blob store. * Very high values decrease the performance. * * @param minBlobSize */ public void setMinBlobSize(String minBlobSize) { this.minBlobSize = Integer.decode(minBlobSize).intValue(); } /** * Sets the error handling behaviour of this manager. See {@link ErrorHandling} * for details about the flags. * * @param errorHandling */ public void setErrorHandling(String errorHandling) { this.errorHandling = new ErrorHandling(errorHandling); } /** * Returns the error handling configuration of this manager * @return the error handling configuration of this manager */ public String getErrorHandling() { return errorHandling.toString(); } /** * {@inheritDoc} */ public void init(PMContext context) throws Exception { if (initialized) { throw new IllegalStateException("already initialized"); } super.init(context); this.name = context.getHomeDir().getName(); // create item fs itemFs = new BasedFileSystem(context.getFileSystem(), "items"); // create correct blob store if (useLocalFsBlobStore()) { LocalFileSystem blobFS = new LocalFileSystem(); blobFS.setRoot(new File(context.getHomeDir(), "blobs")); blobFS.init(); blobStore = new BundleFsPersistenceManager.FSBlobStore(blobFS); } else { blobStore = new BundleFsPersistenceManager.FSBlobStore(itemFs); } // load namespaces binding = new BundleBinding(errorHandling, blobStore, getNsIndex(), getNameIndex(), context.getDataStore()); binding.setMinBlobSize(minBlobSize); initialized = true; } /** * {@inheritDoc} */ @Override protected BLOBStore getBlobStore() { return blobStore; } /** * {@inheritDoc} */ public synchronized void close() throws Exception { if (!initialized) { throw new IllegalStateException("not initialized"); } try { // close blob store blobStore.close(); blobStore = null; itemFs.close(); itemFs = null; super.close(); } finally { initialized = false; } } /** * {@inheritDoc} */ protected NodePropBundle loadBundle(NodeId id) throws ItemStateException { try { String path = buildNodeFilePath(null, id).toString(); if (!itemFs.exists(path)) { return null; } InputStream in = itemFs.getInputStream(path); try { return binding.readBundle(in, id); } finally { IOUtils.closeQuietly(in); } } catch (Exception e) { String msg = "failed to read bundle: " + id + ": " + e; log.error(msg); throw new ItemStateException(msg, e); } } /** * Creates the file path for the given node id that is * suitable for storing node states in a filesystem. * * @param buf buffer to append to or <code>null</code> * @param id the id of the node * @return the buffer with the appended data. */ protected StringBuffer buildNodeFilePath(StringBuffer buf, NodeId id) { if (buf == null) { buf = new StringBuffer(); } buildNodeFolderPath(buf, id); buf.append('.'); buf.append(NODEFILENAME); return buf; } /** * Creates the file path for the given references id that is * suitable for storing reference states in a filesystem. * * @param buf buffer to append to or <code>null</code> * @param id the id of the node * @return the buffer with the appended data. */ protected StringBuffer buildNodeReferencesFilePath(StringBuffer buf, NodeId id) { if (buf == null) { buf = new StringBuffer(); } buildNodeFolderPath(buf, id); buf.append('.'); buf.append(NODEREFSFILENAME); return buf; } /** * {@inheritDoc} */ protected synchronized void storeBundle(NodePropBundle bundle) throws ItemStateException { try { StringBuffer buf = buildNodeFolderPath(null, bundle.getId()); buf.append('.'); buf.append(NODEFILENAME); String fileName = buf.toString(); String dir = fileName.substring(0, fileName.lastIndexOf(FileSystem.SEPARATOR_CHAR)); if (!itemFs.exists(dir)) { itemFs.createFolder(dir); } OutputStream out = itemFs.getOutputStream(fileName); try { binding.writeBundle(out, bundle); } finally { out.close(); } } catch (Exception e) { String msg = "failed to write bundle: " + bundle.getId(); BundleFsPersistenceManager.log.error(msg, e); throw new ItemStateException(msg, e); } } /** * {@inheritDoc} */ protected synchronized void destroyBundle(NodePropBundle bundle) throws ItemStateException { try { StringBuffer buf = buildNodeFilePath(null, bundle.getId()); itemFs.deleteFile(buf.toString()); } catch (Exception e) { if (e instanceof NoSuchItemStateException) { throw (NoSuchItemStateException) e; } String msg = "failed to delete bundle: " + bundle.getId(); BundleFsPersistenceManager.log.error(msg, e); throw new ItemStateException(msg, e); } } /** * {@inheritDoc} */ public synchronized NodeReferences loadReferencesTo(NodeId targetId) throws NoSuchItemStateException, ItemStateException { if (!initialized) { throw new IllegalStateException("not initialized"); } InputStream in = null; try { String path = buildNodeReferencesFilePath(null, targetId).toString(); if (!itemFs.exists(path)) { // special case throw new NoSuchItemStateException(targetId.toString()); } in = itemFs.getInputStream(path); NodeReferences refs = new NodeReferences(targetId); Serializer.deserialize(refs, in); return refs; } catch (NoSuchItemStateException e) { throw e; } catch (Exception e) { String msg = "failed to read references: " + targetId; BundleFsPersistenceManager.log.error(msg, e); throw new ItemStateException(msg, e); } finally { IOUtils.closeQuietly(in); } } /** * {@inheritDoc} */ public synchronized void store(NodeReferences refs) throws ItemStateException { if (!initialized) { throw new IllegalStateException("not initialized"); } try { StringBuffer buf = buildNodeFolderPath(null, refs.getTargetId()); buf.append('.'); buf.append(NODEREFSFILENAME); String fileName = buf.toString(); String dir = fileName.substring(0, fileName.lastIndexOf(FileSystem.SEPARATOR_CHAR)); if (!itemFs.exists(dir)) { itemFs.createFolder(dir); } OutputStream out = itemFs.getOutputStream(fileName); Serializer.serialize(refs, out); out.close(); } catch (Exception e) { String msg = "failed to write " + refs; BundleFsPersistenceManager.log.error(msg, e); throw new ItemStateException(msg, e); } } /** * {@inheritDoc} */ public synchronized void destroy(NodeReferences refs) throws ItemStateException { if (!initialized) { throw new IllegalStateException("not initialized"); } try { StringBuffer buf = buildNodeReferencesFilePath(null, refs.getTargetId()); itemFs.deleteFile(buf.toString()); } catch (Exception e) { if (e instanceof NoSuchItemStateException) { throw (NoSuchItemStateException) e; } String msg = "failed to delete " + refs; BundleFsPersistenceManager.log.error(msg, e); throw new ItemStateException(msg, e); } } /** * {@inheritDoc} */ public synchronized boolean existsReferencesTo(NodeId targetId) throws ItemStateException { if (!initialized) { throw new IllegalStateException("not initialized"); } try { StringBuffer buf = buildNodeReferencesFilePath(null, targetId); return itemFs.exists(buf.toString()); } catch (Exception e) { String msg = "failed to check existence of node references: " + targetId; BundleFsPersistenceManager.log.error(msg, e); throw new ItemStateException(msg, e); } } /** * logs an sql exception * @param message * @param se */ protected void logException(String message, SQLException se) { if (message != null) { BundleFsPersistenceManager.log.error(message); } BundleFsPersistenceManager.log.error(" Reason: " + se.getMessage()); BundleFsPersistenceManager.log.error(" State/Code: " + se.getSQLState() + "/" + se.getErrorCode()); BundleFsPersistenceManager.log.debug(" dump:", se); } /** * @inheritDoc */ public String toString() { return name; } /** * Helper interface for closeable stores */ protected static interface CloseableBLOBStore extends BLOBStore { void close(); } /** * own implementation of the filesystem blob store that uses a different * blob-id scheme. */ private class FSBlobStore extends FileSystemBLOBStore implements BundleFsPersistenceManager.CloseableBLOBStore { private FileSystem fs; public FSBlobStore(FileSystem fs) { super(fs); this.fs = fs; } public String createId(PropertyId id, int index) { return buildBlobFilePath(null, id, index).toString(); } public void close() { try { fs.close(); fs = null; } catch (Exception e) { // ignore } } } /** * {@inheritDoc} */ public List<NodeId> getAllNodeIds(NodeId bigger, int maxCount) throws ItemStateException { ArrayList<NodeId> list = new ArrayList<NodeId>(); try { getListRecursive(list, "", bigger == null ? null : bigger, maxCount); return list; } catch (FileSystemException e) { String msg = "failed to read node list: " + bigger + ": " + e; log.error(msg); throw new ItemStateException(msg, e); } } /** * {@inheritDoc} */ protected NodeId getIdFromFileName(String fileName) { StringBuffer buff = new StringBuffer(35); if (!fileName.endsWith("." + NODEFILENAME)) { return null; } for (int i = 0; i < fileName.length(); i++) { char c = fileName.charAt(i); if (c == '.') { break; } if (c != '/') { buff.append(c); int len = buff.length(); if (len == 8 || len == 13 || len == 18 || len == 23) { buff.append('-'); } } } return new NodeId(buff.toString()); } private void getListRecursive(ArrayList<NodeId> list, String path, NodeId bigger, int maxCount) throws FileSystemException { if (maxCount > 0 && list.size() >= maxCount) { return; } String[] files = itemFs.listFiles(path); Arrays.sort(files); for (int i = 0; i < files.length; i++) { String f = files[i]; NodeId n = getIdFromFileName(path + FileSystem.SEPARATOR + f); if (n == null) { continue; } if (bigger != null && bigger.toString().compareTo(n.toString()) >= 0) { continue; } list.add(n); if (maxCount > 0 && list.size() >= maxCount) { return; } } String[] dirs = itemFs.listFolders(path); Arrays.sort(dirs); for (int i = 0; i < dirs.length; i++) { getListRecursive(list, path + FileSystem.SEPARATOR + dirs[i], bigger, maxCount); } } }