Add skeleton structure for WritableWarm Directories and IndexInputs (opensearch-project#21082)

Signed-off-by: Kavya Aggarwal <kavyaagg@amazon.com>

Author: GeekGlider

server/src/main/java/org/opensearch/storage/directory/TieredDirectory.java

@@ -0,0 +1,38 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.storage.directory;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.lucene.store.Directory;
+import org.opensearch.index.store.CompositeDirectory;
+import org.opensearch.index.store.remote.filecache.FileCache;
+import org.opensearch.threadpool.ThreadPool;
+
+/**
+ * Extension of CompositeDirectory to support writable warm and other related features.
+ * TieredStoragePrefetchSettings dependency will be added in the implementation PR.
+ * Directory overrides (listAll, deleteFile, rename, openInput, close, sync, afterSyncToRemote),
+ * file caching, and full-file-to-block switching logic will be added in the implementation PR.
+ */
+public class TieredDirectory extends CompositeDirectory {
+
+    private static final Logger logger = LogManager.getLogger(TieredDirectory.class);
+
+    /**
+     * Constructs a new TieredDirectory.
+     * @param localDirectory the local directory
+     * @param remoteDirectory the remote directory
+     * @param fileCache the file cache
+     * @param threadPool the thread pool
+     */
+    public TieredDirectory(Directory localDirectory, Directory remoteDirectory, FileCache fileCache, ThreadPool threadPool) {
+        super(localDirectory, remoteDirectory, fileCache, threadPool);
+    }
+}

server/src/main/java/org/opensearch/storage/directory/TieredDirectoryFactory.java

@@ -0,0 +1,45 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.storage.directory;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.lucene.store.Directory;
+import org.opensearch.index.IndexSettings;
+import org.opensearch.index.shard.ShardPath;
+import org.opensearch.index.store.remote.filecache.FileCache;
+import org.opensearch.plugins.IndexStorePlugin;
+import org.opensearch.threadpool.ThreadPool;
+
+import java.io.IOException;
+
+/**
+ * Factory to create TieredDirectory.
+ * TieredStoragePrefetchSettings dependency will be added in the implementation PR.
+ * The newDirectory implementation will be added in the implementation PR.
+ */
+public class TieredDirectoryFactory implements IndexStorePlugin.CompositeDirectoryFactory {
+
+    private static final Logger logger = LogManager.getLogger(TieredDirectoryFactory.class);
+
+    /** Constructs a new TieredDirectoryFactory. */
+    public TieredDirectoryFactory() {}
+
+    @Override
+    public Directory newDirectory(
+        IndexSettings indexSettings,
+        ShardPath shardPath,
+        IndexStorePlugin.DirectoryFactory directoryFactory,
+        Directory directory,
+        FileCache fileCache,
+        ThreadPool threadPool
+    ) throws IOException {
+        throw new UnsupportedOperationException("Not yet implemented");
+    }
+}

server/src/main/java/org/opensearch/storage/directory/package-info.java

@@ -0,0 +1,10 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+/** Directory implementations for tiered storage. */
+package org.opensearch.storage.directory;

server/src/main/java/org/opensearch/storage/indexinput/BlockFetchRequest.java

@@ -0,0 +1,165 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.storage.indexinput;
+
+import org.apache.lucene.store.Directory;
+import org.apache.lucene.store.FSDirectory;
+import org.opensearch.common.annotation.ExperimentalApi;
+
+import java.nio.file.Path;
+
+/**
+ * Class to represent a fetch request for a block of a file.
+ * Field names: directory, fileName, blockFileName, blockStart, blockSize, filePath.
+ * Builder pattern and getters will be added in the implementation PR.
+ */
+@ExperimentalApi
+public class BlockFetchRequest {
+
+    private final Directory directory;
+    private final String fileName;
+    private final String blockFileName;
+    private final long blockStart;
+    private final long blockSize;
+    private final Path filePath;
+
+    private BlockFetchRequest(Builder builder) {
+        this.fileName = builder.fileName;
+        this.blockFileName = builder.blockFileName;
+        this.filePath = builder.directory.getDirectory().resolve(blockFileName);
+        this.directory = builder.directory;
+        this.blockSize = builder.blockSize;
+        this.blockStart = builder.blockStart;
+    }
+
+    /**
+     * Creates a new Builder.
+     * @return a new Builder
+     */
+    public static Builder builder() {
+        return new Builder();
+    }
+
+    /**
+     * Returns the file path.
+     * @return the file path
+     */
+    public Path getFilePath() {
+        return filePath;
+    }
+
+    /**
+     * Returns the directory.
+     * @return the directory
+     */
+    public Directory getDirectory() {
+        return directory;
+    }
+
+    /**
+     * Returns the file name.
+     * @return the file name
+     */
+    public String getFileName() {
+        return fileName;
+    }
+
+    /**
+     * Returns the block file name.
+     * @return the block file name
+     */
+    public String getBlockFileName() {
+        return blockFileName;
+    }
+
+    /**
+     * Returns the block size.
+     * @return the block size
+     */
+    public long getBlockSize() {
+        return blockSize;
+    }
+
+    /**
+     * Returns the block start.
+     * @return the block start
+     */
+    public long getBlockStart() {
+        return blockStart;
+    }
+
+    /**
+    * Builder for BlobFetchRequest
+    */
+    @ExperimentalApi
+    public static final class Builder {
+        private FSDirectory directory;
+        private String fileName;
+        private String blockFileName;
+        private long blockSize;
+        private long blockStart;
+
+        private Builder() {}
+
+        /**
+         * Sets the directory.
+         * @param directory the directory
+         * @return this builder
+         */
+        public Builder directory(FSDirectory directory) {
+            this.directory = directory;
+            return this;
+        }
+
+        /**
+         * Sets the file name.
+         * @param fileName the file name
+         * @return this builder
+         */
+        public Builder fileName(String fileName) {
+            this.fileName = fileName;
+            return this;
+        }
+
+        /**
+         * Sets the block file name.
+         * @param blockFileName the block file name
+         * @return this builder
+         */
+        public Builder blockFileName(String blockFileName) {
+            this.blockFileName = blockFileName;
+            return this;
+        }
+
+        /**
+         * Sets the block size.
+         * @param blockSize the block size
+         * @return this builder
+         */
+        public Builder blockSize(long blockSize) {
+            this.blockSize = blockSize;
+            return this;
+        }
+
+        /**
+         * Sets the block start.
+         * @param blockStart the block start
+         * @return this builder
+         */
+        public Builder blockStart(long blockStart) {
+            this.blockStart = blockStart;
+            return this;
+        }
+
+        /** Builds the BlockFetchRequest. @return the built request */
+        public BlockFetchRequest build() {
+            return new BlockFetchRequest(this);
+        }
+    }
+}

server/src/main/java/org/opensearch/storage/indexinput/BlockIndexInput.java

@@ -0,0 +1,59 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.storage.indexinput;
+
+import org.apache.lucene.store.FSDirectory;
+import org.apache.lucene.store.IOContext;
+import org.apache.lucene.store.IndexInput;
+import org.opensearch.index.store.remote.file.AbstractBlockIndexInput;
+
+/**
+ * A virtual index input backed by block files downloaded from remote store.
+ * Block files are a sequence of bytes of fixed block size belonging to a segment file.
+ * Clone, slice, fetchBlock, and Builder will be added in the implementation PR.
+ */
+public class BlockIndexInput extends AbstractBlockIndexInput {
+
+    /** The file name. */
+    protected final String fileName;
+    /** The size of the file. */
+    protected final long fileSize;
+    /** The underlying Lucene directory. */
+    protected final FSDirectory directory;
+    /** The IO context. */
+    protected final IOContext context;
+
+    // Placeholder constructor. Real constructor via Builder will be added in the implementation PR.
+    BlockIndexInput(AbstractBlockIndexInput.Builder<?> builder) {
+        super(builder);
+        this.fileName = null;
+        this.fileSize = 0;
+        this.directory = null;
+        this.context = null;
+    }
+
+    @Override
+    public BlockIndexInput clone() {
+        throw new UnsupportedOperationException("Not yet implemented");
+    }
+
+    @Override
+    public IndexInput slice(String sliceDescription, long offset, long length) {
+        throw new UnsupportedOperationException("Not yet implemented");
+    }
+
+    @Override
+    protected IndexInput fetchBlock(int blockId) {
+        throw new UnsupportedOperationException("Not yet implemented");
+    }
+
+    public BlockIndexInput buildSlice(String sliceDescription, long offset, long length) {
+        throw new UnsupportedOperationException("Not yet implemented");
+    }
+}

server/src/main/java/org/opensearch/storage/indexinput/CachedSwitchableIndexInput.java

@@ -0,0 +1,52 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.storage.indexinput;
+
+import org.apache.lucene.store.IndexInput;
+import org.opensearch.index.store.remote.filecache.CachedIndexInput;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/**
+ * CachedIndexInput implementation that wraps a SwitchableIndexInput for use with FileCache.
+ * Constructor will accept FileCache, fileName, localDirectory, remoteDirectory, transferManager,
+ * cacheFromRemote flag, threadPool, and tieredStoragePrefetchSettingsSupplier.
+ * getIndexInput, length, isClosed, and close will be added in the implementation PR.
+ */
+public class CachedSwitchableIndexInput implements CachedIndexInput {
+
+    private final SwitchableIndexInput switchableIndexInput;
+    private final AtomicBoolean isClosed;
+
+    // Placeholder constructor. Real constructor will be added in the implementation PR.
+    CachedSwitchableIndexInput() {
+        this.switchableIndexInput = null;
+        this.isClosed = new AtomicBoolean(false);
+    }
+
+    @Override
+    public IndexInput getIndexInput() {
+        throw new UnsupportedOperationException("Not yet implemented");
+    }
+
+    @Override
+    public long length() {
+        throw new UnsupportedOperationException("Not yet implemented");
+    }
+
+    @Override
+    public boolean isClosed() {
+        throw new UnsupportedOperationException("Not yet implemented");
+    }
+
+    @Override
+    public void close() {
+        throw new UnsupportedOperationException("Not yet implemented");
+    }
+}