You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@iotdb.apache.org by hx...@apache.org on 2020/02/22 11:31:16 UTC
[incubator-iotdb] 02/02: fix bug IOTDB-510,
shouldClose is set to true but a new memtable is put to the
flushing queue
This is an automated email from the ASF dual-hosted git repository.
hxd pushed a commit to branch tsfileprocessortest_8181_port
in repository https://gitbox.apache.org/repos/asf/incubator-iotdb.git
commit 7ae349d0a5fb9ff46b3b6c94d421ff63078cc881
Author: xiangdong huang <sa...@gmail.com>
AuthorDate: Sat Feb 22 18:09:54 2020 +0800
fix bug IOTDB-510, shouldClose is set to true but a new memtable is put to the flushing queue
---
.../apache/iotdb/db/engine/flush/FlushManager.java | 33 +++-
.../db/engine/storagegroup/TsFileProcessor.java | 216 +++++++++++++--------
.../engine/storagegroup/TsFileProcessorTest.java | 12 +-
3 files changed, 167 insertions(+), 94 deletions(-)
diff --git a/server/src/main/java/org/apache/iotdb/db/engine/flush/FlushManager.java b/server/src/main/java/org/apache/iotdb/db/engine/flush/FlushManager.java
index 147771e..677c6f6 100644
--- a/server/src/main/java/org/apache/iotdb/db/engine/flush/FlushManager.java
+++ b/server/src/main/java/org/apache/iotdb/db/engine/flush/FlushManager.java
@@ -88,7 +88,10 @@ public class FlushManager implements FlushManagerMBean, IService {
TsFileProcessor tsFileProcessor = tsFileProcessorQueue.poll();
tsFileProcessor.flushOneMemTable();
tsFileProcessor.setManagedByFlushManager(false);
- logger.error("Flush Thread re-register TSProcessor {} to the queue.", tsFileProcessor.getStorageGroupName());
+ if (logger.isDebugEnabled()) {
+ logger.debug("Flush Thread re-register TSProcessor {} to the queue.",
+ tsFileProcessor.getTsFileResource().getFile().getAbsolutePath());
+ }
registerTsFileProcessor(tsFileProcessor);
}
}
@@ -99,17 +102,29 @@ public class FlushManager implements FlushManagerMBean, IService {
@SuppressWarnings("squid:S2445")
public void registerTsFileProcessor(TsFileProcessor tsFileProcessor) {
synchronized (tsFileProcessor) {
- if (!tsFileProcessor.isManagedByFlushManager() && tsFileProcessor.getFlushingMemTableSize() > 0) {
+ if (!tsFileProcessor.isManagedByFlushManager()
+ && tsFileProcessor.getFlushingMemTableSize() > 0) {
tsFileProcessorQueue.add(tsFileProcessor);
- logger.info("storage group {} begin to submit a flush thread, flushing memtable size: {}, queue size: {}",
- tsFileProcessor.getStorageGroupName(), tsFileProcessor.getFlushingMemTableSize(), tsFileProcessorQueue.size());
+ if (logger.isDebugEnabled()) {
+ logger.debug(
+ "{} begin to submit a flush thread, flushing memtable size: {}, queue size: {}",
+ tsFileProcessor.getTsFileResource().getFile().getAbsolutePath(),
+ tsFileProcessor.getFlushingMemTableSize(), tsFileProcessorQueue.size());
+ }
tsFileProcessor.setManagedByFlushManager(true);
flushPool.submit(new FlushThread());
- } else if (tsFileProcessor.isManagedByFlushManager()){
- logger.info("tsFileProcessor {} is already in the flushPool, the first one: {}", tsFileProcessor.getStorageGroupName(),
- tsFileProcessorQueue.size() >0 ? tsFileProcessorQueue.getFirst().getStorageGroupName() : "empty now");
- } else {
- logger.info("No flushing memetable to do, register TsProcessor {} failed.", tsFileProcessor.getStorageGroupName());
+ } else if (logger.isDebugEnabled()) {
+ if (tsFileProcessor.isManagedByFlushManager()) {
+ logger.debug(
+ "{} is already in the flushPool, the first one: {}, the given processor flushMemtable number = {}",
+ tsFileProcessor.getTsFileResource().getFile().getAbsolutePath(),
+ tsFileProcessorQueue.isEmpty() ? "empty now"
+ : tsFileProcessorQueue.getFirst().getStorageGroupName(),
+ tsFileProcessor.getFlushingMemTableSize());
+ } else {
+ logger.debug("No flushing memetable to do, register TsProcessor {} failed.",
+ tsFileProcessor.getTsFileResource().getFile().getAbsolutePath());
+ }
}
}
}
diff --git a/server/src/main/java/org/apache/iotdb/db/engine/storagegroup/TsFileProcessor.java b/server/src/main/java/org/apache/iotdb/db/engine/storagegroup/TsFileProcessor.java
index c818a3e..c1186a4 100644
--- a/server/src/main/java/org/apache/iotdb/db/engine/storagegroup/TsFileProcessor.java
+++ b/server/src/main/java/org/apache/iotdb/db/engine/storagegroup/TsFileProcessor.java
@@ -25,7 +25,6 @@ import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentLinkedDeque;
-import java.util.concurrent.ExecutionException;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
import org.apache.iotdb.db.conf.IoTDBConfig;
@@ -102,6 +101,9 @@ public class TsFileProcessor {
private boolean sequence;
private long totalMemTableSize;
+ private static final String FLUSH_QUERY_WRITE_LOCKED = "{}: {} get flushQueryLock write lock";
+ private static final String FLUSH_QUERY_WRITE_RELEASE = "{}: {} get flushQueryLock write lock released";
+
TsFileProcessor(String storageGroupName, File tsfile, Schema schema,
VersionController versionController,
CloseTsFileCallBack closeTsFileCallback,
@@ -116,9 +118,6 @@ public class TsFileProcessor {
this.updateLatestFlushTimeCallback = updateLatestFlushTimeCallback;
this.sequence = sequence;
logger.info("create a new tsfile processor {}", tsfile.getAbsolutePath());
- if (this.writer == null) {
- logger.error("the writer is null!! {}", tsfile.getName());
- }
// a file generated by flush has only one historical version, which is itself
this.tsFileResource
.setHistoricalVersions(Collections.singleton(versionController.currVersion()));
@@ -166,7 +165,8 @@ public class TsFileProcessor {
try {
getLogNode().write(insertPlan);
} catch (IOException e) {
- logger.error("write WAL failed", e);
+ logger.error("{}: {} write WAL failed", storageGroupName,
+ tsFileResource.getFile().getName(), e);
return false;
}
}
@@ -198,7 +198,8 @@ public class TsFileProcessor {
batchInsertPlan.setEnd(end);
getLogNode().write(batchInsertPlan);
} catch (IOException e) {
- logger.error("write WAL failed", e);
+ logger.error("{}: {} write WAL failed", storageGroupName,
+ tsFileResource.getFile().getName(), e);
for (int i = start; i < end; i++) {
results[i] = TSStatusCode.INTERNAL_SERVER_ERROR.getStatusCode();
}
@@ -227,7 +228,9 @@ public class TsFileProcessor {
*/
public void deleteDataInMemory(Deletion deletion) {
flushQueryLock.writeLock().lock();
- logger.error("get flushQueryLock write lock");
+ if (logger.isDebugEnabled()) {
+ logger.debug(FLUSH_QUERY_WRITE_LOCKED, storageGroupName, tsFileResource.getFile().getName());
+ }
try {
if (workMemTable != null) {
workMemTable
@@ -239,7 +242,10 @@ public class TsFileProcessor {
}
} finally {
flushQueryLock.writeLock().unlock();
- logger.error("release flushQueryLock write lock");
+ if (logger.isDebugEnabled()) {
+ logger.debug(FLUSH_QUERY_WRITE_RELEASE, storageGroupName,
+ tsFileResource.getFile().getName());
+ }
}
}
@@ -301,7 +307,8 @@ public class TsFileProcessor {
}
} catch (InterruptedException e) {
- logger.error("wait close interrupted", e);
+ logger.error("{}: {} wait close interrupted", storageGroupName,
+ tsFileResource.getFile().getName(), e);
Thread.currentThread().interrupt();
}
}
@@ -311,14 +318,14 @@ public class TsFileProcessor {
void asyncClose() {
flushQueryLock.writeLock().lock();
- logger.error("get flushQueryLock write lock");
+ if (logger.isDebugEnabled()) {
+ logger.debug(FLUSH_QUERY_WRITE_LOCKED, storageGroupName, tsFileResource.getFile().getName());
+ }
try {
logger.info("Async close the file: {}", tsFileResource.getFile().getAbsolutePath());
if (shouldClose) {
return;
}
- shouldClose = true;
- tsFileResource.setCloseFlag();
// when a flush thread serves this TsFileProcessor (because the processor is submitted by
// registerTsFileProcessor()), the thread will seal the corresponding TsFile and
// execute other cleanup works if (shouldClose == true and flushingMemTables is empty).
@@ -326,25 +333,29 @@ public class TsFileProcessor {
// To ensure there must be a flush thread serving this processor after the field `shouldClose`
// is set true, we need to generate a NotifyFlushMemTable as a signal task and submit it to
// the FlushManager.
+
+ //we have to add the memtable into flushingList first and then set the shouldClose tag.
+ // see https://issues.apache.org/jira/browse/IOTDB-510
IMemTable tmpMemTable = workMemTable == null ? new NotifyFlushMemTable() : workMemTable;
- //if (logger.isDebugEnabled()) {
- if (tmpMemTable.isSignalMemTable()) {
- logger.error(
- "storage group {} add a signal memtable into flushing memtable list when async close",
- storageGroupName);
- } else {
- logger
- .debug("storage group {} async flush a memtable when async close", storageGroupName);
- }
- //}
+ if (logger.isDebugEnabled()) {
+ logger
+ .debug("{}: {} async flush a memtable (signal = {}) when async close",
+ storageGroupName, tsFileResource.getFile().getName(), tmpMemTable.isSignalMemTable());
+ }
try {
addAMemtableIntoFlushingList(tmpMemTable);
- } catch (IOException e) {
- logger.error("async close failed, because", e);
+ shouldClose = true;
+ tsFileResource.setCloseFlag();
+ } catch (Exception e) {
+ logger.error("{}: {} async close failed, because", storageGroupName,
+ tsFileResource.getFile().getName(), e);
}
} finally {
flushQueryLock.writeLock().unlock();
- logger.error("release flushQueryLock write lock");
+ if (logger.isDebugEnabled()) {
+ logger.debug(FLUSH_QUERY_WRITE_RELEASE, storageGroupName,
+ tsFileResource.getFile().getName());
+ }
}
}
@@ -355,16 +366,20 @@ public class TsFileProcessor {
public void syncFlush() throws IOException {
IMemTable tmpMemTable;
flushQueryLock.writeLock().lock();
- logger.error("get flushQueryLock write lock");
+ if (logger.isDebugEnabled()) {
+ logger.debug(FLUSH_QUERY_WRITE_LOCKED, storageGroupName, tsFileResource.getFile().getName());
+ }
try {
tmpMemTable = workMemTable == null ? new NotifyFlushMemTable() : workMemTable;
- if (tmpMemTable.isSignalMemTable()) {
- logger.error("add a signal memtable into flushing memtable list when sync flush");
+ if (logger.isDebugEnabled() && tmpMemTable.isSignalMemTable()) {
+ logger.debug("{}: {} add a signal memtable into flushing memtable list when sync flush",
+ storageGroupName, tsFileResource.getFile().getName());
}
addAMemtableIntoFlushingList(tmpMemTable);
} finally {
flushQueryLock.writeLock().unlock();
- logger.error("release flushQueryLock write lock");
+ logger.error(FLUSH_QUERY_WRITE_RELEASE, storageGroupName,
+ tsFileResource.getFile().getName());
}
synchronized (tmpMemTable) {
@@ -389,7 +404,8 @@ public class TsFileProcessor {
}
}
} catch (InterruptedException e) {
- logger.error("wait flush finished meets error", e);
+ logger.error("{}: {} wait flush finished meets error", storageGroupName,
+ tsFileResource.getFile().getName(), e);
Thread.currentThread().interrupt();
}
}
@@ -400,19 +416,23 @@ public class TsFileProcessor {
*/
public void asyncFlush() {
flushQueryLock.writeLock().lock();
- logger.error("get flushQueryLock write lock");
+ if (logger.isDebugEnabled()) {
+ logger.debug(FLUSH_QUERY_WRITE_LOCKED, storageGroupName, tsFileResource.getFile().getName());
+ }
try {
if (workMemTable == null) {
return;
}
-
addAMemtableIntoFlushingList(workMemTable);
-
- } catch (IOException e) {
- logger.error("WAL notify start flush failed", e);
+ } catch (Exception e) {
+ logger.error("{}: {} add a memtable into flushing listfailed", storageGroupName,
+ tsFileResource.getFile().getName(), e);
} finally {
flushQueryLock.writeLock().unlock();
- logger.error("release flushQueryLock write lock");
+ if (logger.isDebugEnabled()) {
+ logger.debug(FLUSH_QUERY_WRITE_RELEASE, storageGroupName,
+ tsFileResource.getFile().getName());
+ }
}
}
@@ -423,10 +443,16 @@ public class TsFileProcessor {
*/
private void addAMemtableIntoFlushingList(IMemTable tobeFlushed) throws IOException {
if(!updateLatestFlushTimeCallback.call(this)){
- logger.error("Memetable info: " + tobeFlushed.getMemTableMap());
+ logger.error("{}: {} Memetable info: {}", storageGroupName,
+ tsFileResource.getFile().getName(), tobeFlushed.getMemTableMap());
}
flushingMemTables.addLast(tobeFlushed);
- logger.error("Memtable (signal = {}) is added into the flushing Memtable", tobeFlushed.isSignalMemTable());
+ if (logger.isDebugEnabled()) {
+ logger.debug(
+ "{}: {} Memtable (signal = {}) is added into the flushing Memtable, queue size = {}",
+ storageGroupName, tsFileResource.getFile().getName(),
+ tobeFlushed.isSignalMemTable(), flushingMemTables.size());
+ }
long cur = versionController.nextVersion();
tobeFlushed.setVersion(cur);
if (IoTDBDescriptor.getInstance().getConfig().isEnableWal()) {
@@ -445,30 +471,35 @@ public class TsFileProcessor {
*/
private void releaseFlushedMemTable(IMemTable memTable) {
flushQueryLock.writeLock().lock();
- logger.error("get flushQueryLock write lock");
+ if (logger.isDebugEnabled()) {
+ logger.debug(FLUSH_QUERY_WRITE_LOCKED, storageGroupName,
+ tsFileResource.getFile().getName());
+ }
try {
- if (writer == null) {
- logger.error("the writer is null, why?? memtable (signal = {})", memTable.isSignalMemTable());
- }
writer.makeMetadataVisible();
if (!flushingMemTables.remove(memTable)) {
logger.warn(
- "put the memtable (signal={}) out of flushingMemtables but it is not in the queue.",
- memTable.isSignalMemTable());
- } else {
- logger.warn(
- "memtable (signal={}) is removed from the queue. {} left.",
+ "{}: {} put the memtable (signal={}) out of flushingMemtables but it is not in the queue.",
+ storageGroupName, tsFileResource.getFile().getName(), memTable.isSignalMemTable());
+ } else if (logger.isDebugEnabled()){
+ logger.debug(
+ "{}: {} memtable (signal={}) is removed from the queue. {} left.", storageGroupName,
+ tsFileResource.getFile().getName(),
memTable.isSignalMemTable(), flushingMemTables.size());
}
memTable.release();
MemTablePool.getInstance().putBack(memTable, storageGroupName);
- logger.debug("storage group {} flush finished, remove a memtable from flushing list, "
- + "flushing memtable list size: {}", storageGroupName, flushingMemTables.size());
+ if (logger.isDebugEnabled()) {
+ logger.debug("{}: {} flush finished, remove a memtable from flushing list, "
+ + "flushing memtable list size: {}", storageGroupName,
+ tsFileResource.getFile().getName(), flushingMemTables.size());
+ }
} catch (Exception e) {
- logger.error(e.getMessage(), e);
+ logger.error("{}: {}", storageGroupName, tsFileResource.getFile().getName(), e);
} finally {
flushQueryLock.writeLock().unlock();
- logger.error("release flushQueryLock write lock");
+ logger.error(FLUSH_QUERY_WRITE_RELEASE, storageGroupName,
+ tsFileResource.getFile().getName());
}
}
@@ -479,9 +510,10 @@ public class TsFileProcessor {
public void flushOneMemTable() {
IMemTable memTableToFlush;
memTableToFlush = flushingMemTables.getFirst();
-
- logger.info("storage group {} starts to flush a memtable in a flush thread", storageGroupName);
-
+ if (logger.isInfoEnabled()) {
+ logger.info("{}: {} starts to flush a memtable in a flush thread", storageGroupName,
+ tsFileResource.getFile().getName());
+ }
// signal memtable only may appear when calling asyncClose()
if (!memTableToFlush.isSignalMemTable()) {
MemTableFlushTask flushTask = new MemTableFlushTask(memTableToFlush, schema, writer,
@@ -489,14 +521,17 @@ public class TsFileProcessor {
try {
writer.mark();
flushTask.syncFlushMemTable();
- } catch (ExecutionException | InterruptedException | IOException e) {
- logger.error("meet error when flushing a memtable, change system mode to read-only", e);
+ } catch (Exception e) {
+ logger.error("{}: {} meet error when flushing a memtable, change system mode to read-only",
+ storageGroupName, tsFileResource.getFile().getName(), e);
IoTDBDescriptor.getInstance().getConfig().setReadOnly(true);
try {
- logger.error("IOTask meets error, truncate the corrupted data", e);
+ logger.error("{}: {} IOTask meets error, truncate the corrupted data", storageGroupName,
+ tsFileResource.getFile().getName(), e);
writer.reset();
} catch (IOException e1) {
- logger.error("Truncate corrupted data meets error", e1);
+ logger.error("{}: {} Truncate corrupted data meets error", storageGroupName,
+ tsFileResource.getFile().getName(), e1);
}
Thread.currentThread().interrupt();
}
@@ -505,13 +540,19 @@ public class TsFileProcessor {
getLogNode().notifyEndFlush();
}
}
- logger.error("try get lock to release a memtable (signal={})", memTableToFlush.isSignalMemTable());
+ if (logger.isDebugEnabled()) {
+ logger.debug("{}: {} try get lock to release a memtable (signal={})", storageGroupName,
+ tsFileResource.getFile().getName(), memTableToFlush.isSignalMemTable());
+ }
// for sync flush
synchronized (memTableToFlush) {
- logger.error("have got lock to release a memtable (signal={})", memTableToFlush.isSignalMemTable());
releaseFlushedMemTable(memTableToFlush);
memTableToFlush.notifyAll();
- logger.error("released a memtable (signal={}), flushingMemtables size ={}", memTableToFlush.isSignalMemTable(), flushingMemTables.size());
+ if (logger.isDebugEnabled()) {
+ logger.debug("{}: {} released a memtable (signal={}), flushingMemtables size ={}",
+ storageGroupName, tsFileResource.getFile().getName(),
+ memTableToFlush.isSignalMemTable(), flushingMemTables.size());
+ }
}
if (shouldClose && flushingMemTables.isEmpty()) {
@@ -519,34 +560,45 @@ public class TsFileProcessor {
writer.mark();
try {
double compressionRatio = ((double) totalMemTableSize) / writer.getPos();
- logger.debug(
- "The compression ratio of tsfile {} is {}, totalMemTableSize: {}, the file size: {}",
- writer.getFile().getAbsolutePath(), compressionRatio, totalMemTableSize,
- writer.getPos());
+ if (logger.isDebugEnabled()) {
+ logger.debug(
+ "The compression ratio of tsfile {} is {}, totalMemTableSize: {}, the file size: {}",
+ writer.getFile().getAbsolutePath(), compressionRatio, totalMemTableSize,
+ writer.getPos());
+ }
if (compressionRatio == 0) {
logger.error(
- "The compression ratio of tsfile {} is 0, totalMemTableSize: {}, the file size: {}",
- writer.getFile().getAbsolutePath(), totalMemTableSize, writer.getPos());
+ "{} The compression ratio of tsfile {} is 0, totalMemTableSize: {}, the file size: {}",
+ storageGroupName, writer.getFile().getAbsolutePath(), totalMemTableSize, writer.getPos());
}
CompressionRatio.getInstance().updateRatio(compressionRatio);
} catch (IOException e) {
- logger.error("update compression ratio failed", e);
+ logger.error("{}: {} update compression ratio failed", storageGroupName,
+ tsFileResource.getFile().getName(), e);
+ }
+ if (logger.isDebugEnabled()) {
+ logger.debug("{}: {} flushingMemtables is empty and will close the file", storageGroupName,
+ tsFileResource.getFile().getName());
}
- logger.error("flushing Memtable is empty and will close the file");
endFile();
- } catch (IOException | TsFileProcessorException e) {
- logger.error("meet error when flush FileMetadata to {}, change system mode to read-only",
- tsFileResource.getFile().getAbsolutePath());
+ } catch (Exception e) {
+ logger.error("{} meet error when flush FileMetadata to {}, change system mode to read-only",
+ storageGroupName, tsFileResource.getFile().getAbsolutePath());
IoTDBDescriptor.getInstance().getConfig().setReadOnly(true);
try {
writer.reset();
} catch (IOException e1) {
- logger.error("truncate corrupted data meets error", e1);
+ logger.error("{}: {} truncate corrupted data meets error", storageGroupName,
+ tsFileResource.getFile().getName(), e1);
}
- logger.error("marking or ending file meet error", e);
+ logger.error("{}: {} marking or ending file meet error", storageGroupName,
+ tsFileResource.getFile().getName(), e);
}
-
// for sync close
+ if (logger.isDebugEnabled()) {
+ logger.debug("{}: {} try to get flushingMemtables lock.", storageGroupName,
+ tsFileResource.getFile().getName());
+ }
synchronized (flushingMemTables) {
flushingMemTables.notifyAll();
}
@@ -574,7 +626,6 @@ public class TsFileProcessor {
DatetimeUtils.convertMillsecondToZonedDateTime(closeEndTime),
closeEndTime - closeStartTime);
}
- logger.error("Storage group {} close the file {}", storageGroupName, tsFileResource.getFile().getAbsoluteFile());
}
@@ -635,8 +686,11 @@ public class TsFileProcessor {
public Pair<List<ReadOnlyMemChunk>, List<ChunkMetaData>> query(String deviceId,
String measurementId, TSDataType dataType, TSEncoding encoding, Map<String, String> props,
QueryContext context) {
+ if (logger.isDebugEnabled()) {
+ logger.debug("{}: {} get flushQueryLock read lock", storageGroupName,
+ tsFileResource.getFile().getName());
+ }
flushQueryLock.readLock().lock();
- logger.error("get flushQueryLock read lock");
try {
List<ReadOnlyMemChunk> readOnlyMemChunks = new ArrayList<>();
for (IMemTable flushingMemTable : flushingMemTables) {
@@ -670,10 +724,14 @@ public class TsFileProcessor {
return new Pair<>(readOnlyMemChunks, chunkMetaDataList);
} catch (Exception e) {
- logger.error("get ReadOnlyMemChunk has error", e);
+ logger.error("{}: {} get ReadOnlyMemChunk has error", storageGroupName,
+ tsFileResource.getFile().getName(), e);
} finally {
flushQueryLock.readLock().unlock();
- logger.error("release flushQueryLock read lock");
+ if (logger.isDebugEnabled()) {
+ logger.debug("{}: {} release flushQueryLock read lock", storageGroupName,
+ tsFileResource.getFile().getName());
+ }
}
return null;
}
diff --git a/server/src/test/java/org/apache/iotdb/db/engine/storagegroup/TsFileProcessorTest.java b/server/src/test/java/org/apache/iotdb/db/engine/storagegroup/TsFileProcessorTest.java
index 62efc1d..df1d5e4 100644
--- a/server/src/test/java/org/apache/iotdb/db/engine/storagegroup/TsFileProcessorTest.java
+++ b/server/src/test/java/org/apache/iotdb/db/engine/storagegroup/TsFileProcessorTest.java
@@ -84,7 +84,7 @@ public class TsFileProcessorTest {
@Test
public void testWriteAndFlush() throws IOException, QueryProcessException {
- logger.error("testWriteAndFlush begin..");
+ logger.info("testWriteAndFlush begin..");
processor = new TsFileProcessor(storageGroup, SystemFileFactory.INSTANCE.getFile(filePath),
SchemaUtils.constructSchema(deviceId), SysTimeVersionController.INSTANCE, this::closeTsFileProcessor,
(tsFileProcessor) -> true, true);
@@ -132,7 +132,7 @@ public class TsFileProcessorTest {
@Test
public void testWriteAndRestoreMetadata() throws IOException, QueryProcessException {
- logger.error("testWriteAndRestoreMetadata begin..");
+ logger.info("testWriteAndRestoreMetadata begin..");
processor = new TsFileProcessor(storageGroup, SystemFileFactory.INSTANCE.getFile(filePath),
SchemaUtils.constructSchema(deviceId), SysTimeVersionController.INSTANCE, this::closeTsFileProcessor,
(tsFileProcessor) -> true, true);
@@ -165,7 +165,7 @@ public class TsFileProcessorTest {
assertEquals(num, timeValuePair.getValue().getInt());
}
}
- logger.error("syncFlush..");
+ logger.info("syncFlush..");
// flush synchronously
processor.syncFlush();
@@ -195,7 +195,7 @@ public class TsFileProcessorTest {
}
}
restorableTsFileIOWriter.close();
- logger.error("syncClose..");
+ logger.info("syncClose..");
processor.syncClose();
//we need to close the tsfile writer first and then reopen it.
}
@@ -203,7 +203,7 @@ public class TsFileProcessorTest {
@Test
public void testMultiFlush() throws IOException, QueryProcessException {
- logger.error("testWriteAndRestoreMetadata begin..");
+ logger.info("testWriteAndRestoreMetadata begin..");
processor = new TsFileProcessor(storageGroup, SystemFileFactory.INSTANCE.getFile(filePath),
SchemaUtils.constructSchema(deviceId), SysTimeVersionController.INSTANCE, this::closeTsFileProcessor,
(tsFileProcessor) -> true, true);
@@ -238,7 +238,7 @@ public class TsFileProcessorTest {
@Test
public void testWriteAndClose() throws IOException, QueryProcessException {
- logger.error("testWriteAndRestoreMetadata begin..");
+ logger.info("testWriteAndRestoreMetadata begin..");
processor = new TsFileProcessor(storageGroup, SystemFileFactory.INSTANCE.getFile(filePath),
SchemaUtils.constructSchema(deviceId), SysTimeVersionController.INSTANCE,
this::closeTsFileProcessor, (tsFileProcessor) -> true, true);