source.dussan.org Git - archiva.git/blob

   1 package org.apache.archiva.repository;
   2
   3 /*
   4  * Licensed to the Apache Software Foundation (ASF) under one
   5  * or more contributor license agreements.  See the NOTICE file
   6  * distributed with this work for additional information
   7  * regarding copyright ownership.  The ASF licenses this file
   8  * to you under the Apache License, Version 2.0 (the
   9  * "License"); you may not use this file except in compliance
  10  * with the License.  You may obtain a copy of the License at
  11  *
  12  *  http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing,
  15  * software distributed under the License is distributed on an
  16  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  17  * KIND, either express or implied.  See the License for the
  18  * specific language governing permissions and limitations
  19  * under the License.
  20  */
  21
  22 import org.apache.archiva.model.ArchivaArtifact;
  23 import org.apache.archiva.model.ArtifactReference;
  24 import org.apache.archiva.model.ProjectReference;
  25 import org.apache.archiva.model.VersionedReference;
  26 import org.apache.archiva.repository.layout.LayoutException;
  27
  28 import java.nio.file.Path;
  29 import java.util.Set;
  30
  31 /**
  32  * ManagedRepositoryContent interface for interacting with a managed repository in an abstract way,
  33  * without the need for processing based on filesystem paths, or working with the database.
  34  */
  35 public interface ManagedRepositoryContent extends RepositoryContent
  36 {
  37
  38
  39
  40     /**
  41      * Delete from the managed repository all files / directories associated with the
  42      * provided version reference.
  43      *
  44      * @param reference the version reference to delete.
  45      * @throws ContentNotFoundException
  46      */
  47     void deleteVersion( VersionedReference reference )
  48         throws ContentNotFoundException;
  49
  50     /**
  51      * delete a specified artifact from the repository
  52      *
  53      * @param artifactReference
  54      * @throws ContentNotFoundException
  55      */
  56     void deleteArtifact( ArtifactReference artifactReference )
  57         throws ContentNotFoundException;
  58
  59     /**
  60      * @param groupId
  61      * @throws ContentNotFoundException
  62      * @since 1.4-M3
  63      */
  64     void deleteGroupId( String groupId )
  65         throws ContentNotFoundException;
  66
  67     /**
  68      *
  69      * @param namespace groupId for maven
  70      * @param projectId artifactId for maven
  71      * @throws ContentNotFoundException
  72      */
  73     void deleteProject( String namespace, String projectId )
  74         throws RepositoryException;
  75
  76     /**
  77      * <p>
  78      * Convenience method to get the repository id.
  79      * </p>
  80      * <p>
  81      * Equivalent to calling <code>.getRepository().getId()</code>
  82      * </p>
  83      *
  84      * @return the repository id.
  85      */
  86     String getId();
  87
  88     /**
  89      * <p>
  90      * Gather up the list of related artifacts to the ArtifactReference provided.
  91      * This typically inclues the pom files, and those things with
  92      * classifiers (such as doc, source code, test libs, etc...)
  93      * </p>
  94      * <p>
  95      * <strong>NOTE:</strong> Some layouts (such as maven 1 "legacy") are not compatible with this query.
  96      * </p>
  97      *
  98      * @param reference the reference to work off of.
  99      * @return the set of ArtifactReferences for related artifacts.
 100      * @throws ContentNotFoundException if the initial artifact reference does not exist within the repository.
 101      */
 102     Set<ArtifactReference> getRelatedArtifacts( ArtifactReference reference )
 103         throws ContentNotFoundException;
 104
 105     /**
 106      * <p>
 107      * Convenience method to get the repository (on disk) root directory.
 108      * </p>
 109      * <p>
 110      * Equivalent to calling <code>.getRepository().getLocation()</code>
 111      * </p>
 112      *
 113      * @return the repository (on disk) root directory.
 114      */
 115     String getRepoRoot();
 116
 117     /**
 118      * Get the repository configuration associated with this
 119      * repository content.
 120      *
 121      * @return the repository that is associated with this repository content.
 122      */
 123     ManagedRepository getRepository();
 124
 125     /**
 126      * Given a specific {@link ProjectReference}, return the list of available versions for
 127      * that project reference.
 128      *
 129      * @param reference the project reference to work off of.
 130      * @return the list of versions found for that project reference.
 131      * @throws ContentNotFoundException if the project reference does nto exist within the repository.
 132      * @throws LayoutException
 133      */
 134     Set<String> getVersions( ProjectReference reference )
 135         throws ContentNotFoundException, LayoutException;
 136
 137     /**
 138      * <p>
 139      * Given a specific {@link VersionedReference}, return the list of available versions for that
 140      * versioned reference.
 141      * </p>
 142      * <p>
 143      * <strong>NOTE:</strong> This is really only useful when working with SNAPSHOTs.
 144      * </p>
 145      *
 146      * @param reference the versioned reference to work off of.
 147      * @return the set of versions found.
 148      * @throws ContentNotFoundException if the versioned reference does not exist within the repository.
 149      */
 150     Set<String> getVersions( VersionedReference reference )
 151         throws ContentNotFoundException;
 152
 153     /**
 154      * Determines if the artifact referenced exists in the repository.
 155      *
 156      * @param reference the artifact reference to check for.
 157      * @return true if the artifact referenced exists.
 158      */
 159     boolean hasContent( ArtifactReference reference );
 160
 161     /**
 162      * Determines if the project referenced exists in the repository.
 163      *
 164      * @param reference the project reference to check for.
 165      * @return true it the project referenced exists.
 166      */
 167     boolean hasContent( ProjectReference reference );
 168
 169     /**
 170      * Determines if the version reference exists in the repository.
 171      *
 172      * @param reference the version reference to check for.
 173      * @return true if the version referenced exists.
 174      */
 175     boolean hasContent( VersionedReference reference );
 176
 177     /**
 178      * Set the repository configuration to associate with this
 179      * repository content.
 180      *
 181      * @param repo the repository to associate with this repository content.
 182      */
 183     void setRepository( org.apache.archiva.repository.ManagedRepository repo );
 184
 185     /**
 186      * Given an {@link ArtifactReference}, return the file reference to the artifact.
 187      *
 188      * @param reference the artifact reference to use.
 189      * @return the relative path to the artifact.
 190      */
 191     Path toFile( ArtifactReference reference );
 192
 193     /**
 194      * Given an {@link ArchivaArtifact}, return the file reference to the artifact.
 195      *
 196      * @param reference the archiva artifact to use.
 197      * @return the relative path to the artifact.
 198      */
 199     Path toFile( ArchivaArtifact reference );
 200
 201     /**
 202      * Given a {@link ProjectReference}, return the path to the metadata for
 203      * the project.
 204      *
 205      * @param reference the reference to use.
 206      * @return the path to the metadata file, or null if no metadata is appropriate.
 207      */
 208     String toMetadataPath( ProjectReference reference );
 209
 210     /**
 211      * Given a {@link VersionedReference}, return the path to the metadata for
 212      * the specific version of the project.
 213      *
 214      * @param reference the reference to use.
 215      * @return the path to the metadata file, or null if no metadata is appropriate.
 216      */
 217     String toMetadataPath( VersionedReference reference );
 218
 219     /**
 220      * Given an {@link ArchivaArtifact}, return the relative path to the artifact.
 221      *
 222      * @param reference the archiva artifact to use.
 223      * @return the relative path to the artifact.
 224      */
 225     String toPath( ArchivaArtifact reference );
 226 }