9618

Build # 9618

Build Type

push

jenkins

Committed by GitHub

Commit Message

<a href="https://github.com/apache/carbondata/commit/<a class=hub.com/apache/carbondata/commit/c5ec69f39f7b307f56a0674dea338f139a6bc3c8">c5ec69f39<a href="https://github.com/apache/carbondata/commit/c5ec69f39f7b307f56a0674dea338f139a6bc3c8">">Merge </a><a class="double-link" href="https://github.com/apache/carbondata/commit/<a class="double-link" href="https://github.com/apache/carbondata/commit/b873435adaa96c4125f22054bfcddc9cc3bb384f">b873435ad</a>">b873435ad</a><a href="https://github.com/apache/carbondata/commit/c5ec69f39f7b307f56a0674dea338f139a6bc3c8"> into 6f3b9d3b9">6f3b9d3b9</a>

Run Details

84 of 84 new or added lines in 6 files covered. (100.0%)

62077 of 77605 relevant lines covered (79.99%)

1.06 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

91.86

/processing/src/main/java/org/apache/carbondata/processing/store/writer/AbstractFactDataWriter.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.apache.carbondata.processing.store.writer;

import java.io.DataOutputStream;
import java.io.File;
import java.io.IOException;
import java.nio.channels.Channels;
import java.nio.channels.WritableByteChannel;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;

import org.apache.carbondata.common.logging.LogServiceFactory;
import org.apache.carbondata.core.constants.CarbonCommonConstants;
import org.apache.carbondata.core.constants.CarbonLoadOptionConstants;
import org.apache.carbondata.core.datastore.exception.CarbonDataWriterException;
import org.apache.carbondata.core.datastore.impl.FileFactory;
import org.apache.carbondata.core.keygenerator.mdkey.NumberCompressor;
import org.apache.carbondata.core.metadata.converter.SchemaConverter;
import org.apache.carbondata.core.metadata.converter.ThriftWrapperSchemaConverterImpl;
import org.apache.carbondata.core.metadata.index.BlockIndexInfo;
import org.apache.carbondata.core.metadata.schema.table.column.ColumnSchema;
import org.apache.carbondata.core.util.CarbonMetadataUtil;
import org.apache.carbondata.core.util.CarbonProperties;
import org.apache.carbondata.core.util.CarbonThreadFactory;
import org.apache.carbondata.core.util.CarbonUtil;
import org.apache.carbondata.core.util.path.CarbonTablePath;
import org.apache.carbondata.core.writer.CarbonIndexFileWriter;
import org.apache.carbondata.format.BlockIndex;
import org.apache.carbondata.format.BlockletInfo3;
import org.apache.carbondata.format.IndexHeader;
import org.apache.carbondata.processing.datamap.DataMapWriterListener;
import org.apache.carbondata.processing.store.CarbonFactDataHandlerModel;

import org.apache.log4j.Logger;

public abstract class AbstractFactDataWriter implements CarbonFactDataWriter {

  private static final Logger LOGGER =
      LogServiceFactory.getLogService(AbstractFactDataWriter.class.getName());

  /**
   * file channel to write
   */
  protected WritableByteChannel fileChannel;
  protected long currentOffsetInFile;
  /**
   * The path of CarbonData file to write in hdfs/s3
   */
  private String carbonDataFileStorePath;
  /**
   * The temp path of carbonData file used on executor
   */
  private String carbonDataFileTempPath;

  /**
   * The name of carbonData file (blockId)
   */
  protected String carbonDataFileName;

  /**
   * The sequence number of blocklet inside one block
   */
  protected int blockletId = 0;

  /**
   * The sequence number of page inside one blocklet
   */
  protected int pageId = 0;

  /**
   * Local cardinality for the segment
   */
  protected int[] localCardinality;
  /**
   * thrift column schema
   */
  protected List<org.apache.carbondata.format.ColumnSchema> thriftColumnSchemaList;
  protected NumberCompressor numberCompressor;
  protected CarbonFactDataHandlerModel model;
  protected List<List<Long>> dataChunksOffsets;
  protected List<List<Short>> dataChunksLength;
  /**
   * data file size;
   */
  protected long fileSizeInBytes;
  /**
   * file count will be used to give sequence number to the data file
   */
  private int fileCount;
  /**
   * executorService
   */
  private ExecutorService executorService;
  /**
   * executorService
   */
  private List<Future<Void>> executorServiceSubmitList;
  /**
   * data block size for one carbon data file
   */
  private long blockSizeThreshold;
  /**
   * file size at any given point
   */
  private long currentFileSize;

  protected DataOutputStream fileOutputStream;

  protected List<BlockIndexInfo> blockIndexInfoList;

  /**
   * list of metadata for V3 format
   */
  protected List<BlockletInfo3> blockletMetadata;

  /**
   * list of blocklet index
   */
  protected List<org.apache.carbondata.format.BlockletIndex> blockletIndex;

  /**
   * listener to write data map
   */
  protected DataMapWriterListener listener;
  /**
   * Whether directly write fact data to store path
   */
  private boolean enableDirectlyWriteDataToStorePath = false;

  protected ExecutorService fallbackExecutorService;

