org.apache.lucene.store

## Class RateLimitedDirectoryWrapper

- java.lang.Object
- - org.apache.lucene.store.Directory
  - - org.apache.lucene.store.RateLimitedDirectoryWrapper

All Implemented Interfaces:
  Closeable, AutoCloseable

    public final class RateLimitedDirectoryWrapper
    extends Directory

A `Directory` wrapper that allows `IndexOutput` rate limiting using `IO context` specific `rate limiters`.

See Also:
  `setRateLimiter(RateLimiter, IOContext.Context)`
WARNING: This API is experimental and might change in incompatible ways in the next release.

### Nested Class Summary

### Nested classes/interfaces inherited from class org.apache.lucene.store.Directory

`Directory.IndexInputSlicer`

### Field Summary

### Fields inherited from class org.apache.lucene.store.Directory

`isOpen, lockFactory`

### Constructor Summary

Constructors
Constructor and Description
`RateLimitedDirectoryWrapper(Directory wrapped)`

### Method Summary

Methods
`void` `clearLock(String name)` Attempt to clear (forcefully unlock and remove) the specified lock.
`void` `close()` Closes the store.
`void` `copy(Directory to, String src, String dest, IOContext context)` Copies the file src to `Directory` to under the new file name dest.
`IndexOutput` `createOutput(String name, IOContext context)` Creates a new, empty file in the directory with the given name.
`Directory.IndexInputSlicer` `createSlicer(String name, IOContext context)` Creates an `Directory.IndexInputSlicer` for the given file name.
`void` `deleteFile(String name)` Removes an existing file in the directory.
`boolean` `fileExists(String name)` Returns true iff a file with the given name exists.
`long` `fileLength(String name)` Returns the length of a file in the directory.
`Directory` `getDelegate()`
`LockFactory` `getLockFactory()` Get the LockFactory that this Directory instance is using for its locking implementation.
`String` `getLockID()` Return a string identifier that uniquely differentiates this Directory instance from other Directory instances.
`Double` `getMaxWriteMBPerSec(IOContext.Context context)` See `setMaxWriteMBPerSec(java.lang.Double, org.apache.lucene.store.IOContext.Context)`.
`String[]` `listAll()` Returns an array of strings, one for each file in the directory.
`Lock` `makeLock(String name)` Construct a `Lock`.
`IndexInput` `openInput(String name, IOContext context)` Returns a stream reading an existing file, with the specified read buffer size.
`void` `setLockFactory(LockFactory lockFactory)` Set the LockFactory that this Directory instance should use for its locking implementation.
`void` `setMaxWriteMBPerSec(Double mbPerSec, IOContext.Context context)` Sets the maximum (approx) MB/sec allowed by all write IO performed by `IndexOutput` created with the given `IOContext.Context`.
`void` `setRateLimiter(RateLimiter mergeWriteRateLimiter, IOContext.Context context)` Sets the rate limiter to be used to limit (approx) MB/sec allowed by all IO performed with the given `context`.
`void` `sync(Collection<String> names)` Ensure that any writes to these files are moved to stable storage.
`String` `toString()`

### Methods inherited from class org.apache.lucene.store.Directory

`ensureOpen`

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

### Constructor Detail

#### RateLimitedDirectoryWrapper

    public RateLimitedDirectoryWrapper(Directory wrapped)

### Method Detail

#### getDelegate

    public Directory getDelegate()

#### listAll

    public String[] listAll()
                     throws IOException

Description copied from class: `Directory`
Returns an array of strings, one for each file in the directory.

Specified by:
  `listAll` in class `Directory`
Throws:
  `NoSuchDirectoryException` - if the directory is not prepared for any write operations (such as `Directory.createOutput(String, IOContext)`).
  `IOException` - in case of other IO errors

#### fileExists

    public boolean fileExists(String name)
                       throws IOException

Description copied from class: `Directory`
Returns true iff a file with the given name exists.

Specified by:
  `fileExists` in class `Directory`
Throws:
  `IOException`

#### deleteFile

    public void deleteFile(String name)
                    throws IOException

Description copied from class: `Directory`
Removes an existing file in the directory.

Specified by:
  `deleteFile` in class `Directory`
Throws:
  `IOException`

#### fileLength

    public long fileLength(String name)
                    throws IOException

Description copied from class: `Directory`
Returns the length of a file in the directory. This method follows the following contract:

- Throws `FileNotFoundException` if the file does not exist
- Returns a value ≥0 if the file exists, which specifies its length.

Specified by:
  `fileLength` in class `Directory`
Parameters:
  `name` - the name of the file for which to return the length.
Throws:
  `FileNotFoundException` - if the file does not exist.
  `IOException` - if there was an IO error while retrieving the file's length.

#### createOutput

    public IndexOutput createOutput(String name,
                           IOContext context)
                             throws IOException

Description copied from class: `Directory`
Creates a new, empty file in the directory with the given name. Returns a stream writing this file.

Specified by:
  `createOutput` in class `Directory`
Throws:
  `IOException`

#### sync

    public void sync(Collection<String> names)
              throws IOException

Description copied from class: `Directory`
Ensure that any writes to these files are moved to stable storage. Lucene uses this to properly commit changes to the index, to prevent a machine/OS crash from corrupting the index.
NOTE: Clients may call this method for same files over and over again, so some impls might optimize for that. For other impls the operation can be a noop, for various reasons.

