Java tutorial
package org.apache.archiva.repository.scanner; /* * 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. */ import org.apache.archiva.admin.model.RepositoryAdminException; import org.apache.archiva.admin.model.admin.ArchivaAdministration; import org.apache.archiva.admin.model.beans.ManagedRepository; import org.apache.archiva.common.utils.BaseFile; import org.apache.archiva.configuration.ArchivaConfiguration; import org.apache.archiva.consumers.InvalidRepositoryContentConsumer; import org.apache.archiva.consumers.KnownRepositoryContentConsumer; import org.apache.archiva.consumers.functors.ConsumerWantsFilePredicate; import org.apache.archiva.redback.components.registry.RegistryListener; import org.apache.archiva.repository.scanner.functors.ConsumerProcessFileClosure; import org.apache.archiva.repository.scanner.functors.TriggerBeginScanClosure; import org.apache.archiva.repository.scanner.functors.TriggerScanCompletedClosure; import org.apache.commons.collections.Closure; import org.apache.commons.collections.CollectionUtils; import org.apache.commons.collections.functors.IfClosure; import org.springframework.beans.BeansException; import org.springframework.context.ApplicationContext; import org.springframework.context.ApplicationContextAware; import org.springframework.stereotype.Service; import javax.inject.Inject; import java.io.File; import java.util.ArrayList; import java.util.Date; import java.util.HashMap; import java.util.List; import java.util.Map; /** * RepositoryContentConsumerUtil */ @Service("repositoryContentConsumers") public class RepositoryContentConsumers implements ApplicationContextAware { @Inject private ApplicationContext applicationContext; private ArchivaAdministration archivaAdministration; private List<KnownRepositoryContentConsumer> selectedKnownConsumers; private List<InvalidRepositoryContentConsumer> selectedInvalidConsumers; @Inject private ArchivaConfiguration archivaConfiguration; @Inject public RepositoryContentConsumers(ArchivaAdministration archivaAdministration) { this.archivaAdministration = archivaAdministration; } @Override public void setApplicationContext(ApplicationContext applicationContext) throws BeansException { this.applicationContext = applicationContext; } /** * <p> * Get the list of Ids associated with those {@link KnownRepositoryContentConsumer} that have * been selected in the configuration to execute. * </p> * <p> * NOTE: This list can be larger and contain entries that might not exist or be available * in the classpath, or as a component. * </p> * * @return the list of consumer ids that have been selected by the configuration. */ public List<String> getSelectedKnownConsumerIds() throws RepositoryAdminException { return archivaAdministration.getKnownContentConsumers(); } /** * <p> * Get the list of Ids associated with those {@link InvalidRepositoryContentConsumer} that have * been selected in the configuration to execute. * </p> * <p> * NOTE: This list can be larger and contain entries that might not exist or be available * in the classpath, or as a component. * </p> * * @return the list of consumer ids that have been selected by the configuration. */ public List<String> getSelectedInvalidConsumerIds() throws RepositoryAdminException { return archivaAdministration.getInvalidContentConsumers(); } /** * Get the map of {@link String} ids to {@link KnownRepositoryContentConsumer} implementations, * for those consumers that have been selected according to the active configuration. * * @return the map of String ids to {@link KnownRepositoryContentConsumer} objects. */ public Map<String, KnownRepositoryContentConsumer> getSelectedKnownConsumersMap() throws RepositoryAdminException { Map<String, KnownRepositoryContentConsumer> consumerMap = new HashMap<>(); for (KnownRepositoryContentConsumer consumer : getSelectedKnownConsumers()) { consumerMap.put(consumer.getId(), consumer); } return consumerMap; } /** * Get the map of {@link String} ids to {@link InvalidRepositoryContentConsumer} implementations, * for those consumers that have been selected according to the active configuration. * * @return the map of String ids to {@link InvalidRepositoryContentConsumer} objects. */ public Map<String, InvalidRepositoryContentConsumer> getSelectedInvalidConsumersMap() throws RepositoryAdminException { Map<String, InvalidRepositoryContentConsumer> consumerMap = new HashMap<>(); for (InvalidRepositoryContentConsumer consumer : getSelectedInvalidConsumers()) { consumerMap.put(consumer.getId(), consumer); } return consumerMap; } /** * Get the list of {@link KnownRepositoryContentConsumer} objects that are * selected according to the active configuration. * * @return the list of {@link KnownRepositoryContentConsumer} that have been selected * by the active configuration. */ public List<KnownRepositoryContentConsumer> getSelectedKnownConsumers() throws RepositoryAdminException { // FIXME only for testing if (selectedKnownConsumers != null) { return selectedKnownConsumers; } List<KnownRepositoryContentConsumer> ret = new ArrayList<>(); List<String> knownSelected = getSelectedKnownConsumerIds(); for (KnownRepositoryContentConsumer consumer : getAvailableKnownConsumers()) { if (knownSelected.contains(consumer.getId())) { ret.add(consumer); } } return ret; } public void releaseSelectedKnownConsumers(List<KnownRepositoryContentConsumer> repositoryContentConsumers) { if (repositoryContentConsumers == null) { return; } for (KnownRepositoryContentConsumer knownRepositoryContentConsumer : repositoryContentConsumers) { if (RegistryListener.class.isAssignableFrom(knownRepositoryContentConsumer.getClass())) { archivaConfiguration .removeChangeListener(RegistryListener.class.cast(knownRepositoryContentConsumer)); } } } /** * Get the list of {@link InvalidRepositoryContentConsumer} objects that are * selected according to the active configuration. * * @return the list of {@link InvalidRepositoryContentConsumer} that have been selected * by the active configuration. */ public synchronized List<InvalidRepositoryContentConsumer> getSelectedInvalidConsumers() throws RepositoryAdminException { // FIXME only for testing if (selectedInvalidConsumers != null) { return selectedInvalidConsumers; } List<InvalidRepositoryContentConsumer> ret = new ArrayList<>(); List<String> invalidSelected = getSelectedInvalidConsumerIds(); for (InvalidRepositoryContentConsumer consumer : getAvailableInvalidConsumers()) { if (invalidSelected.contains(consumer.getId())) { ret.add(consumer); } } return ret; } /** * Get the list of {@link KnownRepositoryContentConsumer} objects that are * available and present in the classpath and as components in the IoC. * * @return the list of all available {@link KnownRepositoryContentConsumer} present in the classpath * and as a component in the IoC. */ public List<KnownRepositoryContentConsumer> getAvailableKnownConsumers() { return new ArrayList<>(applicationContext.getBeansOfType(KnownRepositoryContentConsumer.class).values()); } /** * Get the list of {@link InvalidRepositoryContentConsumer} objects that are * available and present in the classpath and as components in the IoC. * * @return the list of all available {@link InvalidRepositoryContentConsumer} present in the classpath * and as a component in the IoC. */ public List<InvalidRepositoryContentConsumer> getAvailableInvalidConsumers() { return new ArrayList<>(applicationContext.getBeansOfType(InvalidRepositoryContentConsumer.class).values()); } /** * A convienence method to execute all of the active selected consumers for a * particular arbitrary file. * NOTE: Make sure that there is no repository scanning task executing before invoking this so as to prevent * the index writer/reader of the current index-content consumer executing from getting closed. For an example, * see ArchivaDavResource#executeConsumers( File ). * * @param repository the repository configuration to use. * @param localFile the local file to execute the consumers against. * @param updateRelatedArtifacts TODO */ public void executeConsumers(ManagedRepository repository, File localFile, boolean updateRelatedArtifacts) throws RepositoryAdminException { List<KnownRepositoryContentConsumer> selectedKnownConsumers = null; // Run the repository consumers try { Closure triggerBeginScan = new TriggerBeginScanClosure(repository, getStartTime(), false); selectedKnownConsumers = getSelectedKnownConsumers(); // MRM-1212/MRM-1197 // - do not create missing/fix invalid checksums and update metadata when deploying from webdav since these are uploaded by maven if (!updateRelatedArtifacts) { List<KnownRepositoryContentConsumer> clone = new ArrayList<>(); clone.addAll(selectedKnownConsumers); for (KnownRepositoryContentConsumer consumer : clone) { if (consumer.getId().equals("create-missing-checksums") || consumer.getId().equals("metadata-updater")) { selectedKnownConsumers.remove(consumer); } } } List<InvalidRepositoryContentConsumer> selectedInvalidConsumers = getSelectedInvalidConsumers(); CollectionUtils.forAllDo(selectedKnownConsumers, triggerBeginScan); CollectionUtils.forAllDo(selectedInvalidConsumers, triggerBeginScan); // yuck. In case you can't read this, it says // "process the file if the consumer has it in the includes list, and not in the excludes list" BaseFile baseFile = new BaseFile(repository.getLocation(), localFile); ConsumerWantsFilePredicate predicate = new ConsumerWantsFilePredicate(repository); predicate.setBasefile(baseFile); predicate.setCaseSensitive(false); ConsumerProcessFileClosure closure = new ConsumerProcessFileClosure(); closure.setBasefile(baseFile); closure.setExecuteOnEntireRepo(false); Closure processIfWanted = IfClosure.getInstance(predicate, closure); CollectionUtils.forAllDo(selectedKnownConsumers, processIfWanted); if (predicate.getWantedFileCount() <= 0) { // Nothing known processed this file. It is invalid! CollectionUtils.forAllDo(selectedInvalidConsumers, closure); } TriggerScanCompletedClosure scanCompletedClosure = new TriggerScanCompletedClosure(repository, false); CollectionUtils.forAllDo(selectedKnownConsumers, scanCompletedClosure); } finally { /* TODO: This is never called by the repository scanner instance, so not calling here either - but it probably should be? CollectionUtils.forAllDo( availableKnownConsumers, triggerCompleteScan ); CollectionUtils.forAllDo( availableInvalidConsumers, triggerCompleteScan ); */ releaseSelectedKnownConsumers(selectedKnownConsumers); } } public void setSelectedKnownConsumers(List<KnownRepositoryContentConsumer> selectedKnownConsumers) { this.selectedKnownConsumers = selectedKnownConsumers; } public void setSelectedInvalidConsumers(List<InvalidRepositoryContentConsumer> selectedInvalidConsumers) { this.selectedInvalidConsumers = selectedInvalidConsumers; } protected Date getStartTime() { return new Date(System.currentTimeMillis()); } public void setArchivaAdministration(ArchivaAdministration archivaAdministration) { this.archivaAdministration = archivaAdministration; } }