  public AbstractFactDataWriter(CarbonFactDataHandlerModel model) {
    this.model = model;
    blockIndexInfoList = new ArrayList<>();
    // get max file size;
    CarbonProperties propInstance = CarbonProperties.getInstance();
    // if blocksize=2048, then 2048*1024*1024 will beyond the range of Int
    this.fileSizeInBytes =
        (long) this.model.getBlockSizeInMB() * CarbonCommonConstants.BYTE_TO_KB_CONVERSION_FACTOR
            * CarbonCommonConstants.BYTE_TO_KB_CONVERSION_FACTOR;

    // size reserved in one file for writing block meta data. It will be in percentage
    int spaceReservedForBlockMetaSize = Integer.parseInt(propInstance
        .getProperty(CarbonCommonConstants.CARBON_BLOCK_META_RESERVED_SPACE,
            CarbonCommonConstants.CARBON_BLOCK_META_RESERVED_SPACE_DEFAULT));
    this.blockSizeThreshold =
        fileSizeInBytes - (fileSizeInBytes * spaceReservedForBlockMetaSize) / 100;
    LOGGER
        .info("Total file size: " + fileSizeInBytes + " and dataBlock Size: " + blockSizeThreshold);

    // whether to directly write fact data to HDFS
    String directlyWriteData2Hdfs = propInstance
        .getProperty(CarbonLoadOptionConstants.ENABLE_CARBON_LOAD_DIRECT_WRITE_TO_STORE_PATH,
            CarbonLoadOptionConstants.ENABLE_CARBON_LOAD_DIRECT_WRITE_TO_STORE_PATH_DEFAULT);
    this.enableDirectlyWriteDataToStorePath = "TRUE".equalsIgnoreCase(directlyWriteData2Hdfs);

    if (enableDirectlyWriteDataToStorePath) {
      LOGGER.info("Carbondata will directly write fact data to HDFS.");
    } else {
      LOGGER.info("Carbondata will write temporary fact data to local disk.");
    }

    this.executorService = Executors.newFixedThreadPool(1,
        new CarbonThreadFactory("CompleteHDFSBackendPool:" + this.model.getTableName()));
    executorServiceSubmitList = new ArrayList<>(CarbonCommonConstants.DEFAULT_COLLECTION_SIZE);
    // in case of compaction we will pass the cardinality.
    this.localCardinality = this.model.getColCardinality();

    List<Integer> cardinalityList = new ArrayList<Integer>();
    thriftColumnSchemaList = getColumnSchemaListAndCardinality(cardinalityList, localCardinality,
        this.model.getWrapperColumnSchema());
    this.numberCompressor = new NumberCompressor(Integer.parseInt(CarbonProperties.getInstance()
        .getProperty(CarbonCommonConstants.BLOCKLET_SIZE,
            CarbonCommonConstants.BLOCKLET_SIZE_DEFAULT_VAL)));
    this.dataChunksOffsets = new ArrayList<>();
    this.dataChunksLength = new ArrayList<>();
    blockletMetadata = new ArrayList<BlockletInfo3>();
    blockletIndex = new ArrayList<>();
    listener = this.model.getDataMapWriterlistener();
    if (model.getColumnLocalDictGenMap().size() > 0) {
      int numberOfCores = 1;
      if (model.getNumberOfCores() > 1) {
        numberOfCores = model.getNumberOfCores() / 2;
      }
      fallbackExecutorService = Executors.newFixedThreadPool(numberOfCores, new CarbonThreadFactory(
          "FallbackPool:" + model.getTableName() + ", range: " + model.getBucketId()));
    }
  }

  /**
   * This method will be used to update the file channel with new file if exceeding block size
   * threshold, new file will be created once existing file reached the file size limit This
   * method will first check whether existing file size is exceeded the file
   * size limit if yes then write the leaf metadata to file then set the
   * current file size to 0 close the existing file channel get the new file
   * name and get the channel for new file
   *
   * @param blockletSizeToBeAdded data size of one block
   * @throws CarbonDataWriterException if any problem
   */
  protected void createNewFileIfReachThreshold(long blockletSizeToBeAdded)
      throws CarbonDataWriterException {
    if ((currentFileSize + blockletSizeToBeAdded) >= blockSizeThreshold && currentFileSize != 0) {
      // set the current file size to zero
      String activeFile =
          enableDirectlyWriteDataToStorePath ? carbonDataFileStorePath : carbonDataFileTempPath;
      LOGGER.info("Writing data to file as max file size reached for file: "
          + activeFile + ". Data block size: " + currentFileSize);
      // write meta data to end of the existing file
      writeFooterToFile();
      this.currentFileSize = 0;
      this.dataChunksOffsets = new ArrayList<>();
      this.dataChunksLength = new ArrayList<>();
      this.blockletMetadata = new ArrayList<>();
      this.blockletIndex = new ArrayList<>();
      commitCurrentFile(false);
      // initialize the new channel
      initializeWriter();
    }
    currentFileSize += blockletSizeToBeAdded;
  }

  private void notifyDataMapBlockStart() {
    if (listener != null) {
      try {
        listener.onBlockStart(carbonDataFileName);
      } catch (IOException e) {
        throw new CarbonDataWriterException("Problem while writing datamap", e);
      }
    }
  }

  private void notifyDataMapBlockEnd() {
    if (listener != null) {
      try {
        listener.onBlockEnd(carbonDataFileName);
      } catch (IOException e) {
        throw new CarbonDataWriterException("Problem while writing datamap", e);
      }
    }
  }

