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
    Modifier and Type | Method and Description
    --- | ---
    `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.

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