import org.apache.lucene.store.IOContext.Context; //导入依赖的package包/类
/**
 * Sets the maximum (approx) MB/sec allowed by all write IO performed by
 * {@link IndexOutput} created with the given {@link IOContext.Context}. Pass
 * <code>null</code> to have no limit.
 * 
 * <p>
 * <b>NOTE</b>: For already created {@link IndexOutput} instances there is no
 * guarantee this new rate will apply to them; it will only be guaranteed to
 * apply for new created {@link IndexOutput} instances.
 * <p>
 * <b>NOTE</b>: this is an optional operation and might not be respected by
 * all Directory implementations. Currently only {@link FSDirectory buffered}
 * Directory implementations use rate-limiting.
 * 
 * @throws IllegalArgumentException
 *           if context is <code>null</code>
 * @throws AlreadyClosedException if the {@link Directory} is already closed
 * @lucene.experimental
 */
public void setMaxWriteMBPerSec(Double mbPerSec, IOContext.Context context) {
  ensureOpen();
  if (context == null) {
    throw new IllegalArgumentException("Context must not be null");
  }
  final int ord = context.ordinal();
  final RateLimiter limiter = contextRateLimiters[ord];
  if (mbPerSec == null) {
    if (limiter != null) {
      limiter.setMbPerSec(Double.MAX_VALUE);
      contextRateLimiters[ord] = null;
    }
  } else if (limiter != null) {
    limiter.setMbPerSec(mbPerSec);
    contextRateLimiters[ord] = limiter; // cross the mem barrier again
  } else {
    contextRateLimiters[ord] = new RateLimiter.SimpleRateLimiter(mbPerSec);
  }
}
 

import org.apache.lucene.store.IOContext.Context; //导入依赖的package包/类
@Override
public IndexOutput createOutput(String name, IOContext context) throws IOException {
    final IndexOutput output = in.createOutput(name, context);

    StoreRateLimiting rateLimiting = rateLimitingProvider.rateLimiting();
    StoreRateLimiting.Type type = rateLimiting.getType();
    RateLimiter limiter = rateLimiting.getRateLimiter();
    if (type == StoreRateLimiting.Type.NONE || limiter == null) {
        return output;
    }
    if (context.context == Context.MERGE || type == StoreRateLimiting.Type.ALL) {
        // we are merging, and type is either MERGE or ALL, rate limit...
        return new RateLimitedIndexOutput(new RateLimiterWrapper(limiter, rateListener), output);
    }
    // we shouldn't really get here...
    return output;
}
 

import org.apache.lucene.store.IOContext.Context; //导入依赖的package包/类
/**
 * See {@link #setMaxWriteMBPerSec}.
 * 
 * @throws IllegalArgumentException
 *           if context is <code>null</code>
 * @throws AlreadyClosedException if the {@link Directory} is already closed
 * @lucene.experimental
 */
public Double getMaxWriteMBPerSec(IOContext.Context context) {
  ensureOpen();
  if (context == null) {
    throw new IllegalArgumentException("Context must not be null");
  }
  RateLimiter limiter = getRateLimiter(context);
  return limiter == null ? null : limiter.getMbPerSec();
}
 

import org.apache.lucene.store.IOContext.Context; //导入依赖的package包/类
public CompletionFieldsProducer(SegmentReadState state) throws IOException {
    String suggestFSTFile = IndexFileNames.segmentFileName(state.segmentInfo.name, state.segmentSuffix, EXTENSION);
    IndexInput input = state.directory.openInput(suggestFSTFile, state.context);
    version = CodecUtil.checkHeader(input, CODEC_NAME, SUGGEST_CODEC_VERSION, SUGGEST_VERSION_CURRENT);
    FieldsProducer delegateProducer = null;
    boolean success = false;
    try {
        PostingsFormat delegatePostingsFormat = PostingsFormat.forName(input.readString());
        String providerName = input.readString();
        CompletionLookupProvider completionLookupProvider = providers.get(providerName);
        if (completionLookupProvider == null) {
            throw new IllegalStateException("no provider with name [" + providerName + "] registered");
        }
        // TODO: we could clone the ReadState and make it always forward IOContext.MERGE to prevent unecessary heap usage?
        delegateProducer = delegatePostingsFormat.fieldsProducer(state);
        /*
         * If we are merging we don't load the FSTs at all such that we
         * don't consume so much memory during merge
         */
        if (state.context.context != Context.MERGE) {
            // TODO: maybe we can do this in a fully lazy fashion based on some configuration
            // eventually we should have some kind of curciut breaker that prevents us from going OOM here
            // with some configuration
            this.lookupFactory = completionLookupProvider.load(input);
        } else {
            this.lookupFactory = null;
        }
        this.delegateProducer = delegateProducer;
        success = true;
    } finally {
        if (!success) {
            IOUtils.closeWhileHandlingException(delegateProducer, input);
        } else {
            IOUtils.close(input);
        }
    }
}
 