  /**
   * Finish writing current file. It will flush stream, copy and rename temp file to final file
   * @param copyInCurrentThread set to false if want to do data copy in a new thread
   */
  protected void commitCurrentFile(boolean copyInCurrentThread) {
    notifyDataMapBlockEnd();
    CarbonUtil.closeStreams(this.fileOutputStream, this.fileChannel);
    if (!enableDirectlyWriteDataToStorePath) {
      try {
        if (copyInCurrentThread) {
          CarbonUtil.copyCarbonDataFileToCarbonStorePath(carbonDataFileTempPath,
              model.getCarbonDataDirectoryPath(), fileSizeInBytes);
          FileFactory
              .deleteFile(carbonDataFileTempPath, FileFactory.getFileType(carbonDataFileTempPath));
        } else {
          executorServiceSubmitList
              .add(executorService.submit(new CompleteHdfsBackendThread(carbonDataFileTempPath)));
        }
      } catch (IOException e) {
        LOGGER.error(e);
      }
    }
  }

  /**
   * This method will be used to initialize the channel
   *
   * @throws CarbonDataWriterException
   */
  public void initializeWriter() throws CarbonDataWriterException {
    this.carbonDataFileName = CarbonTablePath
        .getCarbonDataFileName(fileCount, model.getCarbonDataFileAttributes().getTaskId(),
            model.getBucketId(), model.getTaskExtension(),
            "" + model.getCarbonDataFileAttributes().getFactTimeStamp(), model.getSegmentId());
    this.carbonDataFileStorePath = model.getCarbonDataDirectoryPath() + File.separator
        + carbonDataFileName;
    try {
      if (enableDirectlyWriteDataToStorePath) {
        // the block size will be twice the block_size specified by user to make sure that
        // one carbondata file only consists exactly one HDFS block.
        fileOutputStream = FileFactory
            .getDataOutputStream(carbonDataFileStorePath, FileFactory.FileType.HDFS,
                CarbonCommonConstants.BYTEBUFFER_SIZE, fileSizeInBytes * 2);
      } else {
        //each time we initialize writer, we choose a local temp location randomly
        String[] tempFileLocations = model.getStoreLocation();
        String chosenTempLocation =
            tempFileLocations[new Random().nextInt(tempFileLocations.length)];
        LOGGER.info("Randomly choose factdata temp location: " + chosenTempLocation);
        carbonDataFileTempPath = chosenTempLocation + File.separator + carbonDataFileName;
        fileOutputStream = FileFactory.getDataOutputStream(carbonDataFileTempPath,
            FileFactory.FileType.LOCAL, CarbonCommonConstants.BYTEBUFFER_SIZE, true);
      }

      this.fileCount++;
      // open channel for new data file
      this.fileChannel = Channels.newChannel(fileOutputStream);
      this.currentOffsetInFile = 0;
    } catch (IOException ex) {
      throw new CarbonDataWriterException(
          "Problem while getting the channel for fact data file", ex);
    }
    notifyDataMapBlockStart();
  }

  /**
   * This method will write metadata at the end of file file format in thrift format
   */
  protected abstract void writeFooterToFile() throws CarbonDataWriterException;

  /**
   * Below method will be used to fill the vlock info details
   *
   * @param numberOfRows    number of rows in file
   * @param carbonDataFileName The name of carbonData file
   * @param currentPosition current offset
   */
  protected abstract void fillBlockIndexInfoDetails(long numberOfRows, String carbonDataFileName,
      long currentPosition);

  public static List<org.apache.carbondata.format.ColumnSchema> getColumnSchemaListAndCardinality(
      List<Integer> cardinality, int[] dictionaryColumnCardinality,
      List<ColumnSchema> wrapperColumnSchemaList) {
    List<org.apache.carbondata.format.ColumnSchema> columnSchemaList =
        new ArrayList<org.apache.carbondata.format.ColumnSchema>(
            CarbonCommonConstants.DEFAULT_COLLECTION_SIZE);
    SchemaConverter schemaConverter = new ThriftWrapperSchemaConverterImpl();
    int counter = 0;
    for (int i = 0; i < wrapperColumnSchemaList.size(); i++) {
      columnSchemaList
          .add(schemaConverter.fromWrapperToExternalColumnSchema(wrapperColumnSchemaList.get(i)));
      if (CarbonUtil.hasEncoding(wrapperColumnSchemaList.get(i).getEncodingList(),
          org.apache.carbondata.core.metadata.encoder.Encoding.DICTIONARY)) {
        cardinality.add(dictionaryColumnCardinality[counter]);
        counter++;
      } else if (!wrapperColumnSchemaList.get(i).isDimensionColumn()) {
        continue;
      } else {
        cardinality.add(-1);
      }
    }
    return columnSchemaList;
  }

