How to use org.apache.rocketmq.store.config

/**
 * Enable transient commitLog store pool only if transientStorePoolEnable is true and the FlushDiskType is
 * ASYNC_FLUSH
 *
 * @return <tt>true</tt> or <tt>false</tt>
 */
public boolean isTransientStorePoolEnable() {
  return transientStorePoolEnable && FlushDiskType.ASYNC_FLUSH == getFlushDiskType()
    && BrokerRole.SLAVE != getBrokerRole();
}

private boolean checkInDiskByCommitOffset(long offsetPy, long maxOffsetPy) {
  long memory = (long) (StoreUtil.TOTAL_PHYSICAL_MEMORY_SIZE * (this.messageStoreConfig.getAccessMessageInMemoryMaxRatio() / 100.0));
  return (maxOffsetPy - offsetPy) > memory;
}

public void setBrokerRole(String brokerRole) {
  this.brokerRole = BrokerRole.valueOf(brokerRole);
}

private String diskUtil() {
  String storePathPhysic = this.brokerController.getMessageStoreConfig().getStorePathCommitLog();
  double physicRatio = UtilAll.getDiskPartitionSpaceUsedPercent(storePathPhysic);
  String storePathLogis =
    StorePathConfigHelper.getStorePathConsumeQueue(this.brokerController.getMessageStoreConfig().getStorePathRootDir());
  double logisRatio = UtilAll.getDiskPartitionSpaceUsedPercent(storePathLogis);
  String storePathIndex =
    StorePathConfigHelper.getStorePathIndex(this.brokerController.getMessageStoreConfig().getStorePathRootDir());
  double indexRatio = UtilAll.getDiskPartitionSpaceUsedPercent(storePathIndex);
  return String.format("CL: %5.2f CQ: %5.2f INDEX: %5.2f", physicRatio, logisRatio, indexRatio);
}

public IndexService(final DefaultMessageStore store) {
  this.defaultMessageStore = store;
  this.hashSlotNum = store.getMessageStoreConfig().getMaxHashSlotNum();
  this.indexNum = store.getMessageStoreConfig().getMaxIndexNum();
  this.storePath =
    StorePathConfigHelper.getStorePathIndex(store.getMessageStoreConfig().getStorePathRootDir());
}

private boolean isTheBatchFull(int sizePy, int maxMsgNums, int bufferTotal, int messageTotal, boolean isInDisk) {
  if (0 == bufferTotal || 0 == messageTotal) {
    return false;
  }
  if (maxMsgNums <= messageTotal) {
    return true;
  }
  if (isInDisk) {
    if ((bufferTotal + sizePy) > this.messageStoreConfig.getMaxTransferBytesOnMessageInDisk()) {
      return true;
    }
    if (messageTotal > this.messageStoreConfig.getMaxTransferCountOnMessageInDisk() - 1) {
      return true;
    }
  } else {
    if ((bufferTotal + sizePy) > this.messageStoreConfig.getMaxTransferBytesOnMessageInMemory()) {
      return true;
    }
    if (messageTotal > this.messageStoreConfig.getMaxTransferCountOnMessageInMemory() - 1) {
      return true;
    }
  }
  return false;
}

@Override
public String configFilePath() {
  return StorePathConfigHelper.getDelayOffsetStorePath(this.defaultMessageStore.getMessageStoreConfig()
    .getStorePathRootDir());
}

private long nextOffsetCorrection(long oldOffset, long newOffset) {
  long nextOffset = oldOffset;
  if (this.getMessageStoreConfig().getBrokerRole() != BrokerRole.SLAVE || this.getMessageStoreConfig().isOffsetCheckInSlave()) {
    nextOffset = newOffset;
  }
  return nextOffset;
}

public void destroy() {
  this.destroyLogics();
  this.commitLog.destroy();
  this.indexService.destroy();
  this.deleteFile(StorePathConfigHelper.getAbortFile(this.messageStoreConfig.getStorePathRootDir()));
  this.deleteFile(StorePathConfigHelper.getStoreCheckpoint(this.messageStoreConfig.getStorePathRootDir()));
}

private boolean isTempFileExist() {
  String fileName = StorePathConfigHelper.getAbortFile(this.messageStoreConfig.getStorePathRootDir());
  File file = new File(fileName);
  return file.exists();
}

public TransientStorePool(final MessageStoreConfig storeConfig) {
  this.storeConfig = storeConfig;
  this.poolSize = storeConfig.getTransientStorePoolSize();
  this.fileSize = storeConfig.getMapedFileSizeCommitLog();
  this.availableBuffers = new ConcurrentLinkedDeque<>();
}

  public int remainBufferNumbs() {
    if (storeConfig.isTransientStorePoolEnable()) {
      return availableBuffers.size();
    }
    return Integer.MAX_VALUE;
  }
}

public String getHAServerAddr() {
  return this.brokerConfig.getBrokerIP2() + ":" + this.messageStoreConfig.getHaListenPort();
}

@Override
public String configFilePath() {
  if (this.brokerController != null) {
    return BrokerPathConfigHelper.getConsumerFilterPath(
      this.brokerController.getMessageStoreConfig().getStorePathRootDir()
    );
  }
  return BrokerPathConfigHelper.getConsumerFilterPath("./unit_test");
}

public void setFlushDiskType(String type) {
  this.flushDiskType = FlushDiskType.valueOf(type);
}

  @Override
  public void dispatch(DispatchRequest request) {
    if (DefaultMessageStore.this.messageStoreConfig.isMessageIndexEnable()) {
      DefaultMessageStore.this.indexService.buildIndex(request);
    }
  }
}

public long rollNextFile(final long offset) {
  int mappedFileSize = this.defaultMessageStore.getMessageStoreConfig().getMapedFileSizeCommitLog();
  return offset + mappedFileSize - offset % mappedFileSize;
}

protected boolean isExtWriteEnable() {
  return this.consumeQueueExt != null
    && this.defaultMessageStore.getMessageStoreConfig().isEnableConsumeQueueExt();
}

  @Override
  protected MessageExtBatchEncoder initialValue() {
    return new MessageExtBatchEncoder(defaultMessageStore.getMessageStoreConfig().getMaxMessageSize());
  }
};

/**
 * @throws IOException
 */
private void createTempFile() throws IOException {
  String fileName = StorePathConfigHelper.getAbortFile(this.messageStoreConfig.getStorePathRootDir());
  File file = new File(fileName);
  MappedFile.ensureDirOK(file.getParent());
  boolean result = file.createNewFile();
  log.info(fileName + (result ? " create OK" : " already exists"));
}