Examples with Group org.commonjava.indy.model.core.Group used on opensource projects

Example 26 with Group

use of org.commonjava.indy.model.core.Group in project indy by Commonjava.

the class MeasuringStoreQuery method getGroupsAffectedBy.

@Override
public Set<Group> getGroupsAffectedBy(final Collection<StoreKey> keys) throws IndyDataException {
    AtomicReference<IndyDataException> errorRef = new AtomicReference<>();
    Set<Group> result = metricsManager.wrapWithStandardMetrics(() -> {
        try {
            return query.getGroupsAffectedBy(keys);
        } catch (IndyDataException e) {
            errorRef.set(e);
        }
        return null;
    }, () -> "getGroupsAffectedBy-collection");
    IndyDataException error = errorRef.get();
    if (error != null) {
        throw error;
    }
    return result;
}

Example 27 with Group

use of org.commonjava.indy.model.core.Group in project indy by Commonjava.

the class MeasuringStoreQuery method getGroupsContaining.

@Override
public Set<Group> getGroupsContaining(final StoreKey storeKey) throws IndyDataException {
    AtomicReference<IndyDataException> errorRef = new AtomicReference<>();
    Set<Group> result = metricsManager.wrapWithStandardMetrics(() -> {
        try {
            return query.getGroupsContaining(storeKey);
        } catch (IndyDataException e) {
            errorRef.set(e);
        }
        return null;
    }, () -> "getGroupsContaining");
    IndyDataException error = errorRef.get();
    if (error != null) {
        throw error;
    }
    return result;
}

Example 28 with Group

use of org.commonjava.indy.model.core.Group in project indy by Commonjava.

the class InfinispanStoreDataManager method affectedBy.

@Override
public Set<Group> affectedBy(final Collection<StoreKey> keys) {
    logger.debug("Calculate affectedBy for keys: {}", keys);
    checkAffectedByCacheHealth();
    final Set<Group> result = new HashSet<>();
    // use these to avoid recursion
    final Set<StoreKey> processed = new HashSet<>();
    final LinkedList<StoreKey> toProcess = new LinkedList<>(keys);
    while (!toProcess.isEmpty()) {
        StoreKey key = toProcess.removeFirst();
        if (key == null) {
            continue;
        }
        if (processed.add(key)) {
            Set<StoreKey> affected = affectedByStores.get(key);
            if (affected != null) {
                logger.debug("Get affectedByStores, key: {}, affected: {}", key, affected);
                affected = affected.stream().filter(k -> k.getType() == group).collect(Collectors.toSet());
                for (StoreKey gKey : affected) {
                    // avoid loading the ArtifactStore instance again and again
                    if (!processed.contains(gKey) && !toProcess.contains(gKey)) {
                        ArtifactStore store = getArtifactStoreInternal(gKey);
                        // if this group is disabled, we don't want to keep loading it again and again.
                        if (store.isDisabled()) {
                            processed.add(gKey);
                        } else {
                            // add the group to the toProcess list so we can find any result that might include it in their own membership
                            toProcess.addLast(gKey);
                            result.add((Group) store);
                        }
                    }
                }
            }
        }
    }
    if (logger.isTraceEnabled()) {
        logger.trace("Groups affected by {} are: {}", keys, result.stream().map(ArtifactStore::getKey).collect(Collectors.toSet()));
    }
    return filterAffectedGroups(result);
}

Example 29 with Group

use of org.commonjava.indy.model.core.Group in project indy by Commonjava.

the class ConcurrencyTest method deadlockOnGroupContains.

@BMRules(rules = { @BMRule(name = "init rendezvous", targetClass = "MemoryStoreDataManager", targetMethod = "<init>", targetLocation = "ENTRY", action = "createRendezvous($0, 2, true)"), @BMRule(name = "getGroupsContaining call", targetClass = "MemoryStoreDataManager", targetMethod = "getGroupsContaining", targetLocation = "ENTRY", action = "rendezvous($0); debug(Thread.currentThread().getName() + \": thread proceeding.\")") })
@Test
public void deadlockOnGroupContains() throws IndyDataException, InterruptedException, ExecutionException {
    ExecutorService executor = Executors.newFixedThreadPool(2);
    ExecutorCompletionService<String> completionService = new ExecutorCompletionService<>(executor);
    AtomicInteger count = new AtomicInteger(0);
    RemoteRepository repo = new RemoteRepository(MAVEN_PKG_KEY, "central", "http://repo.maven.apache.org/maven2");
    TestUpdatingEventDispatcher dispatcher = new TestUpdatingEventDispatcher(repo, completionService, count);
    MemoryStoreDataManager dataManager = new MemoryStoreDataManager(dispatcher);
    dispatcher.setDataManager(dataManager);
    ChangeSummary summary = new ChangeSummary(ChangeSummary.SYSTEM_USER, "Test init");
    dataManager.storeArtifactStore(repo, summary, false, false, new EventMetadata());
    for (int i = 0; i < 2; i++) {
        Group group = new Group(MAVEN_PKG_KEY, "group" + i);
        if (i % 2 == 0) {
            group.addConstituent(repo);
        }
        dataManager.storeArtifactStore(group, summary, false, false, new EventMetadata());
    }
    for (int i = 0; i < count.get(); i++) {
        Future<String> future = completionService.take();
        assertThat(future.get(), nullValue());
    }
}

