How to use

DirectoryImplementor

in

org.infinispan.lucene.impl

/**
* @param metadataCache the cache to be used for all smaller metadata: prefer replication over distribution, avoid eviction
* @param chunksCache the cache to use for the space consuming segments: prefer distribution, enable eviction if needed
* @param distLocksCache the cache to use for locks, to avoid more than one process to write to the index
* @param indexName the unique index name, useful to store multiple indexes in the same caches
* @param lf the LockFactory to be used by IndexWriters. @see org.infinispan.lucene.locking
* @param chunkSize segments are fragmented in chunkSize bytes; larger values are more efficient for searching but less for distribution and network replication
* @param readLocker @see org.infinispan.lucene.readlocks for some implementations; you might be able to provide more efficient implementations by controlling the IndexReader's lifecycle.
* @param fileListUpdatedAsync When true, the writes to the list of currently existing files in the Directory will use the putAsync method rather than put.
* @param deleteExecutor The Executor to run file deletes in the background
* @param affinitySegmentId A hint interpreted by the consistent hashing function to force locality with a specific segment identifier
*/
public DirectoryLucene(Cache<?, ?> metadataCache, Cache<?, ?> chunksCache, Cache<?, ?> distLocksCache, String indexName, LockFactory lf, int chunkSize, SegmentReadLocker readLocker, boolean fileListUpdatedAsync, Executor deleteExecutor, int affinitySegmentId) {
 this.deleteExecutor = deleteExecutor;
 this.affinitySegmentId = affinitySegmentId;
 this.impl = new DirectoryImplementor(metadataCache, chunksCache, distLocksCache, indexName, chunkSize, readLocker, fileListUpdatedAsync, affinitySegmentId);
 this.indexName = indexName;
 this.lockFactory = lf;
}

/**
* {@inheritDoc}
*/
@Override
public IndexOutput createOutput(final String name, final IOContext context) throws IOException {
 return impl.createOutput(name);
}

 @Override
 public void run() {
   impl.deleteFile(fileName);
 }
}

/**
* {@inheritDoc}
*/
@Override
public void renameFile(final String from, final String to) {
 impl.renameFile(from, to);
}

/**
* {@inheritDoc}
*/
@Override
public long fileLength(final String name) {
 ensureOpen();
 return impl.fileLength(name);
}

/**
* {@inheritDoc}
*/
@Override
public String[] listAll() {
 return impl.list();
}

/**
* {@inheritDoc}
*/
@Override
public IndexInput openInput(final String name, final IOContext context) throws IOException {
 final IndexInputContext indexInputContext = impl.openInput(name);
 if (indexInputContext.readLocks == null) {
   return new SingleChunkIndexInput(indexInputContext);
 } else {
   return new InfinispanIndexInput(indexInputContext);
 }
}

void deleteFile(final String name) {
  fileOps.deleteFileName(name);
  readLocks.deleteOrReleaseReadLock(name);
  if (log.isDebugEnabled()) {
   log.debugf("Removed file: %s from index: %s from %s", name, indexName, getAddress(chunksCache));
  }
}

/**
* {@inheritDoc}
*/
@Override
public boolean fileExists(final String name) {
 ensureOpen();
 return impl.fileExists(name);
}

@Override
public int getChunkSize() {
 return impl.getChunkSize();
}

/**
* {@inheritDoc}
*/
@Override
public void renameFile(final String from, final String to) {
 impl.renameFile(from, to);
}

/**
* {@inheritDoc}
*/
@Override
public long fileLength(final String name) {
 ensureOpen();
 return impl.fileLength(name);
}

/**
* {@inheritDoc}
*/
@Override
public String[] listAll() {
 return impl.list();
}

/**
* {@inheritDoc}
*/
@Override
public IndexInput openInput(final String name, final IOContext context) throws IOException {
 final IndexInputContext indexInputContext = impl.openInput(name);
 if (indexInputContext.readLocks == null) {
   return new SingleChunkIndexInput(indexInputContext);
 } else {
   return new InfinispanIndexInput(indexInputContext);
 }
}

IndexOutput createOutput(final String name) {
  if(log.isDebugEnabled()) {
   log.tracef("Creating output file %s in index %s from %s", name, indexName,  getAddress(metadataCache));
  }
  if (IndexFileNames.SEGMENTS.equals(name)) {
   return new InfinispanIndexOutput(metadataCache, chunksCache, segmentsGenFileKey, chunkSize, fileOps, affinitySegmentId);
  }
  else {
   final FileCacheKey key = new FileCacheKey(indexName, name, affinitySegmentId);
   // creating new file, metadata is added on flush() or close() of
   // IndexOutPut
   return new InfinispanIndexOutput(metadataCache, chunksCache, key, chunkSize, fileOps, affinitySegmentId);
  }
}

/**
* {@inheritDoc}
*/
@Override
public boolean fileExists(final String name) {
 ensureOpen();
 return impl.fileExists(name);
}

@Override
public int getChunkSize() {
 return impl.getChunkSize();
}

/**
* {@inheritDoc}
*/
@Override
public IndexOutput createOutput(final String name, final IOContext context) throws IOException {
 return impl.createOutput(name);
}

/**
* {@inheritDoc}
*/
@Override
public void renameFile(final String from, final String to) {
 impl.renameFile(from, to);
}

/**
* {@inheritDoc}
*/
@Override
public long fileLength(final String name) {
 ensureOpen();
 return impl.fileLength(name);
}