  /**
   * Below method will be used to write the idex file
   *
   * @throws IOException               throws io exception if any problem while writing
   * @throws CarbonDataWriterException data writing
   */
  protected void writeIndexFile() throws IOException, CarbonDataWriterException {
    // get the header
    IndexHeader indexHeader = CarbonMetadataUtil
        .getIndexHeader(localCardinality, thriftColumnSchemaList, model.getBucketId(),
            model.getSchemaUpdatedTimeStamp());
    // get the block index info thrift
    List<BlockIndex> blockIndexThrift = CarbonMetadataUtil.getBlockIndexInfo(blockIndexInfoList);
    String indexFileName;
    if (enableDirectlyWriteDataToStorePath) {
      String rawFileName = model.getCarbonDataDirectoryPath() + CarbonCommonConstants.FILE_SEPARATOR
          + CarbonTablePath.getCarbonIndexFileName(model.getCarbonDataFileAttributes().getTaskId(),
          model.getBucketId(), model.getTaskExtension(),
          "" + model.getCarbonDataFileAttributes().getFactTimeStamp(), model.getSegmentId());
      indexFileName = FileFactory.getUpdatedFilePath(rawFileName, FileFactory.FileType.HDFS);
    } else {
      // randomly choose a temp location for index file
      String[] tempLocations = model.getStoreLocation();
      String chosenTempLocation = tempLocations[new Random().nextInt(tempLocations.length)];
      LOGGER.info("Randomly choose index file location: " + chosenTempLocation);
      indexFileName = chosenTempLocation + File.separator + CarbonTablePath
          .getCarbonIndexFileName(model.getCarbonDataFileAttributes().getTaskId(),
              model.getBucketId(), model.getTaskExtension(),
              "" + model.getCarbonDataFileAttributes().getFactTimeStamp(), model.getSegmentId());
    }

    CarbonIndexFileWriter writer = new CarbonIndexFileWriter();
    // open file
    writer.openThriftWriter(indexFileName);
    // write the header first
    writer.writeThrift(indexHeader);
    // write the indexes
    for (BlockIndex blockIndex : blockIndexThrift) {
      writer.writeThrift(blockIndex);
    }
    writer.close();
    if (!enableDirectlyWriteDataToStorePath) {
      CarbonUtil
          .copyCarbonDataFileToCarbonStorePath(indexFileName, model.getCarbonDataDirectoryPath(),
              fileSizeInBytes);
      FileFactory.deleteFile(indexFileName, FileFactory.getFileType(indexFileName));
    }
  }

  /**
   * This method will close the executor service which is used for copying carbon
   * data files to carbon store path
   *
   * @throws CarbonDataWriterException
   */
  protected void closeExecutorService() throws CarbonDataWriterException {
    CarbonDataWriterException exception = null;
    try {
      listener.finish();
      listener = null;
    } catch (IOException e) {
      exception = new CarbonDataWriterException(e);
    }
    try {
      executorService.shutdown();
      executorService.awaitTermination(2, TimeUnit.HOURS);
      for (int i = 0; i < executorServiceSubmitList.size(); i++) {
        executorServiceSubmitList.get(i).get();
      }
    } catch (InterruptedException | ExecutionException e) {
      if (null == exception) {
        exception = new CarbonDataWriterException(e);
      }
    }
    if (null != fallbackExecutorService) {
      fallbackExecutorService.shutdownNow();
    }
    if (exception != null) {
      throw exception;
    }
  }



  /**
   * This method will complete hdfs backend storage for this file.
   * It may copy the carbon data file from local store location to carbon store location,
   * it may also complete the remaining replications for the existing hdfs file.
   */
  private final class CompleteHdfsBackendThread implements Callable<Void> {

    /**
     * complete path along with file name which needs to be copied to
     * carbon store path
     */
    private String fileName;

    private CompleteHdfsBackendThread(String fileName) {
      this.fileName = fileName;
    }

    /**
     * Computes a result, or throws an exception if unable to do so.
     *
     * @return computed result
     * @throws Exception if unable to compute a result
     */
    @Override
    public Void call() throws Exception {
      CarbonUtil.copyCarbonDataFileToCarbonStorePath(fileName, model.getCarbonDataDirectoryPath(),
          fileSizeInBytes);
      FileFactory.deleteFile(fileName, FileFactory.getFileType(fileName));
      return null;
    }
  }
}

