@Override public Mount getMountByName(String name) { return DEFAULT_MOUNT.getName().equals(name) ? DEFAULT_MOUNT : null; }
@Override public Mount getMountByName(String name) { return DEFAULT_MOUNT.getName().equals(name) ? DEFAULT_MOUNT : null; }
private static Map<String, Mount> getMounts(List<Mount> mountInfos) { Map<String, Mount> mounts = Maps.newHashMap(); for (Mount mi : mountInfos) { mounts.put(mi.getName(), mi); } return ImmutableMap.copyOf(mounts); }
private static Map<String, Mount> getMounts(List<Mount> mountInfos) { Map<String, Mount> mounts = Maps.newHashMap(); for (Mount mi : mountInfos) { mounts.put(mi.getName(), mi); } return ImmutableMap.copyOf(mounts); }
@Override public String toString() { StringBuilder result = new StringBuilder(super.toString()); result.append('['); if (mount.isDefault()) { result.append("default"); } else { result.append(mount.getName()); } result.append(']'); return result.toString(); } }
public void track(MountedNodeStore mountedNodeStore) { mountedNodeStoresByName.put(mountedNodeStore.getMount().getName(), mountedNodeStore); }
public void report(MountedNodeStore firstNS, String firstPath, MountedNodeStore secondNS, String secondPath, String value, String error) { errors.add(String.format("For NodeStore mount %s, path %s, and NodeStore mount %s, path %s, encountered the following clash for value %s: '%s'", firstNS.getMount().getName(), firstPath, secondNS.getMount().getName(), secondPath, value, error)); if ( errors.size() == FAIL_IMMEDIATELY_THRESHOLD ) { end(); } }
public void report(MountedNodeStore mountedStore, String path, String error) { errors.add(String.format("For NodeStore mount %s, path %s, encountered the following problem: '%s'", mountedStore.getMount().getName(), path, error)); if ( errors.size() == FAIL_IMMEDIATELY_THRESHOLD ) { end(); } }
public T get(MountedNodeStore nodeStore) { if (!suppliers.containsKey(nodeStore)) { Mount mount = nodeStore.getMount(); String mountName = mount.isDefault() ? "[default]" : mount.getName(); throw new IllegalStateException("Node is not available for the node store " + mountName); } return suppliers.get(nodeStore).get(); }
static Set<String> getSupportedPaths(@NotNull ConfigurationParameters params, @NotNull MountInfoProvider mountInfoProvider) { Set<String> supportedPaths = params.getConfigValue(CugConstants.PARAM_CUG_SUPPORTED_PATHS, ImmutableSet.of()); if (!supportedPaths.isEmpty() && mountInfoProvider.hasNonDefaultMounts()) { for (Mount mount : mountInfoProvider.getNonDefaultMounts()) { for (String path : supportedPaths) { if (mount.isUnder(path)) { log.error("Configured supported CUG path '{}' includes node store mount '{}'.", path, mount.getName()); throw new IllegalStateException(); } else if (mount.isMounted(path)) { log.error("Configured supported CUG path '{}' is part of node store mount '{}'.", path, mount.getName()); throw new IllegalStateException(); } } } } return supportedPaths; }
static Set<String> getSupportedPaths(@NotNull ConfigurationParameters params, @NotNull MountInfoProvider mountInfoProvider) { Set<String> supportedPaths = params.getConfigValue(CugConstants.PARAM_CUG_SUPPORTED_PATHS, ImmutableSet.of()); if (!supportedPaths.isEmpty() && mountInfoProvider.hasNonDefaultMounts()) { for (Mount mount : mountInfoProvider.getNonDefaultMounts()) { for (String path : supportedPaths) { if (mount.isUnder(path)) { log.error("Configured supported CUG path '{}' includes node store mount '{}'.", path, mount.getName()); throw new IllegalStateException(); } else if (mount.isMounted(path)) { log.error("Configured supported CUG path '{}' is part of node store mount '{}'.", path, mount.getName()); throw new IllegalStateException(); } } } } return supportedPaths; }
CompositeNodeState createRootNodeState(Map<MountedNodeStore, NodeState> rootStates) { for (Map.Entry<MountedNodeStore, NodeState> e : rootStates.entrySet()) { MountedNodeStore mns = e.getKey(); NodeState nodeState = e.getValue(); if (nodeState instanceof CompositeNodeState) { throw new IllegalArgumentException("Nesting composite node states is not supported"); } if (nodeState == null) { throw new NullPointerException("Passed null as a nodestate for " + mns.getMount().getName()); } } for (MountedNodeStore mns : nonDefaultStores) { if (!rootStates.containsKey(mns)) { throw new IllegalArgumentException("Can't find node state for " + mns.getMount().getName()); } } if (!rootStates.containsKey(globalStore)) { throw new IllegalArgumentException("Can't find node state for the global store"); } if (rootStates.size() != nonDefaultStores.size() + 1) { throw new IllegalArgumentException("Too many root states passed: " + rootStates.size()); } return new CompositeNodeState("/", NodeMap.create(rootStates), this); }
@Override public void check(NodeStore globalStore, MountedNodeStore mountedStore) { ErrorHolder errorHolder = new ErrorHolder(); checkers.forEach( c -> { log.info("Checking NodeStore from mount {} with {}", mountedStore.getMount().getName(), c ); check(mountedStore, errorHolder, globalStore, c); log.info("Check complete"); }); errorHolder.end(); }
private String getPartialCheckpointName(MountedNodeStore nodeStore, String globalCheckpoint, Map<String, String> globalCheckpointProperties, boolean resolveByName) { Set<String> validCheckpointNames = ImmutableSet.copyOf(nodeStore.getNodeStore().checkpoints()); String result = globalCheckpointProperties.get(CHECKPOINT_METADATA_MOUNT + nodeStore.getMount().getName()); if (result != null && validCheckpointNames.contains(result)) { return result; } if (globalCheckpoint != null && validCheckpointNames.contains(globalCheckpoint)) { return globalCheckpoint; } if (resolveByName) { String nameProp = globalCheckpointProperties.get("name"); if (nameProp == null) { return null; } for (String c : validCheckpointNames) { Map<String, String> partialCheckpointProperties = nodeStore.getNodeStore().checkpointInfo(c); if (nameProp.equals(partialCheckpointProperties.get("name"))) { return c; } } } return null; }
private void assertNoChange(MountedNodeStore mountedNodeStore, NodeBuilder partialBuilder) throws CommitFailedException { NodeState baseState = partialBuilder.getBaseState(); NodeState nodeState = partialBuilder.getNodeState(); if (!nodeState.equals(baseState)) { Set<String> changedPaths = getModifiedPaths(baseState, nodeState); if (!changedPaths.isEmpty()) { throw new CommitFailedException("CompositeStore", 31, "Unable to perform changes on read-only mount " + mountedNodeStore.getMount().getName() + ". Failing paths: " + changedPaths.toString()); } } }
private void check(Entry<Mount, NodeState> indexEntry, Entry<Mount, NodeState> indexEntry2, Context ctx, ErrorHolder errorHolder) { String indexName = rootIndexDef.getName(); // optimisation: sort strategies to ensuer that we query all the entries from the mount and check them // against the default. this way we'll run a significantly smaller number of checks. The assumption is // that the non-default mount will always hold a larger number of entries TreeSet<StrategyWrapper> wrappers = new TreeSet<>(); wrappers.add(getWrapper(indexEntry, indexName, ctx)); wrappers.add(getWrapper(indexEntry2, indexName, ctx)); StrategyWrapper wrapper = wrappers.first(); StrategyWrapper wrapper2 = wrappers.last(); LOG.info("Checking index definitions for {} between mounts {} and {}", indexName, wrapper.mount.getName(), wrapper2.mount.getName()); for ( IndexEntry hit : wrapper.queryAll() ) { Optional<IndexEntry> result = wrapper2.queryOne(hit.getPropertyValue()); if ( result.isPresent() ) { IndexEntry hit2 = result.get(); if ( reportedConflictingValues.add(hit.getPropertyValue())) { errorHolder.report(wrapper.nodeStore, hit.getPath(), wrapper2.nodeStore, hit2.getPath(), hit.getPropertyValue(), "duplicate unique index entry"); } } } }
private boolean isExcluded(MountedNodeStore mountedStore, Tree tree, Context context) { for ( String excludedNodeType : excludedNodeTypes ) { if ( context.getTypeManager().isNodeType(tree, excludedNodeType ) ) { log.warn("Not failing check for tree at path {}, mount {} due to matching excluded node type {}", tree.getPath(), mountedStore.getMount().getName(), excludedNodeType); return true; } } return false; }
private StrategyWrapper getWrapper(Entry<Mount, NodeState> indexEntry, String indexName, Context ctx) { NodeState indexNode = indexEntry.getValue(); Mount mount = indexEntry.getKey(); MountedNodeStore mountedNodeStore = ctx.mountedNodeStoresByName.get(mount.getName()); UniqueEntryStoreStrategy strategy = mount.isDefault() ? new UniqueEntryStoreStrategy() : new UniqueEntryStoreStrategy(Multiplexers.getNodeForMount(mount, INDEX_CONTENT_NODE_NAME)); return new StrategyWrapper(strategy, indexNode.getChildNode(indexName), indexName, mountedNodeStore); } }
@Test public void basicMounting() throws Exception { MountInfoProvider mip = Mounts.newBuilder() .mount("foo", "/a", "/b") .mount("bar", "/x", "/y") .build(); assertEquals("foo", mip.getMountByPath("/a").getName()); assertEquals("foo", mip.getMountByPath("/a/x").getName()); assertEquals("bar", mip.getMountByPath("/x").getName()); assertTrue(mip.getMountByPath("/z").isDefault()); assertTrue(mip.hasNonDefaultMounts()); }