| /* |
| * 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.internal.processors.igfs; |
| |
| import java.util.Arrays; |
| import java.util.Collection; |
| import java.util.HashSet; |
| import org.apache.ignite.IgniteCheckedException; |
| import org.apache.ignite.IgniteException; |
| import org.apache.ignite.IgniteSystemProperties; |
| import org.apache.ignite.binary.BinaryRawReader; |
| import org.apache.ignite.binary.BinaryRawWriter; |
| import org.apache.ignite.cache.CacheMode; |
| import org.apache.ignite.cache.CacheWriteSynchronizationMode; |
| import org.apache.ignite.cluster.ClusterNode; |
| import org.apache.ignite.cluster.ClusterTopologyException; |
| import org.apache.ignite.configuration.CacheConfiguration; |
| import org.apache.ignite.configuration.FileSystemConfiguration; |
| import org.apache.ignite.configuration.IgniteConfiguration; |
| import org.apache.ignite.events.IgfsEvent; |
| import org.apache.ignite.igfs.IgfsException; |
| import org.apache.ignite.igfs.IgfsGroupDataBlocksKeyMapper; |
| import org.apache.ignite.igfs.IgfsIpcEndpointConfiguration; |
| import org.apache.ignite.igfs.IgfsMode; |
| import org.apache.ignite.igfs.IgfsPath; |
| import org.apache.ignite.internal.GridKernalContext; |
| import org.apache.ignite.internal.binary.BinaryUtils; |
| import org.apache.ignite.internal.cluster.ClusterTopologyServerNotFoundException; |
| import org.apache.ignite.internal.managers.eventstorage.GridEventStorageManager; |
| import org.apache.ignite.internal.processors.cache.IgniteInternalCache; |
| import org.apache.ignite.internal.processors.query.QueryUtils; |
| import org.apache.ignite.internal.util.IgniteUtils; |
| import org.apache.ignite.internal.util.future.IgniteFutureImpl; |
| import org.apache.ignite.internal.util.lang.IgniteOutClosureX; |
| import org.apache.ignite.internal.util.typedef.F; |
| import org.apache.ignite.internal.util.typedef.T2; |
| import org.apache.ignite.internal.util.typedef.X; |
| import org.apache.ignite.internal.util.typedef.internal.U; |
| import org.apache.ignite.lang.IgniteUuid; |
| import org.apache.ignite.transactions.Transaction; |
| import org.jetbrains.annotations.Nullable; |
| |
| import java.io.DataInput; |
| import java.io.DataOutput; |
| import java.io.IOException; |
| import java.io.ObjectInput; |
| import java.lang.reflect.Constructor; |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.Comparator; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| import java.util.UUID; |
| import java.util.concurrent.ThreadLocalRandom; |
| |
| import static org.apache.ignite.IgniteSystemProperties.IGNITE_CACHE_RETRIES_COUNT; |
| import static org.apache.ignite.cache.CacheAtomicityMode.TRANSACTIONAL; |
| import static org.apache.ignite.cache.CacheWriteSynchronizationMode.FULL_SYNC; |
| import static org.apache.ignite.igfs.IgfsMode.DUAL_ASYNC; |
| import static org.apache.ignite.igfs.IgfsMode.DUAL_SYNC; |
| import static org.apache.ignite.igfs.IgfsMode.PRIMARY; |
| import static org.apache.ignite.internal.IgniteNodeAttributes.ATTR_IGFS; |
| import static org.apache.ignite.transactions.TransactionConcurrency.PESSIMISTIC; |
| import static org.apache.ignite.transactions.TransactionIsolation.REPEATABLE_READ; |
| |
| /** |
| * Common IGFS utility methods. |
| */ |
| public class IgfsUtils { |
| /** ID for the root directory. */ |
| public static final IgniteUuid ROOT_ID = new IgniteUuid(new UUID(0, 0), 0); |
| |
| /** Lock Id used to lock files being deleted from TRASH. This is a global constant. */ |
| public static final IgniteUuid DELETE_LOCK_ID = new IgniteUuid(new UUID(0, 0), 0); |
| |
| /** Constant trash concurrency level. */ |
| public static final int TRASH_CONCURRENCY = 64; |
| |
| /** File property: user name. */ |
| public static final String PROP_USER_NAME = "usrName"; |
| |
| /** File property: group name. */ |
| public static final String PROP_GROUP_NAME = "grpName"; |
| |
| /** File property: permission. */ |
| public static final String PROP_PERMISSION = "permission"; |
| |
| /** File property: prefer writes to local node. */ |
| public static final String PROP_PREFER_LOCAL_WRITES = "locWrite"; |
| |
| /** Generic property index. */ |
| private static final byte PROP_IDX = 0; |
| |
| /** User name property index. */ |
| private static final byte PROP_USER_NAME_IDX = 1; |
| |
| /** Group name property index. */ |
| private static final byte PROP_GROUP_NAME_IDX = 2; |
| |
| /** Permission property index. */ |
| private static final byte PROP_PERMISSION_IDX = 3; |
| |
| /** Prefer local writes property index. */ |
| private static final byte PROP_PREFER_LOCAL_WRITES_IDX = 4; |
| |
| /** Trash directory IDs. */ |
| private static final IgniteUuid[] TRASH_IDS; |
| |
| /** Maximum number of file unlock transaction retries when topology changes. */ |
| private static final int MAX_CACHE_TX_RETRIES = IgniteSystemProperties.getInteger(IGNITE_CACHE_RETRIES_COUNT, 100); |
| |
| /** Separator between id and name parts in the trash name. */ |
| private static final char TRASH_NAME_SEPARATOR = '|'; |
| |
| /** Flag: this is a directory. */ |
| private static final byte FLAG_DIR = 0x1; |
| |
| /** Flag: this is a file. */ |
| private static final byte FLAG_FILE = 0x2; |
| |
| /** Filesystem cache prefix. */ |
| public static final String IGFS_CACHE_PREFIX = "igfs-internal-"; |
| |
| /** Data cache suffix. */ |
| public static final String DATA_CACHE_SUFFIX = "-data"; |
| |
| /** Meta cache suffix. */ |
| public static final String META_CACHE_SUFFIX = "-meta"; |
| |
| /** Maximum string length to be written at once. */ |
| private static final int MAX_STR_LEN = 0xFFFF / 4; |
| |
| /** Min available TCP port. */ |
| private static final int MIN_TCP_PORT = 1; |
| |
| /** Max available TCP port. */ |
| private static final int MAX_TCP_PORT = 0xFFFF; |
| |
| /* |
| * Static initializer. |
| */ |
| static { |
| TRASH_IDS = new IgniteUuid[TRASH_CONCURRENCY]; |
| |
| for (int i = 0; i < TRASH_CONCURRENCY; i++) |
| TRASH_IDS[i] = new IgniteUuid(new UUID(0, i + 1), 0); |
| } |
| |
| /** |
| * Get random trash ID. |
| * |
| * @return Trash ID. |
| */ |
| public static IgniteUuid randomTrashId() { |
| return TRASH_IDS[ThreadLocalRandom.current().nextInt(TRASH_CONCURRENCY)]; |
| } |
| |
| /** |
| * Get trash ID for the given index. |
| * |
| * @param idx Index. |
| * @return Trahs ID. |
| */ |
| public static IgniteUuid trashId(int idx) { |
| assert idx >= 0 && idx < TRASH_CONCURRENCY; |
| |
| return TRASH_IDS[idx]; |
| } |
| |
| /** |
| * Check whether provided ID is either root ID or trash ID. |
| * |
| * @param id ID. |
| * @return {@code True} if this is root ID or trash ID. |
| */ |
| public static boolean isRootOrTrashId(@Nullable IgniteUuid id) { |
| return isRootId(id) || isTrashId(id); |
| } |
| |
| /** |
| * Check whether provided ID is root ID. |
| * |
| * @param id ID. |
| * @return {@code True} if this is root ID. |
| */ |
| public static boolean isRootId(@Nullable IgniteUuid id) { |
| return id != null && ROOT_ID.equals(id); |
| } |
| |
| /** |
| * Check whether provided ID is trash ID. |
| * |
| * @param id ID. |
| * @return {@code True} if this is trash ID. |
| */ |
| private static boolean isTrashId(IgniteUuid id) { |
| if (id == null) |
| return false; |
| |
| UUID gid = id.globalId(); |
| |
| return id.localId() == 0 && gid.getMostSignificantBits() == 0 && |
| gid.getLeastSignificantBits() > 0 && gid.getLeastSignificantBits() <= TRASH_CONCURRENCY; |
| } |
| |
| /** |
| * Converts any passed exception to IGFS exception. |
| * |
| * @param err Initial exception. |
| * @return Converted IGFS exception. |
| */ |
| @SuppressWarnings("ThrowableResultOfMethodCallIgnored") |
| public static IgfsException toIgfsException(Throwable err) { |
| IgfsException err0 = err instanceof IgfsException ? (IgfsException)err : null; |
| |
| IgfsException igfsErr = X.cause(err, IgfsException.class); |
| |
| while (igfsErr != null && igfsErr != err0) { |
| err0 = igfsErr; |
| |
| igfsErr = X.cause(err, IgfsException.class); |
| } |
| |
| // If initial exception is already IGFS exception and no inner stuff exists, just return it unchanged. |
| if (err0 != err) { |
| if (err0 != null) |
| // Dealing with a kind of IGFS error, wrap it once again, preserving message and root cause. |
| err0 = newIgfsException(err0.getClass(), err0.getMessage(), err0); |
| else { |
| if (err instanceof ClusterTopologyServerNotFoundException) |
| err0 = new IgfsException("Cache server nodes not found.", err); |
| else |
| // Unknown error nature. |
| err0 = new IgfsException("Generic IGFS error occurred.", err); |
| } |
| } |
| |
| return err0; |
| } |
| |
| /** |
| * Construct new IGFS exception passing specified message and cause. |
| * |
| * @param cls Class. |
| * @param msg Message. |
| * @param cause Cause. |
| * @return New IGFS exception. |
| */ |
| public static IgfsException newIgfsException(Class<? extends IgfsException> cls, String msg, Throwable cause) { |
| try { |
| Constructor<? extends IgfsException> ctor = cls.getConstructor(String.class, Throwable.class); |
| |
| return ctor.newInstance(msg, cause); |
| } |
| catch (ReflectiveOperationException e) { |
| throw new IgniteException("Failed to create IGFS exception: " + cls.getName(), e); |
| } |
| } |
| |
| /** |
| * Constructor. |
| */ |
| private IgfsUtils() { |
| // No-op. |
| } |
| |
| /** |
| * Provides non-null user name. |
| * If the user name is null or empty string, defaults to {@link FileSystemConfiguration#DFLT_USER_NAME}, |
| * which is the current process owner user. |
| * @param user a user name to be fixed. |
| * @return non-null interned user name. |
| */ |
| public static String fixUserName(@Nullable String user) { |
| if (F.isEmpty(user)) |
| user = FileSystemConfiguration.DFLT_USER_NAME; |
| |
| return user; |
| } |
| |
| /** |
| * Performs an operation with transaction with retries. |
| * |
| * @param cache Cache to do the transaction on. |
| * @param clo Closure. |
| * @return Result of closure execution. |
| * @throws IgniteCheckedException If failed. |
| */ |
| @SuppressWarnings("ThrowableResultOfMethodCallIgnored") |
| public static <T> T doInTransactionWithRetries(IgniteInternalCache cache, IgniteOutClosureX<T> clo) |
| throws IgniteCheckedException { |
| assert cache != null; |
| |
| int attempts = 0; |
| |
| while (attempts < MAX_CACHE_TX_RETRIES) { |
| try (Transaction tx = cache.txStart(PESSIMISTIC, REPEATABLE_READ)) { |
| T res = clo.applyx(); |
| |
| tx.commit(); |
| |
| return res; |
| } |
| catch (IgniteException | IgniteCheckedException e) { |
| ClusterTopologyException cte = X.cause(e, ClusterTopologyException.class); |
| |
| if (cte != null) |
| ((IgniteFutureImpl)cte.retryReadyFuture()).internalFuture().getUninterruptibly(); |
| else |
| throw U.cast(e); |
| } |
| |
| attempts++; |
| } |
| |
| throw new IgniteCheckedException("Failed to perform operation since max number of attempts " + |
| "exceeded. [maxAttempts=" + MAX_CACHE_TX_RETRIES + ']'); |
| } |
| |
| /** |
| * Sends a series of event. |
| * |
| * @param kernalCtx Kernal context. |
| * @param path The path of the created file. |
| * @param type The type of event to send. |
| */ |
| public static void sendEvents(GridKernalContext kernalCtx, IgfsPath path, int type) { |
| sendEvents(kernalCtx, path, null, type); |
| } |
| |
| /** |
| * Sends a series of event. |
| * |
| * @param kernalCtx Kernal context. |
| * @param path The path of the created file. |
| * @param newPath New path. |
| * @param type The type of event to send. |
| */ |
| public static void sendEvents(GridKernalContext kernalCtx, IgfsPath path, IgfsPath newPath, int type) { |
| assert kernalCtx != null; |
| assert path != null; |
| |
| GridEventStorageManager evts = kernalCtx.event(); |
| |
| ClusterNode locNode = kernalCtx.discovery().localNode(); |
| |
| if (evts.isRecordable(type)) { |
| if (newPath == null) |
| evts.record(new IgfsEvent(path, locNode, type)); |
| else |
| evts.record(new IgfsEvent(path, newPath, locNode, type)); |
| } |
| } |
| |
| /** |
| * @param cacheName Cache name. |
| * @return {@code True} in this is IGFS data or meta cache. |
| */ |
| public static boolean matchIgfsCacheName(@Nullable String cacheName) { |
| return cacheName != null && cacheName.startsWith(IGFS_CACHE_PREFIX); |
| } |
| |
| /** |
| * @param cfg Grid configuration. |
| * @param cacheName Cache name. |
| * @return {@code True} in this is IGFS data or meta cache. |
| */ |
| public static boolean isIgfsCache(IgniteConfiguration cfg, @Nullable String cacheName) { |
| return matchIgfsCacheName(cacheName); |
| } |
| |
| /** |
| * Prepare cache configuration if this is IGFS meta or data cache. |
| * |
| * @param cfg Configuration. |
| * @throws IgniteCheckedException If failed. |
| */ |
| public static void prepareCacheConfigurations(IgniteConfiguration cfg) throws IgniteCheckedException { |
| FileSystemConfiguration[] igfsCfgs = cfg.getFileSystemConfiguration(); |
| List<CacheConfiguration> ccfgs = new ArrayList<>(Arrays.asList(cfg.getCacheConfiguration())); |
| |
| if (igfsCfgs != null) { |
| for (FileSystemConfiguration igfsCfg : igfsCfgs) { |
| if (igfsCfg == null) |
| continue; |
| |
| CacheConfiguration ccfgMeta = igfsCfg.getMetaCacheConfiguration(); |
| |
| if (ccfgMeta == null) { |
| ccfgMeta = defaultMetaCacheConfig(); |
| |
| igfsCfg.setMetaCacheConfiguration(ccfgMeta); |
| } |
| |
| ccfgMeta.setName(IGFS_CACHE_PREFIX + igfsCfg.getName() + META_CACHE_SUFFIX); |
| |
| ccfgs.add(ccfgMeta); |
| |
| CacheConfiguration ccfgData = igfsCfg.getDataCacheConfiguration(); |
| |
| if (ccfgData == null) { |
| ccfgData = defaultDataCacheConfig(); |
| |
| igfsCfg.setDataCacheConfiguration(ccfgData); |
| } |
| |
| ccfgData.setName(IGFS_CACHE_PREFIX + igfsCfg.getName() + DATA_CACHE_SUFFIX); |
| |
| ccfgs.add(ccfgData); |
| |
| |
| // No copy-on-read. |
| ccfgMeta.setCopyOnRead(false); |
| ccfgData.setCopyOnRead(false); |
| |
| // Always full-sync to maintain consistency. |
| ccfgMeta.setWriteSynchronizationMode(CacheWriteSynchronizationMode.FULL_SYNC); |
| ccfgData.setWriteSynchronizationMode(CacheWriteSynchronizationMode.FULL_SYNC); |
| |
| // Set co-located affinity mapper if needed. |
| if (igfsCfg.isColocateMetadata() && ccfgMeta.getAffinityMapper() == null) |
| ccfgMeta.setAffinityMapper(new IgfsColocatedMetadataAffinityKeyMapper()); |
| |
| // Set affinity mapper if needed. |
| if (ccfgData.getAffinityMapper() == null) |
| ccfgData.setAffinityMapper(new IgfsGroupDataBlocksKeyMapper()); |
| } |
| |
| cfg.setCacheConfiguration(ccfgs.toArray(new CacheConfiguration[ccfgs.size()])); |
| } |
| |
| validateLocalIgfsConfigurations(cfg); |
| } |
| |
| /** |
| * Validates local IGFS configurations. Compares attributes only for IGFSes with same name. |
| * |
| * @param igniteCfg Ignite config. |
| * @throws IgniteCheckedException If any of IGFS configurations is invalid. |
| */ |
| private static void validateLocalIgfsConfigurations(IgniteConfiguration igniteCfg) |
| throws IgniteCheckedException { |
| |
| if (igniteCfg.getFileSystemConfiguration() == null || igniteCfg.getFileSystemConfiguration().length == 0) |
| return; |
| |
| Collection<String> cfgNames = new HashSet<>(); |
| |
| for (FileSystemConfiguration cfg : igniteCfg.getFileSystemConfiguration()) { |
| String name = cfg.getName(); |
| |
| if (name == null) |
| throw new IgniteCheckedException("IGFS name cannot be null"); |
| |
| if (cfgNames.contains(name)) |
| throw new IgniteCheckedException("Duplicate IGFS name found (check configuration and " + |
| "assign unique name to each): " + name); |
| |
| CacheConfiguration ccfgData = cfg.getDataCacheConfiguration(); |
| |
| CacheConfiguration ccfgMeta = cfg.getMetaCacheConfiguration(); |
| |
| if (QueryUtils.isEnabled(ccfgData)) |
| throw new IgniteCheckedException("IGFS data cache cannot start with enabled query indexing."); |
| |
| if (QueryUtils.isEnabled(ccfgMeta)) |
| throw new IgniteCheckedException("IGFS metadata cache cannot start with enabled query indexing."); |
| |
| if (ccfgMeta.getAtomicityMode() != TRANSACTIONAL) |
| throw new IgniteCheckedException("IGFS metadata cache should be transactional: " + cfg.getName()); |
| |
| if (!(ccfgData.getAffinityMapper() instanceof IgfsGroupDataBlocksKeyMapper)) |
| throw new IgniteCheckedException( |
| "Invalid IGFS data cache configuration (key affinity mapper class should be " + |
| IgfsGroupDataBlocksKeyMapper.class.getSimpleName() + "): " + cfg); |
| |
| IgfsIpcEndpointConfiguration ipcCfg = cfg.getIpcEndpointConfiguration(); |
| |
| if (ipcCfg != null) { |
| final int tcpPort = ipcCfg.getPort(); |
| |
| if (!(tcpPort >= MIN_TCP_PORT && tcpPort <= MAX_TCP_PORT)) |
| throw new IgniteCheckedException("IGFS endpoint TCP port is out of range [" + MIN_TCP_PORT + |
| ".." + MAX_TCP_PORT + "]: " + tcpPort); |
| |
| if (ipcCfg.getThreadCount() <= 0) |
| throw new IgniteCheckedException("IGFS endpoint thread count must be positive: " + |
| ipcCfg.getThreadCount()); |
| } |
| |
| boolean secondary = cfg.getDefaultMode() == IgfsMode.PROXY; |
| |
| if (cfg.getPathModes() != null) { |
| for (Map.Entry<String, IgfsMode> mode : cfg.getPathModes().entrySet()) { |
| if (mode.getValue() == IgfsMode.PROXY) |
| secondary = true; |
| } |
| } |
| |
| if (secondary && cfg.getSecondaryFileSystem() == null) { |
| // When working in any mode except of primary, secondary FS config must be provided. |
| throw new IgniteCheckedException("Grid configuration parameter invalid: " + |
| "secondaryFileSystem cannot be null when mode is not " + IgfsMode.PRIMARY); |
| } |
| |
| cfgNames.add(name); |
| } |
| } |
| |
| |
| /** |
| * @return Default IGFS cache configuration. |
| */ |
| private static CacheConfiguration defaultCacheConfig() { |
| CacheConfiguration cfg = new CacheConfiguration(); |
| cfg.setAtomicityMode(TRANSACTIONAL); |
| cfg.setWriteSynchronizationMode(FULL_SYNC); |
| cfg.setCacheMode(CacheMode.PARTITIONED); |
| |
| return cfg; |
| } |
| |
| /** |
| * @return Default IGFS meta cache configuration. |
| */ |
| private static CacheConfiguration defaultMetaCacheConfig() { |
| CacheConfiguration cfg = defaultCacheConfig(); |
| |
| cfg.setBackups(1); |
| |
| return cfg; |
| } |
| |
| /** |
| * @return Default IGFS data cache configuration. |
| */ |
| private static CacheConfiguration defaultDataCacheConfig() { |
| return defaultCacheConfig(); |
| } |
| |
| /** |
| * Create empty directory with the given ID. |
| * |
| * @param id ID. |
| * @return File info. |
| */ |
| public static IgfsDirectoryInfo createDirectory(IgniteUuid id) { |
| return createDirectory(id, null, null); |
| } |
| |
| /** |
| * Create directory. |
| * |
| * @param id ID. |
| * @param listing Listing. |
| * @param props Properties. |
| * @return File info. |
| */ |
| public static IgfsDirectoryInfo createDirectory( |
| IgniteUuid id, |
| @Nullable Map<String, IgfsListingEntry> listing, |
| @Nullable Map<String, String> props) { |
| long time = System.currentTimeMillis(); |
| |
| return createDirectory(id, listing, props, time, time); |
| } |
| |
| /** |
| * Create directory. |
| * |
| * @param id ID. |
| * @param listing Listing. |
| * @param props Properties. |
| * @param createTime Create time. |
| * @param modificationTime Modification time. |
| * @return File info. |
| */ |
| public static IgfsDirectoryInfo createDirectory( |
| IgniteUuid id, |
| @Nullable Map<String, IgfsListingEntry> listing, |
| @Nullable Map<String,String> props, |
| long createTime, |
| long modificationTime) { |
| return new IgfsDirectoryInfo(id, listing, props, createTime, modificationTime); |
| } |
| |
| /** |
| * Create file. |
| * |
| * @param id File ID. |
| * @param blockSize Block size. |
| * @param len Length. |
| * @param affKey Affinity key. |
| * @param lockId Lock ID. |
| * @param evictExclude Evict exclude flag. |
| * @param props Properties. |
| * @param accessTime Access time. |
| * @param modificationTime Modification time. |
| * @return File info. |
| */ |
| public static IgfsFileInfo createFile(IgniteUuid id, int blockSize, long len, @Nullable IgniteUuid affKey, |
| @Nullable IgniteUuid lockId, boolean evictExclude, @Nullable Map<String, String> props, long accessTime, |
| long modificationTime) { |
| return new IgfsFileInfo(id, blockSize, len, affKey, props, null, lockId, accessTime, modificationTime, |
| evictExclude); |
| } |
| |
| /** |
| * Write listing entry. |
| * |
| * @param out Writer. |
| * @param entry Entry. |
| */ |
| public static void writeListingEntry(BinaryRawWriter out, @Nullable IgfsListingEntry entry) { |
| if (entry != null) { |
| out.writeBoolean(true); |
| |
| BinaryUtils.writeIgniteUuid(out, entry.fileId()); |
| |
| out.writeBoolean(entry.isDirectory()); |
| } |
| else |
| out.writeBoolean(false); |
| } |
| |
| /** |
| * Read listing entry. |
| * |
| * @param in Reader. |
| * @return Entry. |
| */ |
| @Nullable public static IgfsListingEntry readListingEntry(BinaryRawReader in) { |
| if (in.readBoolean()) { |
| IgniteUuid id = BinaryUtils.readIgniteUuid(in); |
| boolean dir = in.readBoolean(); |
| |
| return new IgfsListingEntry(id, dir); |
| } |
| else |
| return null; |
| } |
| |
| /** |
| * Write listing entry. |
| * |
| * @param out Writer. |
| * @param entry Entry. |
| * @throws IOException If failed. |
| */ |
| public static void writeListingEntry(DataOutput out, @Nullable IgfsListingEntry entry) throws IOException { |
| if (entry != null) { |
| out.writeBoolean(true); |
| |
| IgniteUtils.writeGridUuid(out, entry.fileId()); |
| |
| out.writeBoolean(entry.isDirectory()); |
| } |
| else |
| out.writeBoolean(false); |
| } |
| |
| /** |
| * Read listing entry. |
| * |
| * @param in Reader. |
| * @return Entry. |
| * @throws IOException If failed. |
| */ |
| @Nullable public static IgfsListingEntry readListingEntry(DataInput in) throws IOException { |
| if (in.readBoolean()) { |
| IgniteUuid id = IgniteUtils.readGridUuid(in); |
| boolean dir = in.readBoolean(); |
| |
| return new IgfsListingEntry(id, dir); |
| } |
| else |
| return null; |
| } |
| |
| /** |
| * Write entry properties. Rely on reference equality for well-known properties. |
| * |
| * @param out Writer. |
| * @param props Properties. |
| */ |
| @SuppressWarnings("StringEquality") |
| public static void writeProperties(BinaryRawWriter out, @Nullable Map<String, String> props) { |
| if (props != null) { |
| out.writeInt(props.size()); |
| |
| for (Map.Entry<String, String> entry : props.entrySet()) { |
| String key = entry.getKey(); |
| |
| if (key == PROP_PERMISSION) |
| out.writeByte(PROP_PERMISSION_IDX); |
| else if (key == PROP_PREFER_LOCAL_WRITES) |
| out.writeByte(PROP_PREFER_LOCAL_WRITES_IDX); |
| else if (key == PROP_USER_NAME) |
| out.writeByte(PROP_USER_NAME_IDX); |
| else if (key == PROP_GROUP_NAME) |
| out.writeByte(PROP_GROUP_NAME_IDX); |
| else { |
| out.writeByte(PROP_IDX); |
| out.writeString(key); |
| } |
| |
| out.writeString(entry.getValue()); |
| } |
| } |
| else |
| out.writeInt(-1); |
| } |
| |
| /** |
| * Read entry properties. |
| * |
| * @param in Reader. |
| * @return Properties. |
| */ |
| @Nullable public static Map<String, String> readProperties(BinaryRawReader in) { |
| int size = in.readInt(); |
| |
| if (size >= 0) { |
| Map<String, String> props = new HashMap<>(size); |
| |
| for (int i = 0; i < size; i++) { |
| byte idx = in.readByte(); |
| |
| String key; |
| |
| switch (idx) { |
| case PROP_PERMISSION_IDX: |
| key = PROP_PERMISSION; |
| |
| break; |
| |
| case PROP_PREFER_LOCAL_WRITES_IDX: |
| key = PROP_PREFER_LOCAL_WRITES; |
| |
| break; |
| |
| case PROP_USER_NAME_IDX: |
| key = PROP_USER_NAME; |
| |
| break; |
| |
| case PROP_GROUP_NAME_IDX: |
| key = PROP_GROUP_NAME; |
| |
| break; |
| |
| default: |
| key = in.readString(); |
| } |
| |
| props.put(key, in.readString()); |
| } |
| |
| return props; |
| } |
| else |
| return null; |
| } |
| |
| /** |
| * Write entry properties. Rely on reference equality for well-known properties. |
| * |
| * @param out Writer. |
| * @param props Properties. |
| * @throws IOException If failed. |
| */ |
| @SuppressWarnings("StringEquality") |
| public static void writeProperties(DataOutput out, @Nullable Map<String, String> props) throws IOException { |
| if (props != null) { |
| out.writeInt(props.size()); |
| |
| for (Map.Entry<String, String> entry : props.entrySet()) { |
| String key = entry.getKey(); |
| |
| if (key == PROP_PERMISSION) |
| out.writeByte(PROP_PERMISSION_IDX); |
| else if (key == PROP_PREFER_LOCAL_WRITES) |
| out.writeByte(PROP_PREFER_LOCAL_WRITES_IDX); |
| else if (key == PROP_USER_NAME) |
| out.writeByte(PROP_USER_NAME_IDX); |
| else if (key == PROP_GROUP_NAME) |
| out.writeByte(PROP_GROUP_NAME_IDX); |
| else { |
| out.writeByte(PROP_IDX); |
| U.writeString(out, key); |
| } |
| |
| U.writeString(out, entry.getValue()); |
| } |
| } |
| else |
| out.writeInt(-1); |
| } |
| |
| /** |
| * Read entry properties. |
| * |
| * @param in Reader. |
| * @return Properties. |
| * @throws IOException If failed. |
| */ |
| @Nullable public static Map<String, String> readProperties(DataInput in) throws IOException { |
| int size = in.readInt(); |
| |
| if (size >= 0) { |
| Map<String, String> props = new HashMap<>(size); |
| |
| for (int i = 0; i < size; i++) { |
| byte idx = in.readByte(); |
| |
| String key; |
| |
| switch (idx) { |
| case PROP_PERMISSION_IDX: |
| key = PROP_PERMISSION; |
| |
| break; |
| |
| case PROP_PREFER_LOCAL_WRITES_IDX: |
| key = PROP_PREFER_LOCAL_WRITES; |
| |
| break; |
| |
| case PROP_USER_NAME_IDX: |
| key = PROP_USER_NAME; |
| |
| break; |
| |
| case PROP_GROUP_NAME_IDX: |
| key = PROP_GROUP_NAME; |
| |
| break; |
| |
| default: |
| key = U.readString(in); |
| } |
| |
| props.put(key, U.readString(in)); |
| } |
| |
| return props; |
| } |
| else |
| return null; |
| } |
| |
| /** |
| * Write IGFS path. |
| * |
| * @param writer Writer. |
| * @param path Path. |
| */ |
| public static void writePath(BinaryRawWriter writer, @Nullable IgfsPath path) { |
| if (path != null) { |
| writer.writeBoolean(true); |
| |
| path.writeRawBinary(writer); |
| } |
| else |
| writer.writeBoolean(false); |
| } |
| |
| /** |
| * Read IGFS path. |
| * |
| * @param reader Reader. |
| * @return Path. |
| */ |
| @Nullable public static IgfsPath readPath(BinaryRawReader reader) { |
| if (reader.readBoolean()) { |
| IgfsPath path = new IgfsPath(); |
| |
| path.readRawBinary(reader); |
| |
| return path; |
| } |
| else |
| return null; |
| } |
| |
| /** |
| * Read non-null path from the input. |
| * |
| * @param in Input. |
| * @return IGFS path. |
| * @throws IOException If failed. |
| */ |
| public static IgfsPath readPath(ObjectInput in) throws IOException { |
| IgfsPath res = new IgfsPath(); |
| |
| res.readExternal(in); |
| |
| return res; |
| } |
| |
| /** |
| * Write IgfsFileAffinityRange. |
| * |
| * @param writer Writer |
| * @param affRange affinity range. |
| */ |
| public static void writeFileAffinityRange(BinaryRawWriter writer, @Nullable IgfsFileAffinityRange affRange) { |
| if (affRange != null) { |
| writer.writeBoolean(true); |
| |
| affRange.writeRawBinary(writer); |
| } |
| else |
| writer.writeBoolean(false); |
| } |
| |
| /** |
| * Read IgfsFileAffinityRange. |
| * |
| * @param reader Reader. |
| * @return File affinity range. |
| */ |
| public static IgfsFileAffinityRange readFileAffinityRange(BinaryRawReader reader) { |
| if (reader.readBoolean()) { |
| IgfsFileAffinityRange affRange = new IgfsFileAffinityRange(); |
| |
| affRange.readRawBinary(reader); |
| |
| return affRange; |
| } |
| else |
| return null; |
| } |
| |
| /** |
| * Parses the TRASH file name to extract the original path. |
| * |
| * @param name The TRASH short (entry) name. |
| * @return The original path, or null in case of failure. |
| */ |
| public static IgfsPath extractOriginalPathFromTrash(String name) { |
| int idx = name.indexOf(TRASH_NAME_SEPARATOR); |
| |
| assert idx >= 0; |
| |
| String path = name.substring(idx + 1, name.length()); |
| |
| return new IgfsPath(path); |
| } |
| |
| /** |
| * Creates short name of the file in TRASH directory. |
| * The name consists of the whole file path and its unique id. |
| * Upon file cleanup this name will be parsed to extract the path. |
| * Note that in contrast to common practice the composed name contains '/' character. |
| * |
| * @param path The full path of the deleted file. |
| * @param id The file id. |
| * @return The new short name for trash directory. |
| */ |
| static String composeNameForTrash(IgfsPath path, IgniteUuid id) { |
| return id.toString() + TRASH_NAME_SEPARATOR + path.toString(); |
| } |
| |
| /** |
| * Check whether provided node contains IGFS with the given name. |
| * |
| * @param node Node. |
| * @param igfsName IGFS name. |
| * @return {@code True} if it contains IGFS. |
| */ |
| public static boolean isIgfsNode(ClusterNode node, String igfsName) { |
| assert node != null; |
| |
| IgfsAttributes[] igfs = node.attribute(ATTR_IGFS); |
| |
| if (igfs != null) |
| for (IgfsAttributes attrs : igfs) |
| if (F.eq(igfsName, attrs.igfsName())) |
| return true; |
| |
| return false; |
| } |
| |
| /** |
| * Check whether mode is dual. |
| * |
| * @param mode Mode. |
| * @return {@code True} if dual. |
| */ |
| public static boolean isDualMode(IgfsMode mode) { |
| return mode == DUAL_SYNC || mode == DUAL_ASYNC; |
| } |
| |
| /** |
| * Answers if directory of this mode can contain a subdirectory of the given mode. |
| * |
| * @param parent Parent mode. |
| * @param child Child mode. |
| * @return {@code true} if directory of this mode can contain a directory of the given mode. |
| */ |
| public static boolean canContain(IgfsMode parent, IgfsMode child) { |
| return isDualMode(parent) || parent == child; |
| } |
| |
| /** |
| * Checks, filters and sorts the modes. |
| * |
| * @param dfltMode The root mode. Must always be not null. |
| * @param modes The subdirectory modes. |
| * @param dualParentsContainingPrimaryChildren The set to store parents into. |
| * @return Descending list of filtered and checked modes. |
| * @throws IgniteCheckedException On error. |
| */ |
| public static ArrayList<T2<IgfsPath, IgfsMode>> preparePathModes(final IgfsMode dfltMode, |
| @Nullable List<T2<IgfsPath, IgfsMode>> modes, Set<IgfsPath> dualParentsContainingPrimaryChildren) |
| throws IgniteCheckedException { |
| if (modes == null) |
| return null; |
| |
| // Sort by depth, shallow first. |
| Collections.sort(modes, new Comparator<Map.Entry<IgfsPath, IgfsMode>>() { |
| @Override public int compare(Map.Entry<IgfsPath, IgfsMode> o1, Map.Entry<IgfsPath, IgfsMode> o2) { |
| return o1.getKey().depth() - o2.getKey().depth(); |
| } |
| }); |
| |
| ArrayList<T2<IgfsPath, IgfsMode>> resModes = new ArrayList<>(modes.size() + 1); |
| |
| resModes.add(new T2<>(IgfsPath.ROOT, dfltMode)); |
| |
| for (T2<IgfsPath, IgfsMode> mode : modes) { |
| assert mode.getKey() != null; |
| |
| for (T2<IgfsPath, IgfsMode> resMode : resModes) { |
| if (mode.getKey().isSubDirectoryOf(resMode.getKey())) { |
| assert resMode.getValue() != null; |
| |
| if (resMode.getValue() == mode.getValue()) |
| // No reason to add a sub-path of the same mode, ignore this pair. |
| break; |
| |
| if (!canContain(resMode.getValue(), mode.getValue())) |
| throw new IgniteCheckedException("Subdirectory " + mode.getKey() + " mode " |
| + mode.getValue() + " is not compatible with upper level " |
| + resMode.getKey() + " directory mode " + resMode.getValue() + "."); |
| |
| // Add to the 1st position (deep first). |
| resModes.add(0, mode); |
| |
| // Store primary paths inside dual paths in separate collection: |
| if (mode.getValue() == PRIMARY) |
| dualParentsContainingPrimaryChildren.add(mode.getKey().parent()); |
| |
| break; |
| } |
| } |
| } |
| |
| // Remove root, because this class contract is that root mode is not contained in the list. |
| resModes.remove(resModes.size() - 1); |
| |
| return resModes; |
| } |
| |
| /** |
| * Create flags value. |
| * |
| * @param isDir Directory flag. |
| * @param isFile File flag. |
| * @return Result. |
| */ |
| public static byte flags(boolean isDir, boolean isFile) { |
| byte res = isDir ? FLAG_DIR : 0; |
| |
| if (isFile) |
| res |= FLAG_FILE; |
| |
| return res; |
| } |
| |
| /** |
| * Check whether passed flags represent directory. |
| * |
| * @param flags Flags. |
| * @return {@code True} if this is directory. |
| */ |
| public static boolean isDirectory(byte flags) { |
| return hasFlag(flags, FLAG_DIR); |
| } |
| |
| /** |
| * Check whether passed flags represent file. |
| * |
| * @param flags Flags. |
| * @return {@code True} if this is file. |
| */ |
| public static boolean isFile(byte flags) { |
| return hasFlag(flags, FLAG_FILE); |
| } |
| |
| /** |
| * Check whether certain flag is set. |
| * |
| * @param flags Flags. |
| * @param flag Flag to check. |
| * @return {@code True} if flag is set. |
| */ |
| private static boolean hasFlag(byte flags, byte flag) { |
| return (flags & flag) == flag; |
| } |
| |
| /** |
| * Reads string-to-string map written by {@link #writeStringMap(DataOutput, Map)}. |
| * |
| * @param in Data input. |
| * @throws IOException If write failed. |
| * @return Read result. |
| */ |
| public static Map<String, String> readStringMap(DataInput in) throws IOException { |
| int size = in.readInt(); |
| |
| if (size == -1) |
| return null; |
| else { |
| Map<String, String> map = U.newHashMap(size); |
| |
| for (int i = 0; i < size; i++) |
| map.put(readUTF(in), readUTF(in)); |
| |
| return map; |
| } |
| } |
| |
| /** |
| * Writes string-to-string map to given data output. |
| * |
| * @param out Data output. |
| * @param map Map. |
| * @throws IOException If write failed. |
| */ |
| public static void writeStringMap(DataOutput out, @Nullable Map<String, String> map) throws IOException { |
| if (map != null) { |
| out.writeInt(map.size()); |
| |
| for (Map.Entry<String, String> e : map.entrySet()) { |
| writeUTF(out, e.getKey()); |
| writeUTF(out, e.getValue()); |
| } |
| } |
| else |
| out.writeInt(-1); |
| } |
| |
| /** |
| * Write UTF string which can be {@code null}. |
| * |
| * @param out Output stream. |
| * @param val Value. |
| * @throws IOException If failed. |
| */ |
| public static void writeUTF(DataOutput out, @Nullable String val) throws IOException { |
| if (val == null) |
| out.writeInt(-1); |
| else { |
| out.writeInt(val.length()); |
| |
| if (val.length() <= MAX_STR_LEN) |
| out.writeUTF(val); // Optimized write in 1 chunk. |
| else { |
| int written = 0; |
| |
| while (written < val.length()) { |
| int partLen = Math.min(val.length() - written, MAX_STR_LEN); |
| |
| String part = val.substring(written, written + partLen); |
| |
| out.writeUTF(part); |
| |
| written += partLen; |
| } |
| } |
| } |
| } |
| |
| /** |
| * Read UTF string which can be {@code null}. |
| * |
| * @param in Input stream. |
| * @return Value. |
| * @throws IOException If failed. |
| */ |
| public static String readUTF(DataInput in) throws IOException { |
| int len = in.readInt(); // May be zero. |
| |
| if (len < 0) |
| return null; |
| else { |
| if (len <= MAX_STR_LEN) |
| return in.readUTF(); |
| |
| StringBuilder sb = new StringBuilder(len); |
| |
| do { |
| sb.append(in.readUTF()); |
| } |
| while (sb.length() < len); |
| |
| assert sb.length() == len; |
| |
| return sb.toString(); |
| } |
| } |
| } |
