How to use

getMinOffset

method

in

org.apache.rocketmq.store.CommitLog

@Override
public long getMinPhyOffset() {
  return this.commitLog.getMinOffset();
}

private void recoverTopicQueueTable() {
  HashMap<String/* topic-queueid */, Long/* offset */> table = new HashMap<String, Long>(1024);
  long minPhyOffset = this.commitLog.getMinOffset();
  for (ConcurrentMap<Integer, ConsumeQueue> maps : this.consumeQueueTable.values()) {
    for (ConsumeQueue logic : maps.values()) {
      String key = logic.getTopic() + "-" + logic.getQueueId();
      table.put(key, logic.getMaxOffsetInQueue());
      logic.correctMinOffset(minPhyOffset);
    }
  }
  this.commitLog.setTopicQueueTable(table);
}

/**
 * According to receive certain message or offset storage time if an error occurs, it returns -1
 */
public long pickupStoreTimestamp(final long offset, final int size) {
  if (offset >= this.getMinOffset()) {
    SelectMappedBufferResult result = this.getMessage(offset, size);
    if (null != result) {
      try {
        return result.getByteBuffer().getLong(MessageDecoder.MESSAGE_STORE_TIMESTAMP_POSTION);
      } finally {
        result.release();
      }
    }
  }
  return -1;
}

private void deleteExpiredFiles() {
  int deleteLogicsFilesInterval = DefaultMessageStore.this.getMessageStoreConfig().getDeleteConsumeQueueFilesInterval();
  long minOffset = DefaultMessageStore.this.commitLog.getMinOffset();
  if (minOffset > this.lastPhysicalMinOffset) {
    this.lastPhysicalMinOffset = minOffset;
    ConcurrentMap<String, ConcurrentMap<Integer, ConsumeQueue>> tables = DefaultMessageStore.this.consumeQueueTable;
    for (ConcurrentMap<Integer, ConsumeQueue> maps : tables.values()) {
      for (ConsumeQueue logic : maps.values()) {
        int deleteCount = logic.deleteExpiredFile(minOffset);
        if (deleteCount > 0 && deleteLogicsFilesInterval > 0) {
          try {
            Thread.sleep(deleteLogicsFilesInterval);
          } catch (InterruptedException ignored) {
          }
        }
      }
    }
    DefaultMessageStore.this.indexService.deleteExpiredFile(minOffset);
  }
}

public void cleanExpiredConsumerQueue() {
  long minCommitLogOffset = this.commitLog.getMinOffset();

@Override
public long getMinPhyOffset() {
  return this.commitLog.getMinOffset();
}

private void recoverTopicQueueTable() {
  ConcurrentHashMap<String/* topic-queueid */, Long/* offset */> table = new ConcurrentHashMap<String, Long>(1024);
  long minPhyOffset = this.commitLog.getMinOffset();
  for (ConcurrentMap<Integer, ConsumeQueue> maps : this.consumeQueueTable.values()) {
    for (ConsumeQueue logic : maps.values()) {
      String key = logic.getTopic() + "-" + logic.getQueueId();
      table.put(key, logic.getMaxOffsetInQueue());
      logic.correctMinOffset(minPhyOffset);
    }
  }
  this.commitLog.setTopicQueueTable(table);
}

/**
 * According to receive certain message or offset storage time if an error occurs, it returns -1
 */
public long pickupStoreTimestamp(final long offset, final int size) {
  if (offset >= this.getMinOffset()) {
    SelectMappedBufferResult result = this.getMessage(offset, size);
    if (null != result) {
      try {
        return result.getByteBuffer().getLong(MessageDecoder.MESSAGE_STORE_TIMESTAMP_POSTION);
      } finally {
        result.release();
      }
    }
  }
  return -1;
}

public void cleanExpiredConsumerQueue() {
  long minCommitLogOffset = this.commitLog.getMinOffset();

private void deleteExpiredFiles() {
  int deleteLogicsFilesInterval = DefaultMessageStore.this.getMessageStoreConfig().getDeleteConsumeQueueFilesInterval();
  int readConsumeQueueFilesMaxWhenDel = DefaultMessageStore.this.getMessageStoreConfig().getReadConsumeQueueFilesMaxWhenDel();
  long minOffset = DefaultMessageStore.this.commitLog.getMinOffset();
  if (minOffset > this.lastPhysicalMinOffset) {
    this.lastPhysicalMinOffset = minOffset;
    ConcurrentMap<String, ConcurrentMap<Integer, ConsumeQueue>> tables = DefaultMessageStore.this.consumeQueueTable;
    int readCount = 0;
    for (ConcurrentMap<Integer, ConsumeQueue> maps : tables.values()) {
      for (ConsumeQueue logic : maps.values()) {
        int deleteCount = logic.deleteExpiredFile(minOffset);
        if ((deleteCount > 0 || readCount++ > readConsumeQueueFilesMaxWhenDel) && deleteLogicsFilesInterval > 0) {
          try {
            Thread.sleep(deleteLogicsFilesInterval);
            readCount = 0;
          } catch (InterruptedException ignored) {
          }
        }
      }
    }
    DefaultMessageStore.this.indexService.deleteExpiredFile(minOffset);
  }
}

@Override
public long getMinPhyOffset() {
  return this.commitLog.getMinOffset();
}

private void recoverTopicQueueTable() {
  HashMap<String/* topic-queueid */, Long/* offset */> table = new HashMap<String, Long>(1024);
  long minPhyOffset = this.commitLog.getMinOffset();
  for (ConcurrentMap<Integer, ConsumeQueue> maps : this.consumeQueueTable.values()) {
    for (ConsumeQueue logic : maps.values()) {
      String key = logic.getTopic() + "-" + logic.getQueueId();
      table.put(key, logic.getMaxOffsetInQueue());
      logic.correctMinOffset(minPhyOffset);
    }
  }
  this.commitLog.setTopicQueueTable(table);
}

/**
 * According to receive certain message or offset storage time if an error occurs, it returns -1
 */
public long pickupStoreTimestamp(final long offset, final int size) {
  if (offset >= this.getMinOffset()) {
    SelectMappedBufferResult result = this.getMessage(offset, size);
    if (null != result) {
      try {
        return result.getByteBuffer().getLong(MessageDecoder.MESSAGE_STORE_TIMESTAMP_POSTION);
      } finally {
        result.release();
      }
    }
  }
  return -1;
}

private void deleteExpiredFiles() {
  int deleteLogicsFilesInterval = DefaultMessageStore.this.getMessageStoreConfig().getDeleteConsumeQueueFilesInterval();
  long minOffset = DefaultMessageStore.this.commitLog.getMinOffset();
  if (minOffset > this.lastPhysicalMinOffset) {
    this.lastPhysicalMinOffset = minOffset;
    ConcurrentMap<String, ConcurrentMap<Integer, ConsumeQueue>> tables = DefaultMessageStore.this.consumeQueueTable;
    for (ConcurrentMap<Integer, ConsumeQueue> maps : tables.values()) {
      for (ConsumeQueue logic : maps.values()) {
        int deleteCount = logic.deleteExpiredFile(minOffset);
        if (deleteCount > 0 && deleteLogicsFilesInterval > 0) {
          try {
            Thread.sleep(deleteLogicsFilesInterval);
          } catch (InterruptedException ignored) {
          }
        }
      }
    }
    DefaultMessageStore.this.indexService.deleteExpiredFile(minOffset);
  }
}

public void cleanExpiredConsumerQueue() {
  long minCommitLogOffset = this.commitLog.getMinOffset();