Example 30 with Group

use of org.commonjava.indy.model.core.Group in project indy by Commonjava.

the class IndexingContentManagerDecorator method retrieve.

@Override
public Transfer retrieve(final ArtifactStore store, final String path, final EventMetadata eventMetadata) throws IndyWorkflowException {
    if (!indexCfg.isEnabled()) {
        return delegate.retrieve(store, path, eventMetadata);
    }
    if (store == null) {
        return null;
    }
    logger.trace("Looking for indexed path: {} in: {}", path, store.getKey());
    Transfer transfer = getIndexedTransfer(store.getKey(), null, path, TransferOperation.DOWNLOAD, eventMetadata);
    if (transfer != null) {
        logger.debug("Found indexed transfer: {}. Returning.", transfer);
        return transfer;
    } else if (isAuthoritativelyMissing(store)) {
        logger.debug("Not found indexed transfer: {} and authoritative index switched on. Considering not found and return null.", transfer);
        return null;
    }
    StoreType type = store.getKey().getType();
    if (StoreType.group == type) {
        ConcreteResource resource = new ConcreteResource(LocationUtils.toLocation(store), path);
        if (nfc.isMissing(resource)) {
            logger.debug("{} is marked as missing. Returning null.", resource);
            return null;
        }
        logger.debug("No group index hits. Devolving to member store indexes.");
        KeyedLocation location = LocationUtils.toLocation(store);
        SpecialPathInfo specialPathInfo = specialPathManager.getSpecialPathInfo(location, path, store.getPackageType());
        if (specialPathInfo == null || !specialPathInfo.isMergable()) {
            if (PathMaskChecker.checkMask(store, path)) {
                transfer = getTransferFromConstituents(((Group) store).getConstituents(), resource, path, store, memberKey -> {
                    try {
                        ArtifactStore member = storeDataManager.getArtifactStore(memberKey);
                        if (member == null) {
                            logger.trace("Cannot find store for key: {}", memberKey);
                        } else {
                            return retrieve(member, path, eventMetadata);
                        }
                    } catch (IndyDataException e) {
                        logger.error(String.format("Failed to lookup store: %s (in membership of: %s). Reason: %s", memberKey, store.getKey(), e.getMessage()), e);
                    }
                    return null;
                });
                nfcForGroup(store, transfer, resource);
                return transfer;
            } else {
                return null;
            }
        } else {
            logger.debug("Merged content. Delegating to main content manager for: {} in: {}", path, store);
            transfer = delegate.retrieve(store, path, eventMetadata);
            if (!exists(transfer)) {
                Boolean metadataGenerated = (Boolean) eventMetadata.get(GROUP_METADATA_GENERATED);
                Boolean metadataExists = (Boolean) eventMetadata.get(GROUP_METADATA_EXISTS);
                if (Boolean.TRUE.equals(metadataGenerated) || Boolean.TRUE.equals(metadataExists)) {
                    // metadata generated/exists but missing due to membership change, not add to nfc so next req can retry
                    ;
                } else // don't track NFC for hosted repos
                {
                    nfc.addMissing(resource);
                }
            }
            return transfer;
        }
    }
    logger.trace("Delegating retrieve call for concrete repository: {}/{}", store, path);
    transfer = delegate.retrieve(store, path, eventMetadata);
    if (exists(transfer) && indexCfg.isEnabled()) {
        logger.debug("Got transfer from delegate: {} (will index)", transfer);
        indexManager.indexTransferIn(transfer, store.getKey());
    }
    logger.debug("Returning transfer: {}", transfer);
    return transfer;
}