8852

Build # 8852

Build Type

push

jenkins

Committed by GitHub

Commit Message

<a href="https://github.com/apache/carbondata/commit/<a class=hub.com/apache/carbondata/commit/1312b9efff4e0800dcd914a63f6ec9c23633c357">1312b9eff<a href="https://github.com/apache/carbondata/commit/1312b9efff4e0800dcd914a63f6ec9c23633c357">">Merge </a><a class="double-link" href="https://github.com/apache/carbondata/commit/<a class="double-link" href="https://github.com/apache/carbondata/commit/33b60dd368d7677b6336579497c7e0e58cf8d5cb">33b60dd36</a>">33b60dd36</a><a href="https://github.com/apache/carbondata/commit/1312b9efff4e0800dcd914a63f6ec9c23633c357"> into 3cd8b947c">3cd8b947c</a>

Run Details

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

60237 of 75024 relevant lines covered (80.29%)

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.LogService;
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;

public abstract class AbstractFactDataWriter implements CarbonFactDataWriter {

  private static final LogService 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
   */
  private String carbonDataFileHdfsPath;
  /**
   * 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 hdfs
   */
  private boolean enableDirectlyWriteData2Hdfs = 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_HDFS,
            CarbonLoadOptionConstants.ENABLE_CARBON_LOAD_DIRECT_WRITE_HDFS_DEFAULT);
    this.enableDirectlyWriteData2Hdfs = "TRUE".equalsIgnoreCase(directlyWriteData2Hdfs);

    if (enableDirectlyWriteData2Hdfs) {
      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 =
          enableDirectlyWriteData2Hdfs ? carbonDataFileHdfsPath : 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 (!enableDirectlyWriteData2Hdfs) {
      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("Failed to delete carbondata file from temp location" + e.getMessage());
      }
    }
  }

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

apache / carbondata / 8852

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