Package nl.knaw.dans.layerstore

Class LayeredItemStore

java.lang.Object
nl.knaw.dans.layerstore.LayeredItemStore
All Implemented Interfaces:
ItemStore
public class LayeredItemStore extends Object implements ItemStore
An implementation of ItemStore that organizes files and directories (Items) in an ordered stack of Layers. Layers are either staged or archived. Staged layers can be mutable. See

To materialize the layered store into a regular directory, unarchive any archived layers to staging directories and then copy those directories into a single target directory from oldest to newest. Files in newer layers overwrite files from older layers.

The LayeredItemStore is backed by a LayerDatabase, enabling storage on media that may be too slow for direct access (e.g., tape). See the LayerDatabase interface for details.

See Also:

  • Method Details

    • getLayerConsistencyChecker

      public LayerConsistencyChecker getLayerConsistencyChecker()
      Returns the internal layer consistency checker.
      Returns:
      the layer consistency checker

    • newTopLayer

      public long newTopLayer() throws IOException
      Creates a new top layer, archiving any existing top layer.
      Returns:
      the id of the new top layer
      Throws:
      IOException - if an I/O error occurs

    • archiveLayer

      public void archiveLayer(long layerId, boolean overwrite)
      Requests the archiving of the layer with the specified id. The operation may be performed asynchronously, so the caller should check the layer's status to determine when the archiving is complete.
      Parameters:
      layerId - the id of the layer to archive
      overwrite - whether to overwrite an existing archive
      Throws:
      IllegalArgumentException - if no layer with the specified id exists

    • closeLayer

      public void closeLayer(long id) throws IOException
      Closes the layer with the given id.
      Parameters:
      id - the layer id
      Throws:
      IOException - if an I/O error occurs

    • getTopLayerId

      public Long getTopLayerId()
      Returns the id of the top layer, or null if there is no top layer.
      Returns:
      the id of the top layer or null

    • getTopLayerSizeInBytes

      public long getTopLayerSizeInBytes() throws IOException
      Returns the size in bytes of the top layer.
      Returns:
      the size in bytes of the top layer
      Throws:
      IOException - if an I/O error occurs

    • getLayerSizeInBytes

      public long getLayerSizeInBytes(long id) throws IOException
      Returns the size in bytes of the layer with the given id.
      Parameters:
      id - the layer id
      Returns:
      the size in bytes
      Throws:
      IOException - if an I/O error occurs

    • listLayerIds

      public List<Long> listLayerIds() throws IOException
      Throws:
      IOException

    • checkSameLayersOnStorageAndDb

      public void checkSameLayersOnStorageAndDb() throws IOException, LayerIdsMismatchException
      Checks that the layers in the database match the layers in the layer manager.
      Throws:
      IOException - if an I/O error occurs while reading from the database or the layer manager
      LayerIdsMismatchException - if the layer ids do not match

    • checkLayerItemRecords

      public void checkLayerItemRecords(long layerId) throws IOException, ItemsMismatchException
      Checks that the items in the database match the items in the layer.
      Parameters:
      layerId - the layer id to check
      Throws:
      IOException - if an I/O error occurs while reading from the layer or the database
      ItemsMismatchException - if the items do not match

    • listDirectory

      public List<Item> listDirectory(String directoryPath) throws IOException
      Description copied from interface: ItemStore
      Returns the items in the given directory, taking into account the complete stack of layers.
      Specified by:
      listDirectory in interface ItemStore
      Parameters:
      directoryPath - the directory path relative to the storage root
      Returns:
      the items in the directory
      Throws:
      NoSuchFileException - if the directory does not exist in any of the layers
      NotDirectoryException - if the path exists but is not a directory
      IOException

    • listRecursive

      public List<Item> listRecursive(String directoryPath) throws IOException
      Description copied from interface: ItemStore
      Returns the files and directories in the given directory and its subdirectories.
      Specified by:
      listRecursive in interface ItemStore
      Parameters:
      directoryPath - the directory path relative to the storage root
      Returns:
      the items in the directory and its subdirectories
      Throws:
      NoSuchFileException - if the directory does not exist in any of the layers
      NotDirectoryException - if the path exists but is not a directory
      IOException

    • existsPathLike

      public boolean existsPathLike(String path)
      Description copied from interface: ItemStore
      Returns whether a path with the given pattern exists in the store.
      Specified by:
      existsPathLike in interface ItemStore
      Parameters:
      path - a path, which may contain the SQL wildcard character '%'
      Returns:
      true if a path exists that matches the pattern, false otherwise

    • readFile

      public InputStream readFile(String path) throws IOException
      Description copied from interface: ItemStore
      Opens an input stream to the file at the given path.
      Specified by:
      readFile in interface ItemStore
      Parameters:
      path - the path of the file relative to the storage root
      Returns:
      an input stream to the file
      Throws:
      IOException - if the file could not be opened

    • writeFile

      public void writeFile(String path, InputStream content) throws IOException
      Description copied from interface: ItemStore
      Writes the given content to the file at the given path. If the file does not exist yet, it is created. Note that this is different from the behavior of io.ocfl.core.storage.common.Storage#write(java.lang.String, byte[], java.lang.String), which throws an exception if the file already exists. Note also that the parent directory of the file must exist prior to this call. It can be created with ItemStore.createDirectories(String)
      Specified by:
      writeFile in interface ItemStore
      Parameters:
      path - the path of the file relative to the storage root
      content - the content to write
      Throws:
      IOException - if the file could not be written

    • moveDirectoryInto

      public void moveDirectoryInto(Path source, String destination) throws IOException
      Description copied from interface: ItemStore
      Moves the directory outside the store into the given destination. The parent of the destination must exist, but the destination itself must not exist yet.
      Specified by:
      moveDirectoryInto in interface ItemStore
      Parameters:
      source - the path of the directory to move
      destination - the path of the destination directory relative to the storage root
      Throws:
      IOException

    • moveDirectoryInternal

      public void moveDirectoryInternal(String source, String destination) throws IOException
      Description copied from interface: ItemStore
      Moves the directory inside the store to the given destination. The destination must not exist yet, but its parent must exist.
      Specified by:
      moveDirectoryInternal in interface ItemStore
      Parameters:
      source - the path of the directory to move relative to the storage root
      destination - the path of the destination directory relative to the storage root
      Throws:
      IOException

    • deleteDirectory

      public void deleteDirectory(String path) throws IOException
      Description copied from interface: ItemStore
      Deletes the directory at the given path, including all its contents.
      Specified by:
      deleteDirectory in interface ItemStore
      Parameters:
      path - the path of the directory relative to the storage root
      Throws:
      IOException

    • deleteFiles

      public void deleteFiles(List<String> paths) throws IOException
      Description copied from interface: ItemStore
      Deletes the files at the given paths.
      Specified by:
      deleteFiles in interface ItemStore
      Parameters:
      paths - the paths of the files relative to the storage root
      Throws:
      IOException

    • createDirectories

      public void createDirectories(String path) throws IOException
      Description copied from interface: ItemStore
      Creates the directory at the specified path, including any necessary but nonexistent parent directories. If the directory already exists, no exception is thrown. If a regular file exists at the given path, a java.nio.FileAlreadyExistsException is thrown.
      Specified by:
      createDirectories in interface ItemStore
      Parameters:
      path - the path of the directory to create, relative to the storage root
      Throws:
      IOException - if an I/O error occurs while creating the directories

    • copyDirectoryOutOf

      public void copyDirectoryOutOf(String source, Path destination) throws IOException
      Description copied from interface: ItemStore
      Copies the contents of a specified directory from the store to a given destination outside the store. The destination directory will be created if it does not exist.
      Specified by:
      copyDirectoryOutOf in interface ItemStore
      Parameters:
      source - the path of the directory to copy, relative to the storage root
      destination - the target filesystem path where the directory content will be copied
      Throws:
      IOException - if an I/O error occurs during the copy process

    • isAllowReadingContentFromArchives

      public boolean isAllowReadingContentFromArchives()

    • setAllowReadingContentFromArchives

      public void setAllowReadingContentFromArchives(boolean allowReadingContentFromArchives)