## org.apache.lucene.store
Class RateLimitedDirectoryWrapper

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

All Implemented Interfaces:
  Closeable

    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
`RateLimitedDirectoryWrapper(Directory wrapped)`

Method Summary
`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 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.

Copyright © 2000-2013 Apache Software Foundation. All Rights Reserved.