Specified by:
  `sync` in class `Directory`
Throws:
  `IOException`

#### openInput

    public IndexInput openInput(String name,
                       IOContext context)
                         throws IOException

Description copied from class: `Directory`
Returns a stream reading an existing file, with the specified read buffer size. The particular Directory implementation may ignore the buffer size. Currently the only Directory implementations that respect this parameter are `FSDirectory` and `CompoundFileDirectory`.

Specified by:
  `openInput` in class `Directory`
Throws:
  `IOException`

#### close

    public void close()
               throws IOException

Description copied from class: `Directory`
Closes the store.

Specified by:
  `close` in interface `Closeable`
Specified by:
  `close` in interface `AutoCloseable`
Specified by:
  `close` in class `Directory`
Throws:
  `IOException`

#### createSlicer

    public Directory.IndexInputSlicer createSlicer(String name,
                                          IOContext context)
                                            throws IOException

Description copied from class: `Directory`
Creates an `Directory.IndexInputSlicer` for the given file name. IndexInputSlicer allows other `Directory` implementations to efficiently open one or more sliced `IndexInput` instances from a single file handle. The underlying file handle is kept open until the `Directory.IndexInputSlicer` is closed.

Overrides:
  `createSlicer` in class `Directory`
Throws:
  `IOException` - if an `IOException` occurs

#### makeLock

    public Lock makeLock(String name)

Description copied from class: `Directory`
Construct a `Lock`.

Overrides:
  `makeLock` in class `Directory`
Parameters:
  `name` - the name of the lock file

#### clearLock

    public void clearLock(String name)
                   throws IOException

Description copied from class: `Directory`
Attempt to clear (forcefully unlock and remove) the specified lock. Only call this at a time when you are certain this lock is no longer in use.

Overrides:
  `clearLock` in class `Directory`
Parameters:
  `name` - name of the lock to be cleared.
Throws:
  `IOException`

#### setLockFactory

    public void setLockFactory(LockFactory lockFactory)
                        throws IOException

Description copied from class: `Directory`
Set the LockFactory that this Directory instance should use for its locking implementation. Each * instance of LockFactory should only be used for one directory (ie, do not share a single instance across multiple Directories).

Overrides:
  `setLockFactory` in class `Directory`
Parameters:
  `lockFactory` - instance of `LockFactory`.
Throws:
  `IOException`

#### getLockFactory

    public LockFactory getLockFactory()

Description copied from class: `Directory`
Get the LockFactory that this Directory instance is using for its locking implementation. Note that this may be null for Directory implementations that provide their own locking implementation.

Overrides:
  `getLockFactory` in class `Directory`

#### getLockID

    public String getLockID()

Description copied from class: `Directory`
Return a string identifier that uniquely differentiates this Directory instance from other Directory instances. This ID should be the same if two Directory instances (even in different JVMs and/or on different machines) are considered "the same index". This is how locking "scopes" to the right index.

Overrides:
  `getLockID` in class `Directory`

#### toString

    public String toString()

Overrides:
  `toString` in class `Directory`

#### copy

    public void copy(Directory to,
            String src,
            String dest,
            IOContext context)
              throws IOException

Description copied from class: `Directory`
Copies the file src to `Directory` to under the new file name dest.

If you want to copy the entire source directory to the destination one, you can do so like this:

     Directory to; // the directory to copy to
     for (String file : dir.listAll()) {
       dir.copy(to, file, newFile); // newFile can be either file, or a new name
     }

NOTE: this method does not check whether dest exist and will overwrite it if it does.

Overrides:
  `copy` in class `Directory`
Throws:
  `IOException`

#### setMaxWriteMBPerSec

    public void setMaxWriteMBPerSec(Double mbPerSec,
                           IOContext.Context context)

Sets the maximum (approx) MB/sec allowed by all write IO performed by `IndexOutput` created with the given `IOContext.Context`. Pass `null` to have no limit.

NOTE: For already created `IndexOutput` instances there is no guarantee this new rate will apply to them; it will only be guaranteed to apply for new created `IndexOutput` instances.

NOTE: this is an optional operation and might not be respected by all Directory implementations. Currently only `buffered` Directory implementations use rate-limiting.

Throws:
  `IllegalArgumentException` - if context is `null`
  `AlreadyClosedException` - if the `Directory` is already closed
WARNING: This API is experimental and might change in incompatible ways in the next release.

#### setRateLimiter

    public void setRateLimiter(RateLimiter mergeWriteRateLimiter,
                      IOContext.Context context)

Sets the rate limiter to be used to limit (approx) MB/sec allowed by all IO performed with the given `context`. Pass `null` to have no limit.

Passing an instance of rate limiter compared to setting it using `setMaxWriteMBPerSec(Double, IOContext.Context)` allows to use the same limiter instance across several directories globally limiting IO across them.

Throws:
  `IllegalArgumentException` - if context is `null`
  `AlreadyClosedException` - if the `Directory` is already closed
WARNING: This API is experimental and might change in incompatible ways in the next release.

#### getMaxWriteMBPerSec

    public Double getMaxWriteMBPerSec(IOContext.Context context)

See `setMaxWriteMBPerSec(java.lang.Double, org.apache.lucene.store.IOContext.Context)`.

Throws:
  `IllegalArgumentException` - if context is `null`
  `AlreadyClosedException` - if the `Directory` is already closed
WARNING: This API is experimental and might change in incompatible ways in the next release.