import org.apache.lucene.store.IOContext.Context; //导入依赖的package包/类
@Override
public IndexInput openInput(String name, IOContext context) throws IOException {
  ensureOpen();
  if (context.context != Context.MERGE || context.mergeInfo.estimatedMergeBytes < minBytesDirect || fileLength(name) < minBytesDirect) {
    return delegate.openInput(name, context);
  } else {
    return new NativeUnixIndexInput(new File(getDirectory(), name), mergeBufferSize);
  }
}
 

import org.apache.lucene.store.IOContext.Context; //导入依赖的package包/类
@Override
public IndexOutput createOutput(String name, IOContext context) throws IOException {
  ensureOpen();
  if (context.context != Context.MERGE || context.mergeInfo.estimatedMergeBytes < minBytesDirect) {
    return delegate.createOutput(name, context);
  } else {
    ensureCanWrite(name);
    return new NativeUnixIndexOutput(new File(getDirectory(), name), mergeBufferSize);
  }
}
 

import org.apache.lucene.store.IOContext.Context; //导入依赖的package包/类
private static BaseDirectoryWrapper wrapDirectory(Random random, Directory directory, boolean bare) {
  if (rarely(random)) {
    directory = new NRTCachingDirectory(directory, random.nextDouble(), random.nextDouble());
  }
  
  if (rarely(random)) { 
    final double maxMBPerSec = 10 + 5*(random.nextDouble()-0.5);
    if (LuceneTestCase.VERBOSE) {
      System.out.println("LuceneTestCase: will rate limit output IndexOutput to " + maxMBPerSec + " MB/sec");
    }
    final RateLimitedDirectoryWrapper rateLimitedDirectoryWrapper = new RateLimitedDirectoryWrapper(directory);
    switch (random.nextInt(10)) {
      case 3: // sometimes rate limit on flush
        rateLimitedDirectoryWrapper.setMaxWriteMBPerSec(maxMBPerSec, Context.FLUSH);
        break;
      case 2: // sometimes rate limit flush & merge
        rateLimitedDirectoryWrapper.setMaxWriteMBPerSec(maxMBPerSec, Context.FLUSH);
        rateLimitedDirectoryWrapper.setMaxWriteMBPerSec(maxMBPerSec, Context.MERGE);
        break;
      default:
        rateLimitedDirectoryWrapper.setMaxWriteMBPerSec(maxMBPerSec, Context.MERGE);
    }
    directory =  rateLimitedDirectoryWrapper;
    
  }

  if (bare) {
    BaseDirectoryWrapper base = new BaseDirectoryWrapper(directory);
    closeAfterSuite(new CloseableDirectory(base, suiteFailureMarker));
    return base;
  } else {
    MockDirectoryWrapper mock = new MockDirectoryWrapper(random, directory);
    
    mock.setThrottling(TEST_THROTTLING);
    closeAfterSuite(new CloseableDirectory(mock, suiteFailureMarker));
    return mock;
  }
}
 

import org.apache.lucene.store.IOContext.Context; //导入依赖的package包/类
private RateLimiter getRateLimiter(IOContext.Context context) {
  assert context != null;
  return contextRateLimiters[context.ordinal()];
}
 

import org.apache.lucene.store.IOContext.Context; //导入依赖的package包/类
public @Bean Directory trainingSetDirectory() throws IOException {
    FSDirectory directory = FSDirectory.open(Paths.get(trainingSetCollectionPath));
    return new RAMDirectory(directory, new IOContext(Context.DEFAULT));
}
 

import org.apache.lucene.store.IOContext.Context; //导入依赖的package包/类
public @Bean Directory iaViewDirectory() throws IOException {
    FSDirectory directory = FSDirectory.open(Paths.get(iaviewCollectionPath));
    return new RAMDirectory(directory, new IOContext(Context.DEFAULT));
}