1	/*
2	* Licensed to the Apache Software Foundation (ASF) under one or more
3	* contributor license agreements. See the NOTICE file distributed with
4	* this work for additional information regarding copyright ownership.
5	* The ASF licenses this file to You under the Apache License, Version 2.0
6	* (the "License"); you may not use this file except in compliance with
7	* the License. You may obtain a copy of the License at
8	*
9	* http://www.apache.org/licenses/LICENSE-2.0
10	*
11	* Unless required by applicable law or agreed to in writing, software
12	* distributed under the License is distributed on an "AS IS" BASIS,
13	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14	* See the License for the specific language governing permissions and
15	* limitations under the License.
16	*/
17
18	package org.apache.carbondata.processing.store.writer;
19
20	import java.io.DataOutputStream;
21	import java.io.File;
22	import java.io.IOException;
23	import java.nio.channels.Channels;
24	import java.nio.channels.WritableByteChannel;
25	import java.util.ArrayList;
26	import java.util.List;
27	import java.util.Random;
28	import java.util.concurrent.Callable;
29	import java.util.concurrent.ExecutionException;
30	import java.util.concurrent.ExecutorService;
31	import java.util.concurrent.Executors;
32	import java.util.concurrent.Future;
33	import java.util.concurrent.TimeUnit;
34
35	import org.apache.carbondata.common.logging.LogServiceFactory;
36	import org.apache.carbondata.core.constants.CarbonCommonConstants;
37	import org.apache.carbondata.core.constants.CarbonLoadOptionConstants;
38	import org.apache.carbondata.core.datastore.exception.CarbonDataWriterException;
39	import org.apache.carbondata.core.datastore.impl.FileFactory;
40	import org.apache.carbondata.core.keygenerator.mdkey.NumberCompressor;
41	import org.apache.carbondata.core.metadata.converter.SchemaConverter;
42	import org.apache.carbondata.core.metadata.converter.ThriftWrapperSchemaConverterImpl;
43	import org.apache.carbondata.core.metadata.index.BlockIndexInfo;
44	import org.apache.carbondata.core.metadata.schema.table.column.ColumnSchema;
45	import org.apache.carbondata.core.util.CarbonMetadataUtil;
46	import org.apache.carbondata.core.util.CarbonProperties;
47	import org.apache.carbondata.core.util.CarbonThreadFactory;
48	import org.apache.carbondata.core.util.CarbonUtil;
49	import org.apache.carbondata.core.util.path.CarbonTablePath;
50	import org.apache.carbondata.core.writer.CarbonIndexFileWriter;
51	import org.apache.carbondata.format.BlockIndex;
52	import org.apache.carbondata.format.BlockletInfo3;
53	import org.apache.carbondata.format.IndexHeader;
54	import org.apache.carbondata.processing.datamap.DataMapWriterListener;
55	import org.apache.carbondata.processing.store.CarbonFactDataHandlerModel;
56
57	import org.apache.log4j.Logger;
58
59	public abstract class AbstractFactDataWriter implements CarbonFactDataWriter {
60
61	private static final Logger LOGGER =	1✔
62	LogServiceFactory.getLogService(AbstractFactDataWriter.class.getName());	1✔
63
64	/**
65	* file channel to write
66	*/
67	protected WritableByteChannel fileChannel;
68	protected long currentOffsetInFile;
69	/**
70	* The path of CarbonData file to write in hdfs/s3
71	*/
72	private String carbonDataFileStorePath;
73	/**
74	* The temp path of carbonData file used on executor
75	*/
76	private String carbonDataFileTempPath;
77
78	/**
79	* The name of carbonData file (blockId)
80	*/
81	protected String carbonDataFileName;
82
83	/**
84	* The sequence number of blocklet inside one block
85	*/
86	protected int blockletId = 0;	1✔
87
88	/**
89	* The sequence number of page inside one blocklet
90	*/
91	protected int pageId = 0;	1✔
92
93	/**
94	* Local cardinality for the segment
95	*/
96	protected int[] localCardinality;
97	/**
98	* thrift column schema
99	*/
100	protected List<org.apache.carbondata.format.ColumnSchema> thriftColumnSchemaList;
101	protected NumberCompressor numberCompressor;
102	protected CarbonFactDataHandlerModel model;
103	protected List<List<Long>> dataChunksOffsets;
104	protected List<List<Short>> dataChunksLength;
105	/**
106	* data file size;
107	*/
108	protected long fileSizeInBytes;
109	/**
110	* file count will be used to give sequence number to the data file
111	*/
112	private int fileCount;
113	/**
114	* executorService
115	*/
116	private ExecutorService executorService;
117	/**
118	* executorService
119	*/
120	private List<Future<Void>> executorServiceSubmitList;
121	/**
122	* data block size for one carbon data file
123	*/
124	private long blockSizeThreshold;
125	/**
126	* file size at any given point
127	*/
128	private long currentFileSize;
129
130	protected DataOutputStream fileOutputStream;
131
132	protected List<BlockIndexInfo> blockIndexInfoList;
133
134	/**
135	* list of metadata for V3 format
136	*/
137	protected List<BlockletInfo3> blockletMetadata;
138
139	/**
140	* list of blocklet index
141	*/
142	protected List<org.apache.carbondata.format.BlockletIndex> blockletIndex;
143
144	/**
145	* listener to write data map
146	*/
147	protected DataMapWriterListener listener;
148	/**
149	* Whether directly write fact data to store path
150	*/
151	private boolean enableDirectlyWriteDataToStorePath = false;	1✔
152
153	protected ExecutorService fallbackExecutorService;
154
155	public AbstractFactDataWriter(CarbonFactDataHandlerModel model) {	1✔
156	this.model = model;	1✔
157	blockIndexInfoList = new ArrayList<>();	1✔
158	// get max file size;
159	CarbonProperties propInstance = CarbonProperties.getInstance();	1✔
160	// if blocksize=2048, then 204810241024 will beyond the range of Int
161	this.fileSizeInBytes =	1✔
162	(long) this.model.getBlockSizeInMB() * CarbonCommonConstants.BYTE_TO_KB_CONVERSION_FACTOR	1✔
163	* CarbonCommonConstants.BYTE_TO_KB_CONVERSION_FACTOR;
164
165	// size reserved in one file for writing block meta data. It will be in percentage
166	int spaceReservedForBlockMetaSize = Integer.parseInt(propInstance	1✔
167	.getProperty(CarbonCommonConstants.CARBON_BLOCK_META_RESERVED_SPACE,	1✔
168	CarbonCommonConstants.CARBON_BLOCK_META_RESERVED_SPACE_DEFAULT));
169	this.blockSizeThreshold =	1✔
170	fileSizeInBytes - (fileSizeInBytes * spaceReservedForBlockMetaSize) / 100;
171	LOGGER	1✔
172	.info("Total file size: " + fileSizeInBytes + " and dataBlock Size: " + blockSizeThreshold);	1✔
173
174	// whether to directly write fact data to HDFS
175	String directlyWriteData2Hdfs = propInstance	1✔
176	.getProperty(CarbonLoadOptionConstants.ENABLE_CARBON_LOAD_DIRECT_WRITE_TO_STORE_PATH,	1✔
177	CarbonLoadOptionConstants.ENABLE_CARBON_LOAD_DIRECT_WRITE_TO_STORE_PATH_DEFAULT);
178	this.enableDirectlyWriteDataToStorePath = "TRUE".equalsIgnoreCase(directlyWriteData2Hdfs);	1✔
179
180	if (enableDirectlyWriteDataToStorePath) {	1✔
181	LOGGER.info("Carbondata will directly write fact data to HDFS.");	1✔
182	} else {
183	LOGGER.info("Carbondata will write temporary fact data to local disk.");	1✔
184	}
185
186	this.executorService = Executors.newFixedThreadPool(1,	1✔
187	new CarbonThreadFactory("CompleteHDFSBackendPool:" + this.model.getTableName()));	1✔
188	executorServiceSubmitList = new ArrayList<>(CarbonCommonConstants.DEFAULT_COLLECTION_SIZE);	1✔
189	// in case of compaction we will pass the cardinality.
190	this.localCardinality = this.model.getColCardinality();	1✔
191
192	List<Integer> cardinalityList = new ArrayList<Integer>();	1✔
193	thriftColumnSchemaList = getColumnSchemaListAndCardinality(cardinalityList, localCardinality,	1✔
194	this.model.getWrapperColumnSchema());	1✔
195	this.numberCompressor = new NumberCompressor(Integer.parseInt(CarbonProperties.getInstance()	1✔
196	.getProperty(CarbonCommonConstants.BLOCKLET_SIZE,	1✔
197	CarbonCommonConstants.BLOCKLET_SIZE_DEFAULT_VAL)));
198	this.dataChunksOffsets = new ArrayList<>();	1✔
199	this.dataChunksLength = new ArrayList<>();	1✔
200	blockletMetadata = new ArrayList<BlockletInfo3>();	1✔
201	blockletIndex = new ArrayList<>();	1✔
202	listener = this.model.getDataMapWriterlistener();	1✔
203	if (model.getColumnLocalDictGenMap().size() > 0) {	1✔
204	int numberOfCores = 1;	1✔
205	if (model.getNumberOfCores() > 1) {	1✔
206	numberOfCores = model.getNumberOfCores() / 2;	1✔
207	}
208	fallbackExecutorService = Executors.newFixedThreadPool(numberOfCores, new CarbonThreadFactory(	1✔
209	"FallbackPool:" + model.getTableName() + ", range: " + model.getBucketId()));	1✔
210	}
211	}	1✔
212
213	/**
214	* This method will be used to update the file channel with new file if exceeding block size
215	* threshold, new file will be created once existing file reached the file size limit This
216	* method will first check whether existing file size is exceeded the file
217	* size limit if yes then write the leaf metadata to file then set the
218	* current file size to 0 close the existing file channel get the new file
219	* name and get the channel for new file
220	*
221	* @param blockletSizeToBeAdded data size of one block
222	* @throws CarbonDataWriterException if any problem
223	*/
224	protected void createNewFileIfReachThreshold(long blockletSizeToBeAdded)
225	throws CarbonDataWriterException {
226	if ((currentFileSize + blockletSizeToBeAdded) >= blockSizeThreshold && currentFileSize != 0) {	1✔
227	// set the current file size to zero
228	String activeFile =	1✔
229	enableDirectlyWriteDataToStorePath ? carbonDataFileStorePath : carbonDataFileTempPath;
230	LOGGER.info("Writing data to file as max file size reached for file: "	1✔
231	+ activeFile + ". Data block size: " + currentFileSize);
232	// write meta data to end of the existing file
233	writeFooterToFile();	1✔
234	this.currentFileSize = 0;	1✔
235	this.dataChunksOffsets = new ArrayList<>();	1✔
236	this.dataChunksLength = new ArrayList<>();	1✔
237	this.blockletMetadata = new ArrayList<>();	1✔
238	this.blockletIndex = new ArrayList<>();	1✔
239	commitCurrentFile(false);	1✔
240	// initialize the new channel
241	initializeWriter();	1✔
242	}
243	currentFileSize += blockletSizeToBeAdded;	1✔
244	}	1✔
245
246	private void notifyDataMapBlockStart() {
247	if (listener != null) {	1✔
248	try {
249	listener.onBlockStart(carbonDataFileName);	1✔
250	} catch (IOException e) {	×
251	throw new CarbonDataWriterException("Problem while writing datamap", e);	×
252	}	1✔
253	}
254	}	1✔
255
256	private void notifyDataMapBlockEnd() {
257	if (listener != null) {	1✔
258	try {
259	listener.onBlockEnd(carbonDataFileName);	1✔
260	} catch (IOException e) {	×
261	throw new CarbonDataWriterException("Problem while writing datamap", e);	×
262	}	1✔
263	}
264	}	1✔
265
266	/**
267	* Finish writing current file. It will flush stream, copy and rename temp file to final file
268	* @param copyInCurrentThread set to false if want to do data copy in a new thread
269	*/
270	protected void commitCurrentFile(boolean copyInCurrentThread) {
271	notifyDataMapBlockEnd();	1✔
272	CarbonUtil.closeStreams(this.fileOutputStream, this.fileChannel);	1✔
273	if (!enableDirectlyWriteDataToStorePath) {	1✔
274	try {
275	if (copyInCurrentThread) {	1✔
276	CarbonUtil.copyCarbonDataFileToCarbonStorePath(carbonDataFileTempPath,	1✔
277	model.getCarbonDataDirectoryPath(), fileSizeInBytes);	1✔
278	FileFactory	1✔
279	.deleteFile(carbonDataFileTempPath, FileFactory.getFileType(carbonDataFileTempPath));	1✔
280	} else {
281	executorServiceSubmitList	1✔
282	.add(executorService.submit(new CompleteHdfsBackendThread(carbonDataFileTempPath)));	1✔
283	}
284	} catch (IOException e) {	×
285	LOGGER.error(e);	×
286	}	1✔
287	}
288	}	1✔
289
290	/**
291	* This method will be used to initialize the channel
292	*
293	* @throws CarbonDataWriterException
294	*/
295	public void initializeWriter() throws CarbonDataWriterException {
296	this.carbonDataFileName = CarbonTablePath	1✔
297	.getCarbonDataFileName(fileCount, model.getCarbonDataFileAttributes().getTaskId(),	1✔
298	model.getBucketId(), model.getTaskExtension(),	1✔
299	"" + model.getCarbonDataFileAttributes().getFactTimeStamp(), model.getSegmentId());	1✔
300	this.carbonDataFileStorePath = model.getCarbonDataDirectoryPath() + File.separator	1✔
301	+ carbonDataFileName;
302	try {
303	if (enableDirectlyWriteDataToStorePath) {	1✔
304	// the block size will be twice the block_size specified by user to make sure that
305	// one carbondata file only consists exactly one HDFS block.
306	fileOutputStream = FileFactory	1✔
307	.getDataOutputStream(carbonDataFileStorePath, FileFactory.FileType.HDFS,	1✔
308	CarbonCommonConstants.BYTEBUFFER_SIZE, fileSizeInBytes * 2);
309	} else {
310	//each time we initialize writer, we choose a local temp location randomly
311	String[] tempFileLocations = model.getStoreLocation();	1✔
312	String chosenTempLocation =	1✔
313	tempFileLocations[new Random().nextInt(tempFileLocations.length)];	1✔
314	LOGGER.info("Randomly choose factdata temp location: " + chosenTempLocation);	1✔
315	carbonDataFileTempPath = chosenTempLocation + File.separator + carbonDataFileName;	1✔
316	fileOutputStream = FileFactory.getDataOutputStream(carbonDataFileTempPath,	1✔
317	FileFactory.FileType.LOCAL, CarbonCommonConstants.BYTEBUFFER_SIZE, true);
318	}
319
320	this.fileCount++;	1✔
321	// open channel for new data file
322	this.fileChannel = Channels.newChannel(fileOutputStream);	1✔
323	this.currentOffsetInFile = 0;	1✔
324	} catch (IOException ex) {	×
325	throw new CarbonDataWriterException(	×
326	"Problem while getting the channel for fact data file", ex);
327	}	1✔
328	notifyDataMapBlockStart();	1✔
329	}	1✔
330
331	/**
332	* This method will write metadata at the end of file file format in thrift format
333	*/
334	protected abstract void writeFooterToFile() throws CarbonDataWriterException;
335
336	/**
337	* Below method will be used to fill the vlock info details
338	*
339	* @param numberOfRows number of rows in file
340	* @param carbonDataFileName The name of carbonData file
341	* @param currentPosition current offset
342	*/
343	protected abstract void fillBlockIndexInfoDetails(long numberOfRows, String carbonDataFileName,
344	long currentPosition);
345
346	public static List<org.apache.carbondata.format.ColumnSchema> getColumnSchemaListAndCardinality(
347	List<Integer> cardinality, int[] dictionaryColumnCardinality,
348	List<ColumnSchema> wrapperColumnSchemaList) {
349	List<org.apache.carbondata.format.ColumnSchema> columnSchemaList =	1✔
350	new ArrayList<org.apache.carbondata.format.ColumnSchema>(
351	CarbonCommonConstants.DEFAULT_COLLECTION_SIZE);
352	SchemaConverter schemaConverter = new ThriftWrapperSchemaConverterImpl();	1✔
353	int counter = 0;	1✔
354	for (int i = 0; i < wrapperColumnSchemaList.size(); i++) {	1✔
355	columnSchemaList	1✔
356	.add(schemaConverter.fromWrapperToExternalColumnSchema(wrapperColumnSchemaList.get(i)));	1✔
357	if (CarbonUtil.hasEncoding(wrapperColumnSchemaList.get(i).getEncodingList(),	1✔
358	org.apache.carbondata.core.metadata.encoder.Encoding.DICTIONARY)) {
359	cardinality.add(dictionaryColumnCardinality[counter]);	1✔
360	counter++;	1✔
361	} else if (!wrapperColumnSchemaList.get(i).isDimensionColumn()) {	1✔
362	continue;	1✔
363	} else {
364	cardinality.add(-1);	1✔
365	}
366	}
367	return columnSchemaList;	1✔
368	}
369
370	/**
371	* Below method will be used to write the idex file
372	*
373	* @throws IOException throws io exception if any problem while writing
374	* @throws CarbonDataWriterException data writing
375	*/
376	protected void writeIndexFile() throws IOException, CarbonDataWriterException {
377	// get the header
378	IndexHeader indexHeader = CarbonMetadataUtil	1✔
379	.getIndexHeader(localCardinality, thriftColumnSchemaList, model.getBucketId(),	1✔
380	model.getSchemaUpdatedTimeStamp());	1✔
381	// get the block index info thrift
382	List<BlockIndex> blockIndexThrift = CarbonMetadataUtil.getBlockIndexInfo(blockIndexInfoList);	1✔
383	String indexFileName;
384	if (enableDirectlyWriteDataToStorePath) {	1✔
385	String rawFileName = model.getCarbonDataDirectoryPath() + CarbonCommonConstants.FILE_SEPARATOR	1✔
386	+ CarbonTablePath.getCarbonIndexFileName(model.getCarbonDataFileAttributes().getTaskId(),	1✔
387	model.getBucketId(), model.getTaskExtension(),	1✔
388	"" + model.getCarbonDataFileAttributes().getFactTimeStamp(), model.getSegmentId());	1✔
389	indexFileName = FileFactory.getUpdatedFilePath(rawFileName, FileFactory.FileType.HDFS);	1✔
390	} else {	1✔
391	// randomly choose a temp location for index file
392	String[] tempLocations = model.getStoreLocation();	1✔
393	String chosenTempLocation = tempLocations[new Random().nextInt(tempLocations.length)];	1✔
394	LOGGER.info("Randomly choose index file location: " + chosenTempLocation);	1✔
395	indexFileName = chosenTempLocation + File.separator + CarbonTablePath	1✔
396	.getCarbonIndexFileName(model.getCarbonDataFileAttributes().getTaskId(),	1✔
397	model.getBucketId(), model.getTaskExtension(),	1✔
398	"" + model.getCarbonDataFileAttributes().getFactTimeStamp(), model.getSegmentId());	1✔
399	}
400
401	CarbonIndexFileWriter writer = new CarbonIndexFileWriter();	1✔
402	// open file
403	writer.openThriftWriter(indexFileName);	1✔
404	// write the header first
405	writer.writeThrift(indexHeader);	1✔
406	// write the indexes
407	for (BlockIndex blockIndex : blockIndexThrift) {	1✔
408	writer.writeThrift(blockIndex);	1✔
409	}	1✔
410	writer.close();	1✔
411	if (!enableDirectlyWriteDataToStorePath) {	1✔
412	CarbonUtil	1✔
413	.copyCarbonDataFileToCarbonStorePath(indexFileName, model.getCarbonDataDirectoryPath(),	1✔
414	fileSizeInBytes);
415	FileFactory.deleteFile(indexFileName, FileFactory.getFileType(indexFileName));	1✔
416	}
417	}	1✔
418
419	/**
420	* This method will close the executor service which is used for copying carbon
421	* data files to carbon store path
422	*
423	* @throws CarbonDataWriterException
424	*/
425	protected void closeExecutorService() throws CarbonDataWriterException {
426	CarbonDataWriterException exception = null;	1✔
427	try {
428	listener.finish();	1✔
429	listener = null;	1✔
430	} catch (IOException e) {	×
431	exception = new CarbonDataWriterException(e);	×
432	}	1✔
433	try {
434	executorService.shutdown();	1✔
435	executorService.awaitTermination(2, TimeUnit.HOURS);	1✔
436	for (int i = 0; i < executorServiceSubmitList.size(); i++) {	1✔
437	executorServiceSubmitList.get(i).get();	1✔
438	}
439	} catch (InterruptedException \| ExecutionException e) {	×
440	if (null == exception) {	×
441	exception = new CarbonDataWriterException(e);	×
442	}
443	}	1✔
444	if (null != fallbackExecutorService) {	1✔
445	fallbackExecutorService.shutdownNow();	1✔
446	}
447	if (exception != null) {	1✔
448	throw exception;	×
449	}
450	}	1✔
451
452
453
454	/**
455	* This method will complete hdfs backend storage for this file.
456	* It may copy the carbon data file from local store location to carbon store location,
457	* it may also complete the remaining replications for the existing hdfs file.
458	*/
459	private final class CompleteHdfsBackendThread implements Callable<Void> {
460
461	/**
462	* complete path along with file name which needs to be copied to
463	* carbon store path
464	*/
465	private String fileName;
466
467	private CompleteHdfsBackendThread(String fileName) {	1✔
468	this.fileName = fileName;	1✔
469	}	1✔
470
471	/**
472	* Computes a result, or throws an exception if unable to do so.
473	*
474	* @return computed result
475	* @throws Exception if unable to compute a result
476	*/
477	@Override
478	public Void call() throws Exception {
479	CarbonUtil.copyCarbonDataFileToCarbonStorePath(fileName, model.getCarbonDataDirectoryPath(),	1✔
480	fileSizeInBytes);
481	FileFactory.deleteFile(fileName, FileFactory.getFileType(fileName));	1✔
482	return null;	1✔
483	}
484	}
485	}

apache / carbondata / 9618

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous