| /* |
| * 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.iotdb.tsfile.common.conf; |
| |
| import org.apache.iotdb.tsfile.common.constant.TsFileConstant; |
| import org.apache.iotdb.tsfile.utils.Loader; |
| |
| import org.slf4j.Logger; |
| import org.slf4j.LoggerFactory; |
| |
| import java.io.FileInputStream; |
| import java.io.FileNotFoundException; |
| import java.io.IOException; |
| import java.io.InputStreamReader; |
| import java.net.URI; |
| import java.net.URISyntaxException; |
| import java.net.URL; |
| import java.nio.charset.StandardCharsets; |
| import java.nio.file.Paths; |
| import java.util.Optional; |
| import java.util.Properties; |
| import java.util.Set; |
| import java.util.function.Consumer; |
| import java.util.function.Function; |
| |
| /** TSFileDescriptor is used to load TSFileConfig and provide configure information. */ |
| public class TSFileDescriptor { |
| |
| private static final Logger logger = LoggerFactory.getLogger(TSFileDescriptor.class); |
| private final TSFileConfig conf = new TSFileConfig(); |
| |
| /** The constructor just visible for test. */ |
| /* private */ TSFileDescriptor() { |
| init(); |
| } |
| |
| public static TSFileDescriptor getInstance() { |
| return TsfileDescriptorHolder.INSTANCE; |
| } |
| |
| public TSFileConfig getConfig() { |
| return conf; |
| } |
| |
| private void init() { |
| loadProperties().ifPresent(this::overwriteConfigByCustomSettings); |
| } |
| |
| public void overwriteConfigByCustomSettings(Properties properties) { |
| PropertiesOverWriter writer = new PropertiesOverWriter(properties); |
| |
| writer.setInt(conf::setGroupSizeInByte, "group_size_in_byte"); |
| writer.setInt(conf::setPageSizeInByte, "page_size_in_byte"); |
| if (conf.getPageSizeInByte() > conf.getGroupSizeInByte()) { |
| int groupSizeInByte = conf.getGroupSizeInByte(); |
| logger.warn( |
| "page_size is greater than group size, will set it as the same with group size {}", |
| groupSizeInByte); |
| conf.setPageSizeInByte(groupSizeInByte); |
| } |
| writer.setInt(conf::setMaxNumberOfPointsInPage, "max_number_of_points_in_page"); |
| writer.setInt(conf::setMaxDegreeOfIndexNode, "max_degree_of_index_node"); |
| writer.setInt(conf::setMaxStringLength, "max_string_length"); |
| writer.setInt(conf::setFloatPrecision, "float_precision"); |
| writer.setString(conf::setValueEncoder, "value_encoder"); |
| writer.setString(conf::setCompressor, "compressor"); |
| writer.setInt(conf::setBatchSize, "batch_size"); |
| } |
| |
| private static class PropertiesOverWriter { |
| |
| private final Properties properties; |
| |
| public PropertiesOverWriter(Properties properties) { |
| if (properties == null) { |
| throw new NullPointerException("properties should not be null"); |
| } |
| this.properties = properties; |
| } |
| |
| public void setInt(Consumer<Integer> setter, String propertyKey) { |
| set(setter, propertyKey, Integer::parseInt); |
| } |
| |
| public void setDouble(Consumer<Double> setter, String propertyKey) { |
| set(setter, propertyKey, Double::parseDouble); |
| } |
| |
| public void setString(Consumer<String> setter, String propertyKey) { |
| set(setter, propertyKey, Function.identity()); |
| } |
| |
| private <T> void set( |
| Consumer<T> setter, String propertyKey, Function<String, T> propertyValueConverter) { |
| String value = this.properties.getProperty(propertyKey); |
| |
| if (value != null) { |
| try { |
| T v = propertyValueConverter.apply(value); |
| setter.accept(v); |
| } catch (Exception e) { |
| logger.warn("invalid value for {}, use the default value", propertyKey); |
| } |
| } |
| } |
| } |
| |
| private Optional<Properties> loadProperties() { |
| String file = detectPropertiesFile(); |
| if (file != null) { |
| logger.info("try loading {} from {}", TSFileConfig.CONFIG_FILE_NAME, file); |
| return loadPropertiesFromFile(file); |
| } else { |
| logger.warn("not found {}, use the default configs.", TSFileConfig.CONFIG_FILE_NAME); |
| return Optional.empty(); |
| } |
| } |
| |
| private Optional<Properties> loadPropertiesFromFile(String filePath) { |
| try (FileInputStream fileInputStream = new FileInputStream(filePath)) { |
| Properties properties = new Properties(); |
| properties.load(new InputStreamReader(fileInputStream, StandardCharsets.UTF_8)); |
| return Optional.of(properties); |
| } catch (FileNotFoundException e) { |
| logger.warn("Fail to find config file {}", filePath); |
| return Optional.empty(); |
| } catch (IOException e) { |
| logger.warn("read file ({}) failure, please check the access permissions.", filePath); |
| return Optional.empty(); |
| } |
| } |
| |
| private String detectPropertiesFile() { |
| String confDirectory = System.getProperty(TsFileConstant.TSFILE_CONF); |
| if (confDirectory != null) { |
| return Paths.get(confDirectory, TSFileConfig.CONFIG_FILE_NAME).toAbsolutePath().toString(); |
| } |
| String tsFileHome = System.getProperty(TsFileConstant.TSFILE_HOME); |
| if (tsFileHome != null) { |
| return Paths.get(tsFileHome, "conf", TSFileConfig.CONFIG_FILE_NAME) |
| .toAbsolutePath() |
| .toString(); |
| } |
| |
| return detectPropertiesFromClassPath(); |
| } |
| |
| private static URL getResource(String filename, ClassLoader classLoader) { |
| return Loader.getResource(filename, classLoader); |
| } |
| |
| private String detectPropertiesFromClassPath() { |
| ClassLoader classLoader = Loader.getClassLoaderOfObject(this); |
| URL u = getResource(TSFileConfig.CONFIG_FILE_NAME, classLoader); |
| if (u == null) { |
| return null; |
| } else { |
| multiplicityWarning(TSFileConfig.CONFIG_FILE_NAME, classLoader); |
| return u.getFile(); |
| } |
| } |
| |
| private void multiplicityWarning(String resource, ClassLoader classLoader) { |
| try { |
| Set<URI> uriSet = Loader.getResources(resource, classLoader); |
| if (uriSet.size() > 1) { |
| logger.warn("Resource [{}] occurs multiple times on the classpath", resource); |
| for (URI uri : uriSet) { |
| logger.warn("Resource [{}] occurs at [{}]", resource, uri); |
| } |
| } |
| } catch (IOException | URISyntaxException e) { |
| logger.error("Failed to get url list for {}", resource); |
| } |
| } |
| |
| private static class TsfileDescriptorHolder { |
| |
| private TsfileDescriptorHolder() { |
| throw new IllegalAccessError("Utility class"); |
| } |
| |
| private static final TSFileDescriptor INSTANCE = new TSFileDescriptor(); |
| } |
| } |