| package org.apache.archiva.repository.features; |
| |
| /* |
| * 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.repository.Repository; |
| import org.apache.archiva.repository.event.RepositoryIndexEvent; |
| import org.apache.archiva.event.EventHandler; |
| import org.apache.archiva.repository.storage.StorageAsset; |
| import org.apache.commons.lang3.StringUtils; |
| |
| import java.net.URI; |
| import java.net.URISyntaxException; |
| |
| import static org.apache.archiva.indexer.ArchivaIndexManager.DEFAULT_INDEX_PATH; |
| import static org.apache.archiva.indexer.ArchivaIndexManager.DEFAULT_PACKED_INDEX_PATH; |
| |
| /** |
| * |
| * This feature provides information about index creation. |
| * |
| * Repositories that support this feature are able to create indexes and download them from remote repositories. |
| * |
| * Repositories may have a normal and packed index. A normal index is used by repository search utilities, the packed |
| * index is for downloading purpose. |
| * |
| * A index may have a remote and a local representation. The remote representation is used for downloading and |
| * updating the local representation. |
| * |
| * The feature is throwing a {@link RepositoryIndexEvent}, if the URI of the index has been changed. |
| * |
| */ |
| public class IndexCreationFeature extends AbstractFeature implements RepositoryFeature<IndexCreationFeature>{ |
| |
| |
| private boolean skipPackedIndexCreation = false; |
| |
| private URI indexPath; |
| |
| private URI packedIndexPath; |
| |
| private StorageAsset localIndexPath; |
| |
| private StorageAsset localPackedIndexPath; |
| |
| private Repository repo; |
| |
| public IndexCreationFeature(Repository repository, EventHandler listener) { |
| super(listener); |
| this.repo = repository; |
| try { |
| this.indexPath = new URI(DEFAULT_INDEX_PATH); |
| this.packedIndexPath = new URI(DEFAULT_PACKED_INDEX_PATH); |
| } catch (URISyntaxException e) { |
| // Does not happen |
| e.printStackTrace(); |
| } |
| } |
| |
| public IndexCreationFeature(boolean skipPackedIndexCreation) { |
| this.skipPackedIndexCreation = skipPackedIndexCreation; |
| try { |
| this.indexPath = new URI(DEFAULT_INDEX_PATH); |
| this.packedIndexPath = new URI(DEFAULT_PACKED_INDEX_PATH); |
| } catch (URISyntaxException e) { |
| // Does not happen |
| e.printStackTrace(); |
| } |
| } |
| |
| @Override |
| public IndexCreationFeature get() { |
| return this; |
| } |
| |
| /** |
| * Returns true, if no packed index files should be created. |
| * @return True, if no packed index files are created, otherwise false. |
| */ |
| public boolean isSkipPackedIndexCreation() { |
| return skipPackedIndexCreation; |
| } |
| |
| /** |
| * Sets the flag for packed index creation. |
| * |
| * @param skipPackedIndexCreation |
| */ |
| public void setSkipPackedIndexCreation(boolean skipPackedIndexCreation) { |
| this.skipPackedIndexCreation = skipPackedIndexCreation; |
| } |
| |
| /** |
| * Returns the path that is used to store the index. The path may be a absolute URI or relative to the |
| * base URI of the repository. |
| * |
| * @return the uri (may be relative or absolute) |
| */ |
| public URI getIndexPath( ) |
| { |
| return indexPath; |
| } |
| |
| /** |
| * Sets the path that is used to store the index. The path may be either absolute or a |
| * path that is relative to the repository storage path (either a local or remote path). |
| * |
| * @param indexPath the uri to the index path (may be relative) |
| */ |
| public void setIndexPath( URI indexPath ) |
| { |
| if ((this.indexPath==null && indexPath!=null) || !this.indexPath.equals(indexPath)) { |
| URI oldVal = this.indexPath; |
| this.indexPath = indexPath; |
| pushEvent(RepositoryIndexEvent.indexUriChange(this, repo, oldVal, this.indexPath)); |
| } |
| |
| } |
| |
| /** |
| * Returns true, if this repository has a index defined. |
| * |
| * @return <code>true</code>, if a index path is set, otherwise <code>false</code> |
| */ |
| public boolean hasIndex() { |
| return this.indexPath!=null && !StringUtils.isEmpty( this.indexPath.getPath() ); |
| } |
| |
| /** |
| * Returns the path where the index is stored physically. |
| * |
| * @return |
| */ |
| public StorageAsset getLocalIndexPath() { |
| return localIndexPath; |
| } |
| |
| /** |
| * Sets the path where the index is stored locally. |
| * |
| * @param localIndexPath |
| */ |
| public void setLocalIndexPath(StorageAsset localIndexPath) { |
| this.localIndexPath = localIndexPath; |
| } |
| |
| |
| /** |
| * Returns the path of the packed index. |
| * @return |
| */ |
| public URI getPackedIndexPath() { |
| return packedIndexPath; |
| } |
| |
| /** |
| * Sets the path (relative or absolute) of the packed index. |
| * |
| * Throws a {@link RepositoryIndexEvent.Index#PACKED_INDEX_URI_CHANGE}, if the value changes. |
| * |
| * @param packedIndexPath the new path uri for the packed index |
| */ |
| public void setPackedIndexPath(URI packedIndexPath) { |
| URI oldVal = this.packedIndexPath; |
| this.packedIndexPath = packedIndexPath; |
| pushEvent(RepositoryIndexEvent.packedIndexUriChange(this, repo, oldVal, this.packedIndexPath)); |
| } |
| |
| /** |
| * Returns the directory where the packed index is stored. |
| * @return |
| */ |
| public StorageAsset getLocalPackedIndexPath() { |
| return localPackedIndexPath; |
| } |
| |
| /** |
| * Sets the path where the packed index is stored physically. This method should only be used by the |
| * MavenIndexProvider implementations. |
| * |
| * @param localPackedIndexPath |
| */ |
| public void setLocalPackedIndexPath(StorageAsset localPackedIndexPath) { |
| this.localPackedIndexPath = localPackedIndexPath; |
| } |
| |
| @Override |
| public String toString() { |
| StringBuilder sb = new StringBuilder(); |
| sb.append("IndexCreationFeature:{").append("skipPackedIndexCreation=").append(skipPackedIndexCreation) |
| .append(",indexPath=").append(indexPath).append(",packedIndexPath=").append(packedIndexPath).append("}"); |
| return sb.toString(); |
| } |
| } |