/*
* 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.ignite.configuration;
import org.apache.ignite.cache.CacheMode;
import org.apache.ignite.igfs.IgfsIpcEndpointConfiguration;
import org.apache.ignite.igfs.IgfsMode;
import org.apache.ignite.igfs.IgfsOutputStream;
import org.apache.ignite.igfs.secondary.IgfsSecondaryFileSystem;
import org.apache.ignite.internal.util.typedef.internal.A;
import org.apache.ignite.internal.util.typedef.internal.S;
import org.jetbrains.annotations.Nullable;
import java.util.Map;
/**
* {@code IGFS} configuration. More than one file system can be configured within grid.
* {@code IGFS} configuration is provided via {@link IgniteConfiguration#getFileSystemConfiguration()}
* method.
*/
public class FileSystemConfiguration {
/** Default file system user name. */
public static final String DFLT_USER_NAME = System.getProperty("user.name", "anonymous");
/** Default fragmentizer throttling block length. */
public static final long DFLT_FRAGMENTIZER_THROTTLING_BLOCK_LENGTH = 16 * 1024 * 1024;
/** Default fragmentizer throttling delay. */
public static final long DFLT_FRAGMENTIZER_THROTTLING_DELAY = 200;
/** Default fragmentizer concurrent files. */
public static final int DFLT_FRAGMENTIZER_CONCURRENT_FILES = 0;
/** Fragmentizer enabled property. */
public static final boolean DFLT_FRAGMENTIZER_ENABLED = true;
/** Default batch size for logging. */
public static final int DFLT_IGFS_LOG_BATCH_SIZE = 100;
/** Default {@code IGFS} log directory. */
public static final String DFLT_IGFS_LOG_DIR = "work/igfs/log";
/** Default per node buffer size. */
public static final int DFLT_PER_NODE_BATCH_SIZE = 512;
/** Default number of per node parallel operations. */
public static final int DFLT_PER_NODE_PARALLEL_BATCH_CNT = 16;
/** Default IGFS mode. */
public static final IgfsMode DFLT_MODE = IgfsMode.DUAL_ASYNC;
/** Default file's data block size (bytes). */
public static final int DFLT_BLOCK_SIZE = 1 << 16;
/** Default read/write buffers size (bytes). */
public static final int DFLT_BUF_SIZE = 1 << 16;
/** Default management port. */
public static final int DFLT_MGMT_PORT = 11400;
/** Default IPC endpoint enabled flag. */
public static final boolean DFLT_IPC_ENDPOINT_ENABLED = true;
/** Default value of metadata co-location flag. */
public static final boolean DFLT_COLOCATE_META = true;
/** Default value of relaxed consistency flag. */
public static final boolean DFLT_RELAXED_CONSISTENCY = true;
/** Default value of update file length on flush flag. */
public static final boolean DFLT_UPDATE_FILE_LEN_ON_FLUSH = false;
/** IGFS instance name. */
private String name;
/** File's data block size (bytes). */
private int blockSize = DFLT_BLOCK_SIZE;
/** The number of pre-fetched blocks if specific file's chunk is requested. */
private int prefetchBlocks;
/** Amount of sequential block reads before prefetch is triggered. */
private int seqReadsBeforePrefetch;
/** Read/write buffers size for stream operations (bytes). */
private int bufSize = DFLT_BUF_SIZE;
/** Per node buffer size. */
private int perNodeBatchSize = DFLT_PER_NODE_BATCH_SIZE;
/** Per node parallel operations. */
private int perNodeParallelBatchCnt = DFLT_PER_NODE_PARALLEL_BATCH_CNT;
/** IPC endpoint configuration. */
private IgfsIpcEndpointConfiguration ipcEndpointCfg;
/** IPC endpoint enabled flag. */
private boolean ipcEndpointEnabled = DFLT_IPC_ENDPOINT_ENABLED;
/** Management port. */
private int mgmtPort = DFLT_MGMT_PORT;
/** Secondary file system */
private IgfsSecondaryFileSystem secondaryFs;
/** IGFS mode. */
private IgfsMode dfltMode = DFLT_MODE;
/** Fragmentizer throttling block length. */
private long fragmentizerThrottlingBlockLen = DFLT_FRAGMENTIZER_THROTTLING_BLOCK_LENGTH;
/** Fragmentizer throttling delay. */
private long fragmentizerThrottlingDelay = DFLT_FRAGMENTIZER_THROTTLING_DELAY;
/** Fragmentizer concurrent files. */
private int fragmentizerConcurrentFiles = DFLT_FRAGMENTIZER_CONCURRENT_FILES;
/** Fragmentizer enabled flag. */
private boolean fragmentizerEnabled = DFLT_FRAGMENTIZER_ENABLED;
/** Path modes. */
private Map<String, IgfsMode> pathModes;
/** Maximum range length. */
private long maxTaskRangeLen;
/** Metadata co-location flag. */
private boolean colocateMeta = DFLT_COLOCATE_META;
/** Relaxed consistency flag. */
private boolean relaxedConsistency = DFLT_RELAXED_CONSISTENCY;
/** Update file length on flush flag. */
private boolean updateFileLenOnFlush = DFLT_UPDATE_FILE_LEN_ON_FLUSH;
/** Meta cache config. */
private CacheConfiguration metaCacheCfg;
/** Data cache config. */
private CacheConfiguration dataCacheCfg;
/**
* Constructs default configuration.
*/
public FileSystemConfiguration() {
// No-op.
}
/**
* Constructs the copy of the configuration.
*
* @param cfg Configuration to copy.
*/
public FileSystemConfiguration(FileSystemConfiguration cfg) {
assert cfg != null;
/*
* Must preserve alphabetical order!
*/
blockSize = cfg.getBlockSize();
bufSize = cfg.getBufferSize();
colocateMeta = cfg.isColocateMetadata();
dataCacheCfg = cfg.getDataCacheConfiguration();
dfltMode = cfg.getDefaultMode();
fragmentizerConcurrentFiles = cfg.getFragmentizerConcurrentFiles();
fragmentizerEnabled = cfg.isFragmentizerEnabled();
fragmentizerThrottlingBlockLen = cfg.getFragmentizerThrottlingBlockLength();
fragmentizerThrottlingDelay = cfg.getFragmentizerThrottlingDelay();
secondaryFs = cfg.getSecondaryFileSystem();
ipcEndpointCfg = cfg.getIpcEndpointConfiguration();
ipcEndpointEnabled = cfg.isIpcEndpointEnabled();
maxTaskRangeLen = cfg.getMaximumTaskRangeLength();
metaCacheCfg = cfg.getMetaCacheConfiguration();
mgmtPort = cfg.getManagementPort();
name = cfg.getName();
pathModes = cfg.getPathModes();
perNodeBatchSize = cfg.getPerNodeBatchSize();
perNodeParallelBatchCnt = cfg.getPerNodeParallelBatchCount();
prefetchBlocks = cfg.getPrefetchBlocks();
relaxedConsistency = cfg.isRelaxedConsistency();
seqReadsBeforePrefetch = cfg.getSequentialReadsBeforePrefetch();
updateFileLenOnFlush = cfg.isUpdateFileLengthOnFlush();
}
/**
* Gets IGFS instance name.
*
* @return IGFS instance name.
*/
public String getName() {
return name;
}
/**
* Sets IGFS instance name.
*
* @param name IGFS instance name.
* @return {@code this} for chaining.
*/
public FileSystemConfiguration setName(String name) {
if (name == null)
throw new IllegalArgumentException("IGFS name cannot be null");
this.name = name;
return this;
}
/**
* Cache config to store IGFS meta information.
*
* @return Cache configuration object.
*/
@Nullable public CacheConfiguration getMetaCacheConfiguration() {
return metaCacheCfg;
}
/**
* Cache config to store IGFS meta information. If {@code null}, then default config for
* meta-cache will be used.
*
* Default configuration for the meta cache is:
* <ul>
* <li>atomicityMode = TRANSACTIONAL</li>
* <li>cacheMode = PARTITIONED</li>
* <li>backups = 1</li>
* </ul>
*
* @param metaCacheCfg Cache configuration object.
* @return {@code this} for chaining.
*/
public FileSystemConfiguration setMetaCacheConfiguration(CacheConfiguration metaCacheCfg) {
this.metaCacheCfg = metaCacheCfg;
return this;
}
/**
* Cache config to store IGFS data.
*
* @return Cache configuration object.
*/
@Nullable public CacheConfiguration getDataCacheConfiguration() {
return dataCacheCfg;
}
/**
* Cache config to store IGFS data. If {@code null}, then default config for
* data cache will be used.
*
* Default configuration for the data cache is:
* <ul>
* <<li>atomicityMode = TRANSACTIONAL</li>
* <li>cacheMode = PARTITIONED</li>
* <li>backups = 0</li>
* </ul>
*
* @param dataCacheCfg Cache configuration object.
* @return {@code this} for chaining.
*/
public FileSystemConfiguration setDataCacheConfiguration(CacheConfiguration dataCacheCfg) {
this.dataCacheCfg = dataCacheCfg;
return this;
}
/**
* Get file's data block size.
*
* @return File's data block size.
*/
public int getBlockSize() {
return blockSize;
}
/**
* Sets file's data block size.
*
* @param blockSize File's data block size (bytes) or {@code 0} to reset default value.
* @return {@code this} for chaining.
*/
public FileSystemConfiguration setBlockSize(int blockSize) {
A.ensure(blockSize >= 0, "blockSize >= 0");
this.blockSize = blockSize == 0 ? DFLT_BLOCK_SIZE : blockSize;
return this;
}
/**
* Get number of pre-fetched blocks if specific file's chunk is requested.
*
* @return The number of pre-fetched blocks.
*/
public int getPrefetchBlocks() {
return prefetchBlocks;
}
/**
* Sets the number of pre-fetched blocks if specific file's chunk is requested.
*
* @param prefetchBlocks New number of pre-fetched blocks.
* @return {@code this} for chaining.
*/
public FileSystemConfiguration setPrefetchBlocks(int prefetchBlocks) {
A.ensure(prefetchBlocks >= 0, "prefetchBlocks >= 0");
this.prefetchBlocks = prefetchBlocks;
return this;
}
/**
* Get amount of sequential block reads before prefetch is triggered. The
* higher this value, the longer IGFS will wait before starting to prefetch
* values ahead of time. Depending on the use case, this can either help
* or hurt performance.
* <p>
* Default is {@code 0} which means that pre-fetching will start right away.
* <h1 class="header">Integration With Hadoop</h1>
* This parameter can be also overridden for individual Hadoop MapReduce tasks by passing
* {@code fs.igfs.[name].open.sequential_reads_before_prefetch} configuration property directly to Hadoop
* MapReduce task.
* <p>
* <b>NOTE:</b> Integration with Hadoop is available only in {@code In-Memory Accelerator For Hadoop} edition.
*
* @return Amount of sequential block reads.
*/
public int getSequentialReadsBeforePrefetch() {
return seqReadsBeforePrefetch;
}
/**
* Sets amount of sequential block reads before prefetch is triggered. The
* higher this value, the longer IGFS will wait before starting to prefetch
* values ahead of time. Depending on the use case, this can either help
* or hurt performance.
* <p>
* Default is {@code 0} which means that pre-fetching will start right away.
* <h1 class="header">Integration With Hadoop</h1>
* This parameter can be also overridden for individual Hadoop MapReduce tasks by passing
* {@code fs.igfs.[name].open.sequential_reads_before_prefetch} configuration property directly to Hadoop
* MapReduce task.
* <p>
* <b>NOTE:</b> Integration with Hadoop is available only in {@code In-Memory Accelerator For Hadoop} edition.
*
* @param seqReadsBeforePrefetch Amount of sequential block reads before prefetch is triggered.
* @return {@code this} for chaining.
*/
public FileSystemConfiguration setSequentialReadsBeforePrefetch(int seqReadsBeforePrefetch) {
A.ensure(seqReadsBeforePrefetch >= 0, "seqReadsBeforePrefetch >= 0");
this.seqReadsBeforePrefetch = seqReadsBeforePrefetch;
return this;
}
/**
* Get read/write buffer size for {@code IGFS} stream operations in bytes.
*
* @return Read/write buffers size (bytes).
*/
public int getBufferSize() {
return bufSize;
}
/**
* Sets read/write buffers size for {@code IGFS} stream operations (bytes).
*
* @param bufSize Read/write buffers size for stream operations (bytes) or {@code 0} to reset default value.
* @return {@code this} for chaining.
*/
public FileSystemConfiguration setBufferSize(int bufSize) {
A.ensure(bufSize >= 0, "bufSize >= 0");
this.bufSize = bufSize == 0 ? DFLT_BUF_SIZE : bufSize;
return this;
}
/**
* Gets number of file blocks buffered on local node before sending batch to remote node.
*
* @return Per node buffer size.
*/
public int getPerNodeBatchSize() {
return perNodeBatchSize;
}
/**
* Sets number of file blocks collected on local node before sending batch to remote node.
*
* @param perNodeBatchSize Per node buffer size.
* @return {@code this} for chaining.
*/
public FileSystemConfiguration setPerNodeBatchSize(int perNodeBatchSize) {
this.perNodeBatchSize = perNodeBatchSize;
return this;
}
/**
* Gets number of batches that can be concurrently sent to remote node.
*
* @return Number of batches for each node.
*/
public int getPerNodeParallelBatchCount() {
return perNodeParallelBatchCnt;
}
/**
* Sets number of file block batches that can be concurrently sent to remote node.
*
* @param perNodeParallelBatchCnt Per node parallel load operations.
* @return {@code this} for chaining.
*/
public FileSystemConfiguration setPerNodeParallelBatchCount(int perNodeParallelBatchCnt) {
this.perNodeParallelBatchCnt = perNodeParallelBatchCnt;
return this;
}
/**
* Gets IPC endpoint configuration.
* <p>
* Endpoint is needed for communication between IGFS and {@code IgniteHadoopFileSystem} shipped with <b>Ignite
* Hadoop Accelerator</b>.
*
* @return IPC endpoint configuration.
*/
@Nullable public IgfsIpcEndpointConfiguration getIpcEndpointConfiguration() {
return ipcEndpointCfg;
}
/**
* Sets IPC endpoint configuration.
* <p>
* Endpoint is needed for communication between IGFS and {@code IgniteHadoopFileSystem} shipped with <b>Ignite
* Hadoop Accelerator</b>.
*
* @param ipcEndpointCfg IPC endpoint configuration.
* @return {@code this} for chaining.
*/
public FileSystemConfiguration setIpcEndpointConfiguration(@Nullable IgfsIpcEndpointConfiguration ipcEndpointCfg) {
this.ipcEndpointCfg = ipcEndpointCfg;
return this;
}
/**
* Get IPC endpoint enabled flag. In case it is set to {@code true} endpoint will be created and bound to specific
* port. Otherwise endpoint will not be created. Default value is {@link #DFLT_IPC_ENDPOINT_ENABLED}.
* <p>
* Endpoint is needed for communication between IGFS and {@code IgniteHadoopFileSystem} shipped with <b>Ignite
* Hadoop Accelerator</b>.
*
* @return {@code True} in case endpoint is enabled.
*/
public boolean isIpcEndpointEnabled() {
return ipcEndpointEnabled;
}
/**
* Set IPC endpoint enabled flag. See {@link #isIpcEndpointEnabled()}.
* <p>
* Endpoint is needed for communication between IGFS and {@code IgniteHadoopFileSystem} shipped with <b>Ignite
* Hadoop Accelerator</b>.
*
* @param ipcEndpointEnabled IPC endpoint enabled flag.
* @return {@code this} for chaining.
*/
public FileSystemConfiguration setIpcEndpointEnabled(boolean ipcEndpointEnabled) {
this.ipcEndpointEnabled = ipcEndpointEnabled;
return this;
}
/**
* Gets port number for management endpoint. All IGFS nodes should have this port open
* for Visor Management Console to work with IGFS.
* <p>
* Default value is {@link #DFLT_MGMT_PORT}
*
* @return Port number or {@code -1} if management endpoint should be disabled.
*/
public int getManagementPort() {
return mgmtPort;
}
/**
* Sets management endpoint port.
*
* @param mgmtPort port number or {@code -1} to disable management endpoint.
* @return {@code this} for chaining.
*/
public FileSystemConfiguration setManagementPort(int mgmtPort) {
this.mgmtPort = mgmtPort;
return this;
}
/**
* Gets mode to specify how {@code IGFS} interacts with Hadoop file system, like {@code HDFS}.
* Secondary Hadoop file system is provided for pass-through, write-through, and read-through
* purposes.
* <p>
* Default mode is {@link org.apache.ignite.igfs.IgfsMode#DUAL_ASYNC}. If secondary Hadoop file system is
* not configured, this mode will work just like {@link org.apache.ignite.igfs.IgfsMode#PRIMARY} mode.
*
* @return Mode to specify how IGFS interacts with secondary HDFS file system.
*/
public IgfsMode getDefaultMode() {
return dfltMode;
}
/**
* Sets {@code IGFS} mode to specify how it should interact with secondary
* Hadoop file system, like {@code HDFS}. Secondary Hadoop file system is provided
* for pass-through, write-through, and read-through purposes.
*
* @param dfltMode {@code IGFS} mode.
* @return {@code this} for chaining.
*/
public FileSystemConfiguration setDefaultMode(IgfsMode dfltMode) {
this.dfltMode = dfltMode;
return this;
}
/**
* Gets the secondary file system. Secondary file system is provided for pass-through, write-through,
* and read-through purposes.
*
* @return Secondary file system.
*/
public IgfsSecondaryFileSystem getSecondaryFileSystem() {
return secondaryFs;
}
/**
* Sets the secondary file system. Secondary file system is provided for pass-through, write-through,
* and read-through purposes.
*
* @param fileSystem Secondary file system.
* @return {@code this} for chaining.
*/
public FileSystemConfiguration setSecondaryFileSystem(IgfsSecondaryFileSystem fileSystem) {
secondaryFs = fileSystem;
return this;
}
/**
* Gets map of path prefixes to {@code IGFS} modes used for them.
* <p>
* If path doesn't correspond to any specified prefix or mappings are not provided, then
* {@link #getDefaultMode()} is used.
*
* @return Map of paths to {@code IGFS} modes.
*/
@Nullable public Map<String, IgfsMode> getPathModes() {
return pathModes;
}
/**
* Sets map of path prefixes to {@code IGFS} modes used for them.
* <p>
* If path doesn't correspond to any specified prefix or mappings are not provided, then
* {@link #getDefaultMode()} is used.
*
* @param pathModes Map of paths to {@code IGFS} modes.
* @return {@code this} for chaining.
*/
public FileSystemConfiguration setPathModes(Map<String, IgfsMode> pathModes) {
this.pathModes = pathModes;
return this;
}
/**
* Gets the length of file chunk to send before delaying the fragmentizer.
*
* @return File chunk length in bytes.
*/
public long getFragmentizerThrottlingBlockLength() {
return fragmentizerThrottlingBlockLen;
}
/**
* Sets length of file chunk to transmit before throttling is delayed.
*
* @param fragmentizerThrottlingBlockLen Block length in bytes.
* @return {@code this} for chaining.
*/
public FileSystemConfiguration setFragmentizerThrottlingBlockLength(long fragmentizerThrottlingBlockLen) {
this.fragmentizerThrottlingBlockLen = fragmentizerThrottlingBlockLen;
return this;
}
/**
* Gets throttle delay for fragmentizer.
*
* @return Throttle delay in milliseconds.
*/
public long getFragmentizerThrottlingDelay() {
return fragmentizerThrottlingDelay;
}
/**
* Sets delay in milliseconds for which fragmentizer is paused.
*
* @param fragmentizerThrottlingDelay Delay in milliseconds.
* @return {@code this} for chaining.
*/
public FileSystemConfiguration setFragmentizerThrottlingDelay(long fragmentizerThrottlingDelay) {
this.fragmentizerThrottlingDelay = fragmentizerThrottlingDelay;
return this;
}
/**
* Gets number of files that can be processed by fragmentizer concurrently.
*
* @return Number of files to process concurrently.
*/
public int getFragmentizerConcurrentFiles() {
return fragmentizerConcurrentFiles;
}
/**
* Sets number of files to process concurrently by fragmentizer.
*
* @param fragmentizerConcurrentFiles Number of files to process concurrently.
* @return {@code this} for chaining.
*/
public FileSystemConfiguration setFragmentizerConcurrentFiles(int fragmentizerConcurrentFiles) {
this.fragmentizerConcurrentFiles = fragmentizerConcurrentFiles;
return this;
}
/**
* Gets flag indicating whether IGFS fragmentizer is enabled. If fragmentizer is disabled, files will be
* written in distributed fashion.
*
* @return Flag indicating whether fragmentizer is enabled.
*/
public boolean isFragmentizerEnabled() {
return fragmentizerEnabled;
}
/**
* Sets property indicating whether fragmentizer is enabled.
*
* @param fragmentizerEnabled {@code True} if fragmentizer is enabled.
* @return {@code this} for chaining.
*/
public FileSystemConfiguration setFragmentizerEnabled(boolean fragmentizerEnabled) {
this.fragmentizerEnabled = fragmentizerEnabled;
return this;
}
/**
* Get maximum default range size of a file being split during IGFS task execution. When IGFS task is about to
* be executed, it requests file block locations first. Each location is defined as {@link org.apache.ignite.igfs.mapreduce.IgfsFileRange} which
* has length. In case this parameter is set to positive value, then IGFS will split single file range into smaller
* ranges with length not greater that this parameter. The only exception to this case is when maximum task range
* length is smaller than file block size. In this case maximum task range size will be overridden and set to file
* block size.
* <p>
* Note that this parameter is applied when task is split into jobs before {@link org.apache.ignite.igfs.mapreduce.IgfsRecordResolver} is
* applied. Therefore, final file ranges being assigned to particular jobs could be greater than value of this
* parameter depending on file data layout and selected resolver type.
* <p>
* Setting this parameter might be useful when file is highly colocated and have very long consequent data chunks
* so that task execution suffers from insufficient parallelism. E.g., in case you have one IGFS node in topology
* and want to process 1Gb file, then only single range of length 1Gb will be returned. This will result in
* a single job which will be processed in one thread. But in case you provide this configuration parameter and set
* maximum range length to 16Mb, then 64 ranges will be returned resulting in 64 jobs which could be executed in
* parallel.
* <p>
* Note that some {@code IgniteFs.execute()} methods can override value of this parameter.
* <p>
* In case value of this parameter is set to {@code 0} or negative value, it is simply ignored. Default value is
* {@code 0}.
*
* @return Maximum range size of a file being split during IGFS task execution.
*/
public long getMaximumTaskRangeLength() {
return maxTaskRangeLen;
}
/**
* Set maximum default range size of a file being split during IGFS task execution.
* See {@link #getMaximumTaskRangeLength()} for more details.
*
* @param maxTaskRangeLen Set maximum default range size of a file being split during IGFS task execution.
* @return {@code this} for chaining.
*/
public FileSystemConfiguration setMaximumTaskRangeLength(long maxTaskRangeLen) {
this.maxTaskRangeLen = maxTaskRangeLen;
return this;
}
/**
* Get whether to co-locate metadata on a single node.
* <p>
* Normally Ignite spread ownership of particular keys among all cache nodes. Transaction with keys owned by
* different nodes will produce more network traffic and will require more time to complete comparing to
* transaction with keys owned only by a single node.
* <p>
* IGFS stores information about file system structure (metadata) inside a transactional cache configured through
* {@link #getMetaCacheConfiguration()} property. Metadata updates caused by operations on IGFS usually require
* several internal keys to be updated. As IGFS metadata cache usually operates
* in {@link CacheMode#REPLICATED} mode, meaning that all nodes have all metadata locally, it makes sense to give
* a hint to Ignite to co-locate ownership of all metadata keys on a single node.
* This will decrease amount of network trips required to update metadata and hence could improve performance.
* <p>
* This property should be disabled if you see excessive CPU and network load on a single node, which
* degrades performance and cannot be explained by business logic of your application.
* <p>
* This settings is only used if metadata cache is configured in {@code CacheMode#REPLICATED} mode. Otherwise it
* is ignored.
* <p>
* Defaults to {@link #DFLT_COLOCATE_META}.
*
* @return {@code True} if metadata co-location is enabled.
*/
public boolean isColocateMetadata() {
return colocateMeta;
}
/**
* Set metadata co-location flag.
* <p>
* See {@link #isColocateMetadata()} for more information.
*
* @param colocateMeta Whether metadata co-location is enabled.
* @return {@code this} for chaining.
*/
public FileSystemConfiguration setColocateMetadata(boolean colocateMeta) {
this.colocateMeta = colocateMeta;
return this;
}
/**
* Get relaxed consistency flag.
* <p>
* Concurrent file system operations might conflict with each other. E.g. {@code move("/a1/a2", "/b")} and
* {@code move("/b", "/a1")}. Hence, it is necessary to atomically verify that participating paths are still
* on their places to keep file system in consistent state in such cases. These checks are expensive in
* distributed environment.
* <p>
* Real applications, e.g. Hadoop jobs, rarely produce conflicting operations. So additional checks could be
* skipped in these scenarios without any negative effect on file system integrity. It significantly increases
* performance of file system operations.
* <p>
* If value of this flag is {@code true}, IGFS will skip expensive consistency checks. It is recommended to set
* this flag to {@code false} if your application has conflicting operations, or you do not how exactly users will
* use your system.
* <p>
* This property affects only {@link IgfsMode#PRIMARY} paths.
* <p>
* Defaults to {@link #DFLT_RELAXED_CONSISTENCY}.
*
* @return {@code True} if relaxed consistency is enabled.
*/
public boolean isRelaxedConsistency() {
return relaxedConsistency;
}
/**
* Set relaxed consistency flag.
* <p>
* See {@link #isColocateMetadata()} for more information.
*
* @param relaxedConsistency Whether to use relaxed consistency optimization.
* @return {@code this} for chaining.
*/
public FileSystemConfiguration setRelaxedConsistency(boolean relaxedConsistency) {
this.relaxedConsistency = relaxedConsistency;
return this;
}
/**
* Get whether to update file length on flush.
* <p>
* Controls whether to update file length or not when {@link IgfsOutputStream#flush()} method is invoked. You
* may want to set this property to true in case you want to read from a file which is being written at the
* same time.
* <p>
* Defaults to {@link #DFLT_UPDATE_FILE_LEN_ON_FLUSH}.
*
* @return Whether to update file length on flush.
*/
public boolean isUpdateFileLengthOnFlush() {
return updateFileLenOnFlush;
}
/**
* Set whether to update file length on flush.
* <p>
* Set {@link #isUpdateFileLengthOnFlush()} for more information.
*
* @param updateFileLenOnFlush Whether to update file length on flush.
* @return {@code this} for chaining.
*/
public FileSystemConfiguration setUpdateFileLengthOnFlush(boolean updateFileLenOnFlush) {
this.updateFileLenOnFlush = updateFileLenOnFlush;
return this;
}
/** {@inheritDoc} */
@Override public String toString() {
return S.toString(FileSystemConfiguration.class, this);
}
}