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

   1 package org.apache.archiva.metadata.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.metadata.QueryParameter;
  23 import org.apache.archiva.metadata.model.ArtifactMetadata;
  24 import org.apache.archiva.metadata.model.MetadataFacet;
  25 import org.apache.archiva.metadata.model.ProjectMetadata;
  26 import org.apache.archiva.metadata.model.ProjectVersionMetadata;
  27 import org.apache.archiva.metadata.model.ProjectVersionReference;
  28
  29 import javax.annotation.Nonnull;
  30 import javax.annotation.Nullable;
  31 import java.time.ZonedDateTime;
  32 import java.util.Collection;
  33 import java.util.List;
  34 import java.util.stream.Stream;
  35
  36 /**
  37  * A Metadata repository provides information about artifact metadata. It does not provide the artifact data itself.
  38  * It may be possible to use the same backend for metadata and storage, but this depends on the backends and they are
  39  * provided by different APIs.
  40  *
  41  * The motivation for this API is to provide fast access to the repository metadata and fulltext search. Also dependencies
  42  * are stored in this repository.
  43  *
  44  * The methods here do not update the artifacts itself. They are only updating the data in the metadata repository.
  45  * That means, if you want to update some artifact, you should make sure to update the artifact itself and the metadata
  46  * repository (either directly or by repository scanning).
  47  *
  48  * Currently we are providing JCR, File based and Cassandra as backend for the metadata.
  49  *
  50  * The metadata repository uses sessions for accessing the data. Please make sure to always close the sessions after using it.
  51  * Best idiom for using the sessions:
  52  * <code>
  53  * try(RepositorySession session = sessionFactory.createSession() {
  54  *     // do your stuff
  55  * }
  56  * </code>
  57  *
  58  * It is implementation dependent, if the sessions are really used by the backend. E.g. the file based implementation ignores
  59  * the sessions completely.
  60  *
  61  * Sessions should be closed immediately after usage. If it is expensive to open a session for a given backend. The backend
  62  * should provide a session pool if possible. There are methods for refreshing a session if needed.
  63  *
  64  * You should avoid stacking sessions, that means, do not create a new session in the same thread, when a session is opened already.
  65  *
  66  * Some backend implementations (JCR) update the metadata in the background, that means update of the metadata is not reflected
  67  * immediately.
  68  *
  69  * The base metadata coordinates are:
  70  * <ul>
  71  *     <li>Repository ID: The identifier of the repository, where the artifact resides</li>
  72  *     <li>Namespace: This is a hierarchical coordinate for locating the projects. E.g. this corresponds to the groupId in maven. </li>
  73  *     <li>Project ID: The project itself</li>
  74  *     <li>Version: Each project may have different versions.</li>
  75  *     <li>Artifact: Artifacts correspond to files / blob data. Each artifact has additional metadata, like name, version, modification time, ...</li>
  76  * </ul>
  77  *
  78  * As the repository connects to some backend either locally or remote, the access to the repository may fail. The methods capsule the
  79  * backend errors into <code>{@link MetadataRepositoryException}</code>.
  80  *
  81  * Facets are the way to provide additional metadata that is not part of the base API. It depends on the repository type (e.g. Maven, NPM,
  82  * not the metadata backend) what facets are stored in addition to the standard metadata.
  83  * Facets have a specific facet ID that represents the schema for the data stored. For creating specific objects for a given
  84  * facet id the <code>{@link org.apache.archiva.metadata.model.MetadataFacetFactory}</code> is used.
  85  * For each facet id there may exist multiple facet instances on each level. Facet instances are identified by their name, which may be
  86  * a hierarchical path.
  87  * The data in each facet instance is stored in properties (key-value pairs). The properties are converted into / from the specific
  88  * facet object.
  89  *
  90  * Facets can be stored on repository, project, version and artifact level.
  91  *
  92  * For retrieving artifacts there are methods that return lists and streaming based methods. Some implementations (e.g. JCR) use
  93  * lazy loading for the retrieved objects. So the streaming methods may be faster and use less memory than the list based methods.
  94  * But for some backends there is no difference.
  95  *
  96  */
  97 public interface MetadataRepository
  98 {
  99
 100
 101
 102     /**
 103      * Update metadata for a particular project in the metadata repository, or create it, if it does not already exist.
 104      *
 105      * @param session The session used for updating.
 106      * @param repositoryId the repository the project is in
 107      * @param project      the project metadata to create or update
 108      * @throws MetadataRepositoryException if the update fails
 109      */
 110     void updateProject( @Nonnull RepositorySession session, @Nonnull String repositoryId, @Nonnull ProjectMetadata project )
 111         throws MetadataRepositoryException;
 112
 113     /**
 114      * Update the metadata of a given artifact. If the artifact, namespace, version, project does not exist in the repository it will be created.
 115      *
 116      * @param session The repository session
 117      * @param repositoryId The repository id
 118      * @param namespace The namespace ('.' separated)
 119      * @param projectId The project id
 120      * @param projectVersion The project version
 121      * @param artifactMeta Information about the artifact itself.
 122      * @throws MetadataRepositoryException if something goes wrong during update.
 123      */
 124     void updateArtifact( @Nonnull RepositorySession session, @Nonnull String repositoryId,
 125                          @Nonnull String namespace, @Nonnull String projectId, @Nonnull String projectVersion,
 126                          @Nonnull ArtifactMetadata artifactMeta )
 127         throws MetadataRepositoryException;
 128
 129     /**
 130      * Updates the metadata for a specific version of a given project. If the namespace, project, version does not exist,
 131      * it will be created.
 132      *
 133      * @param session The repository session
 134      * @param repositoryId The repository id
 135      * @param namespace The namespace ('.' separated)
 136      * @param projectId The project id
 137      * @param versionMetadata The metadata for the version
 138      * @throws MetadataRepositoryException if something goes wrong during update
 139      */
 140     void updateProjectVersion( @Nonnull RepositorySession session, @Nonnull String repositoryId,
 141                                @Nonnull String namespace, @Nonnull String projectId,
 142                                @Nonnull ProjectVersionMetadata versionMetadata )
 143         throws MetadataRepositoryException;
 144
 145     /**
 146      * Create the namespace in the repository, if it does not exist.
 147      * Namespaces do not have specific metadata attached.
 148      *
 149      * @param session The repository session
 150      * @param repositoryId The repository id
 151      * @param namespace The namespace ('.' separated)
 152      * @throws MetadataRepositoryException if something goes wrong during update
 153      */
 154     void updateNamespace( @Nonnull RepositorySession session, @Nonnull String repositoryId, @Nonnull String namespace )
 155         throws MetadataRepositoryException;
 156
 157     /**
 158      * Return the facet names stored for the given facet id on the repository level.
 159      *
 160      * @param session The repository session
 161      * @param repositoryId The repository id
 162      * @param facetId The facet id
 163      * @return The list of facet names, or an empty list, if there are no facets stored on this repository for the given facet id.
 164      * @throws MetadataRepositoryException if something goes wrong
 165      */
 166     List<String> getMetadataFacets( @Nonnull RepositorySession session, @Nonnull String repositoryId, @Nonnull String facetId )
 167         throws MetadataRepositoryException;
 168
 169
 170     /**
 171      *
 172      * The same as
 173      * @see #getMetadataFacetStream(RepositorySession, String, Class, QueryParameter queryParameter)
 174      * but uses default query parameters.
 175      *
 176      * There is no limitation of the number of result objects returned, but implementations may have a hard upper bound for
 177      * the number of results.
 178      *
 179      * @param session
 180      * @param repositoryId
 181      * @param facetClazz
 182      * @param <T>
 183      * @return
 184      * @throws MetadataRepositoryException
 185      * @since 3.0
 186      */
 187     <T extends MetadataFacet> Stream<T> getMetadataFacetStream( @Nonnull RepositorySession session,
 188                                                                 @Nonnull String repositoryId, @Nonnull Class<T> facetClazz)
 189         throws MetadataRepositoryException;
 190
 191     /**
 192      * Returns a stream of MetadataFacet elements that match the given facet class.
 193      * Implementations should order the resulting stream by facet name.
 194      *
 195      *
 196      * @param session The repository session
 197      * @param repositoryId The repository id
 198      * @param facetClazz The class of the facet
 199      * @param <T> The facet type
 200      * @return
 201      * @throws MetadataRepositoryException
 202      * @since 3.0
 203      */
 204     <T extends MetadataFacet> Stream<T> getMetadataFacetStream(@Nonnull RepositorySession session,
 205                                                                 @Nonnull String repositoryId,  @Nonnull Class<T> facetClazz,
 206                                                                 @Nonnull QueryParameter queryParameter)
 207         throws MetadataRepositoryException;
 208
 209     /**
 210      * Returns true, if there is facet data stored for the given facet id on the repository on repository level. The facet data itself
 211      * may be empty. It's just checking if there is an object stored for the given facet id.
 212      *
 213      * @param session The repository session
 214      * @param repositoryId The repository id
 215      * @param facetId The facet id
 216      * @return true if there is data stored this facetId on repository level.
 217      * @throws MetadataRepositoryException if something goes wrong
 218      * @since 1.4-M4
 219      */
 220     boolean hasMetadataFacet( @Nonnull RepositorySession session, @Nonnull String repositoryId, @Nonnull String facetId )
 221         throws MetadataRepositoryException;
 222
 223     /**
 224      * Returns the facet data stored on the repository level. The facet instance is identified by the facet id and the
 225      * facet name. The returned object is a instance created by using <code>{@link org.apache.archiva.metadata.model.MetadataFacetFactory}</code>.
 226      *
 227      * @param session The repository session
 228      * @param repositoryId The repository id
 229      * @param facetId The facet id
 230      * @param name The attribute name
 231      * @return The facet values
 232      * @throws MetadataRepositoryException if something goes wrong.
 233      */
 234     MetadataFacet getMetadataFacet( @Nonnull RepositorySession session, @Nonnull String repositoryId, @Nonnull String facetId,
 235                                     @Nonnull String name )
 236         throws MetadataRepositoryException;
 237
 238     /**
 239      * Returns the facet instance for the given class, which is stored on repository level for the given name.
 240      * If the given name does not point to a instance that can be represented by this class, <code>null</code> will be returned.
 241      * If the facet is not found the method returns <code>null</code>.
 242      *
 243      * @param session The repository session
 244      * @param repositoryId The id of the repository
 245      * @param clazz The facet object class
 246      * @param name The name of the facet (name or path)
 247      * @param <T> The type of the facet object
 248      * @return The facet instance, if it exists.
 249      * @throws MetadataRepositoryException if the data cannot be retrieved from the backend
 250      * @since 3.0
 251      */
 252     <T extends MetadataFacet> T getMetadataFacet(@Nonnull RepositorySession session, @Nonnull String repositoryId,
 253                                                  @Nonnull Class<T> clazz, @Nonnull String name)
 254     throws MetadataRepositoryException;
 255
 256     /**
 257      * Adds a facet to the repository level.
 258      *
 259      * @param session The repository session
 260      * @param repositoryId The id of the repository
 261      * @param metadataFacet The facet to add
 262      * @throws MetadataRepositoryException if the facet cannot be stored.
 263      */
 264     void addMetadataFacet( @Nonnull RepositorySession session, @Nonnull String repositoryId,
 265                            @Nonnull MetadataFacet metadataFacet )
 266         throws MetadataRepositoryException;
 267
 268     /**
 269      * Removes all facets with the given facetId from the repository level.
 270      *
 271      * @param session The repository session
 272      * @param repositoryId The id of the repository
 273      * @param facetId The facet id
 274      * @throws MetadataRepositoryException if the removal fails
 275      */
 276     void removeMetadataFacets( @Nonnull RepositorySession session, @Nonnull String repositoryId, @Nonnull String facetId )
 277         throws MetadataRepositoryException;
 278
 279     /**
 280      * Removes the given facet from the repository level, if it exists.
 281      *
 282      * @param session The repository session
 283      * @param repositoryId The id of the repository
 284      * @param facetId The facet id
 285      * @param name The facet name or path
 286      */
 287     void removeMetadataFacet( @Nonnull RepositorySession session, @Nonnull String repositoryId, @Nonnull String facetId, @Nonnull String name )
 288         throws MetadataRepositoryException;
 289
 290
 291     /**
 292      * Is the same as {@link #getArtifactsByDateRange(RepositorySession, String, ZonedDateTime, ZonedDateTime, QueryParameter)}, but
 293      * uses default query parameters.
 294      *
 295      */
 296     List<ArtifactMetadata> getArtifactsByDateRange( @Nonnull RepositorySession session, @Nonnull String repositoryId,
 297                                                     @Nullable ZonedDateTime startTime, @Nullable ZonedDateTime endTime )
 298         throws MetadataRepositoryException;
 299
 300     /**
 301      *
 302      * Searches for artifacts where the 'whenGathered' attribute value is between the given start and end time.
 303      * If start or end time or both are <code>null</code>, the time range for the search is unbounded for this parameter.
 304      *
 305      *
 306      * @param session The repository session
 307      * @param repositoryId The repository id
 308      * @param startTime    The start time/date as zoned date, can be <code>null</code>
 309      * @param endTime      The end time/date as zoned date, can be <code>null</code>
 310      * @param queryParameter Additional parameters for the query that affect ordering and returned results
 311      * @return The list of metadata objects for the found instances.
 312      * @throws MetadataRepositoryException if the query fails.
 313      * @since 3.0
 314      */
 315     List<ArtifactMetadata> getArtifactsByDateRange(@Nonnull RepositorySession session, @Nonnull String repositoryId,
 316                                                    @Nullable ZonedDateTime startTime, @Nullable ZonedDateTime endTime,
 317                                                    @Nonnull QueryParameter queryParameter )
 318             throws MetadataRepositoryException;
 319
 320
 321     /**
 322      * Returns all the artifacts who's 'whenGathered' attribute value is inside the given time range (inclusive) as stream of objects.
 323      *
 324      * Implementations should return a stream of sorted objects. The objects should be sorted by the 'whenGathered' date in ascending order.
 325      *
 326      * @param session The repository session
 327      * @param repositoryId The repository id
 328      * @param startTime The start time, can be <code>null</code>
 329      * @param endTime The end time, can be <code>null</code>
 330      * @return A stream of artifact metadata objects.
 331      * @throws MetadataRepositoryException
 332      * @since 3.0
 333      */
 334     Stream<ArtifactMetadata> getArtifactByDateRangeStream( @Nonnull RepositorySession session, @Nonnull String repositoryId,
 335                                                            @Nullable ZonedDateTime startTime, @Nullable ZonedDateTime endTime )
 336         throws MetadataRepositoryException;
 337
 338     /**
 339      * Returns all the artifacts who's 'whenGathered' attribute value is inside the given time range (inclusive) as stream of objects.
 340      *
 341      * If no sort attributes are given by the queryParameter, the result is sorted by the 'whenGathered' date.
 342      *
 343      * @param session The repository session
 344      * @param repositoryId The repository id
 345      * @param startTime The start time, can be <code>null</code>
 346      * @param endTime The end time, can be <code>null</code>
 347      * @param queryParameter Additional parameters for the query that affect ordering and number of returned results.
 348      * @return A stream of artifact metadata objects.
 349      * @throws MetadataRepositoryException
 350      * @since 3.0
 351      */
 352     Stream<ArtifactMetadata> getArtifactByDateRangeStream( @Nonnull RepositorySession session, @Nonnull String repositoryId,
 353                                                            @Nullable ZonedDateTime startTime, @Nullable ZonedDateTime endTime,
 354                                                            @Nonnull QueryParameter queryParameter)
 355         throws MetadataRepositoryException;
 356
 357
 358     /**
 359      * Returns the artifacts that match the given checksum. All checksum types are searched.
 360      *
 361      * @param session The repository session
 362      * @param repositoryId  The repository id
 363      * @param checksum The checksum as string of numbers
 364      * @return The list of artifacts that match the given checksum.
 365      * @throws MetadataRepositoryException
 366      */
 367     List<ArtifactMetadata> getArtifactsByChecksum(@Nonnull RepositorySession session, @Nonnull String repositoryId, @Nonnull String checksum )
 368         throws MetadataRepositoryException;
 369
 370     /**
 371      * Get artifacts with a project version metadata key that matches the passed value.
 372      *
 373      *
 374      * @param session
 375      * @param key
 376      * @param value
 377      * @param repositoryId can be null, meaning search in all repositories
 378      * @return a list of artifacts
 379      * @throws MetadataRepositoryException
 380      */
 381     List<ArtifactMetadata> getArtifactsByProjectVersionMetadata( @Nonnull RepositorySession session, @Nonnull String key, @Nonnull String value,
 382                                                                  @Nullable String repositoryId )
 383         throws MetadataRepositoryException;
 384
 385     /**
 386      * Get artifacts with an artifact metadata key that matches the passed value.
 387      *
 388      *
 389      * @param session
 390      * @param key
 391      * @param value
 392      * @param repositoryId can be null, meaning search in all repositories
 393      * @return a list of artifacts
 394      * @throws MetadataRepositoryException
 395      */
 396     List<ArtifactMetadata> getArtifactsByMetadata( RepositorySession session, String key, String value, String repositoryId )
 397         throws MetadataRepositoryException;
 398
 399     /**
 400      * Get artifacts with a property key that matches the passed value.
 401      * Possible keys are 'scm.url', 'org.name', 'url', 'mailingList.0.name', 'license.0.name',...
 402      *
 403      *
 404      * @param session
 405      * @param key
 406      * @param value
 407      * @param repositoryId can be null, meaning search in all repositories
 408      * @return a list of artifacts
 409      * @throws MetadataRepositoryException
 410      */
 411     List<ArtifactMetadata> getArtifactsByProperty( RepositorySession session, String key, String value, String repositoryId )
 412         throws MetadataRepositoryException;
 413
 414     void removeArtifact( RepositorySession session, String repositoryId, String namespace, String project, String version, String id )
 415         throws MetadataRepositoryException;
 416
 417     /**
 418      * used for deleting timestamped version of SNAPSHOT artifacts
 419      *
 420      *
 421      * @param session
 422      * @param artifactMetadata the artifactMetadata with the timestamped version (2.0-20120618.214135-2)
 423      * @param baseVersion      the base version of the snapshot (2.0-SNAPSHOT)
 424      * @throws MetadataRepositoryException
 425      * @since 1.4-M3
 426      */
 427     void removeArtifact( RepositorySession session, ArtifactMetadata artifactMetadata, String baseVersion )
 428         throws MetadataRepositoryException;
 429
 430     /**
 431      * FIXME need a unit test!!!
 432      * Only remove {@link MetadataFacet} for the artifact
 433      *
 434      *
 435      * @param session
 436      * @param repositoryId
 437      * @param namespace
 438      * @param project
 439      * @param version
 440      * @param metadataFacet
 441      * @throws MetadataRepositoryException
 442      * @since 1.4-M3
 443      */
 444     void removeArtifact( RepositorySession session, String repositoryId, String namespace, String project, String version,
 445                          MetadataFacet metadataFacet )
 446         throws MetadataRepositoryException;
 447
 448     /**
 449      * Delete a repository's metadata. This includes all associated metadata facets.
 450      *
 451      * @param session
 452      * @param repositoryId the repository to delete
 453      */
 454     void removeRepository( RepositorySession session, String repositoryId )
 455         throws MetadataRepositoryException;
 456
 457     /**
 458      *
 459      * @param session
 460      * @param repositoryId
 461      * @param namespace    (groupId for maven )
 462      * @throws MetadataRepositoryException
 463      * @since 1.4-M3
 464      */
 465     void removeNamespace( RepositorySession session, String repositoryId, String namespace )
 466         throws MetadataRepositoryException;
 467
 468     List<ArtifactMetadata> getArtifacts( RepositorySession session, String repositoryId )
 469         throws MetadataRepositoryException;
 470
 471     /**
 472      * Returns a stream of artifacts that are stored in the given repository. The number and order of elements in the stream
 473      * is defined by the <code>queryParameter</code>.
 474      * The efficiency of ordering of elements is dependent on the implementation.
 475      * There may be some implementations that have to put a hard limit on the elements returned.
 476      * If there are no <code>sortFields</code> defined in the query parameter, the order of elements in the stream is undefined and depends
 477      * on the implementation.
 478      *
 479      * @param session
 480      * @param repositoryId
 481      * @return A stream of artifact metadata objects for each artifact found in the repository.
 482      * @since 3.0
 483      */
 484     Stream<ArtifactMetadata> getArtifactStream( @Nonnull RepositorySession session, @Nonnull String repositoryId, @Nonnull QueryParameter queryParameter )
 485         throws MetadataResolutionException;
 486
 487     /**
 488      * Returns a stream of all the artifacts in the given repository using default query parameter.
 489      * The order of the artifacts returned in the stream depends on the implementation.
 490      * The number of elements in the stream is unlimited, but there may be some implementations that have to put a hard
 491      * limit on the elements returned.
 492      * For further information see {@link #getArtifactStream(RepositorySession, String, QueryParameter)}
 493      *
 494      * @param session The repository session
 495      * @param repositoryId The repository id
 496      * @return A (unlimited) stream of artifact metadata elements that are found in this repository
 497      * @since 3.0
 498      * @see #getArtifactStream(RepositorySession, String, QueryParameter)
 499      */
 500     Stream<ArtifactMetadata> getArtifactStream( @Nonnull RepositorySession session, @Nonnull String repositoryId)
 501         throws MetadataResolutionException;
 502
 503     /**
 504      * Returns a stream of artifacts found for the given artifact coordinates and using the <code>queryParameter</code>
 505      *
 506      * @param session The repository session. May not be <code>null</code>.
 507      * @param repoId The repository id. May not be <code>null</code>.
 508      * @param namespace The namespace. May not be <code>null</code>.
 509      * @param projectId The project id. May not be <code>null</code>.
 510      * @param projectVersion The project version. May not be <code>null</code>.
 511      * @return A stream of artifact metadata object. Order and number of elements returned, depends on the <code>queryParameter</code>.
 512      * @since 3.0
 513      * @throws MetadataResolutionException if there are no elements for the given artifact coordinates.
 514      */
 515     Stream<ArtifactMetadata> getArtifactStream( @Nonnull RepositorySession session, @Nonnull String repoId,
 516                                                 @Nonnull String namespace, @Nonnull String projectId,
 517                                                 @Nonnull String projectVersion, @Nonnull QueryParameter queryParameter )
 518         throws MetadataResolutionException;
 519
 520     /**
 521      * Returns a stream of artifacts found for the given artifact coordinates. The order of elements returned, depends on the
 522      * implementation.
 523      *
 524      * @param session The repository session. May not be <code>null</code>.
 525      * @param repoId The repository id. May not be <code>null</code>.
 526      * @param namespace The namespace. May not be <code>null</code>.
 527      * @param projectId The project id. May not be <code>null</code>.
 528      * @param projectVersion The project version. May not be <code>null</code>.
 529      * @return A stream of artifact metadata object. Order and number of elements returned, depends on the <code>queryParameter</code>.
 530      * @since 3.0
 531      * @throws MetadataResolutionException if there are no elements for the given artifact coordinates.
 532      */
 533     Stream<ArtifactMetadata> getArtifactStream( @Nonnull RepositorySession session, @Nonnull String repoId,
 534                                                 @Nonnull String namespace, @Nonnull String projectId,
 535                                            @Nonnull String projectVersion)
 536         throws MetadataResolutionException;
 537     /**
 538      * basically just checking it exists not complete data returned
 539      *
 540      *
 541      * @param session
 542      * @param repoId
 543      * @param namespace
 544      * @param projectId
 545      * @return
 546      * @throws MetadataResolutionException
 547      */
 548     ProjectMetadata getProject( RepositorySession session, String repoId, String namespace, String projectId )
 549         throws MetadataResolutionException;
 550
 551     ProjectVersionMetadata getProjectVersion( RepositorySession session, String repoId, String namespace, String projectId, String projectVersion )
 552         throws MetadataResolutionException;
 553
 554     Collection<String> getArtifactVersions( RepositorySession session, String repoId, String namespace, String projectId, String projectVersion )
 555         throws MetadataResolutionException;
 556
 557     /**
 558      * Retrieve project references from the metadata repository. Note that this is not built into the content model for
 559      * a project version as a reference may be present (due to reverse-lookup of dependencies) before the actual
 560      * project is, and we want to avoid adding a stub model to the content repository.
 561      *
 562      *
 563      * @param session
 564      * @param repoId         the repository ID to look within
 565      * @param namespace      the namespace of the project to get references to
 566      * @param projectId      the identifier of the project to get references to
 567      * @param projectVersion the version of the project to get references to
 568      * @return a list of project references
 569      */
 570     Collection<ProjectVersionReference> getProjectReferences( RepositorySession session, String repoId, String namespace, String projectId,
 571                                                               String projectVersion )
 572         throws MetadataResolutionException;
 573
 574     Collection<String> getRootNamespaces( RepositorySession session, String repoId )
 575         throws MetadataResolutionException;
 576
 577     /**
 578      *
 579      * @param session
 580      * @param repoId
 581      * @param namespace
 582      * @return {@link Collection} of child namespaces of the namespace argument
 583      * @throws MetadataResolutionException
 584      */
 585     Collection<String> getNamespaces( RepositorySession session, String repoId, String namespace )
 586         throws MetadataResolutionException;
 587
 588     /**
 589      *
 590      * @param session
 591      * @param repoId
 592      * @param namespace
 593      * @return
 594      * @throws MetadataResolutionException
 595      */
 596     Collection<String> getProjects( RepositorySession session, String repoId, String namespace )
 597         throws MetadataResolutionException;
 598
 599     /**
 600      *
 601      * @param session
 602      * @param repoId
 603      * @param namespace
 604      * @param projectId
 605      * @return
 606      * @throws MetadataResolutionException
 607      */
 608     Collection<String> getProjectVersions( RepositorySession session, String repoId, String namespace, String projectId )
 609         throws MetadataResolutionException;
 610
 611     /**
 612      *
 613      * @param session
 614      * @param repoId
 615      * @param namespace
 616      * @param projectId
 617      * @param projectVersion
 618      * @throws MetadataRepositoryException
 619      * @since 1.4-M4
 620      */
 621     void removeProjectVersion( RepositorySession session, String repoId, String namespace, String projectId, String projectVersion )
 622         throws MetadataRepositoryException;
 623
 624     /**
 625      *
 626      * @param session
 627      * @param repoId
 628      * @param namespace
 629      * @param projectId
 630      * @param projectVersion
 631      * @return
 632      * @throws MetadataResolutionException
 633      */
 634     Collection<ArtifactMetadata> getArtifacts( RepositorySession session, String repoId, String namespace, String projectId,
 635                                                String projectVersion )
 636         throws MetadataResolutionException;
 637
 638     /**
 639      * remove a project
 640      *
 641      *
 642      * @param session
 643      * @param repositoryId
 644      * @param namespace
 645      * @param projectId
 646      * @throws MetadataRepositoryException
 647      * @since 1.4-M4
 648      */
 649     void removeProject( RepositorySession session, String repositoryId, String namespace, String projectId )
 650         throws MetadataRepositoryException;
 651
 652
 653     void close()
 654         throws MetadataRepositoryException;
 655
 656
 657     boolean canObtainAccess( Class<?> aClass );
 658
 659     <T> T obtainAccess( RepositorySession session,  Class<T> aClass )
 660         throws MetadataRepositoryException;
 661
 662     /**
 663      * Full text artifacts search.
 664      *
 665      *
 666      * @param session
 667      * @param repositoryId can be null to search in all repositories
 668      * @param text
 669      * @param exact running an exact search, the value must exactly match the text.
 670      * @return a list of artifacts
 671      * @throws MetadataRepositoryException
 672      */
 673     List<ArtifactMetadata> searchArtifacts( RepositorySession session, String repositoryId, String text, boolean exact )
 674         throws MetadataRepositoryException;
 675
 676     /**
 677      * Full text artifacts search inside the specified key.
 678      *
 679      *
 680      * @param session
 681      * @param repositoryId can be null to search in all repositories
 682      * @param key search only inside this key
 683      * @param text
 684      * @param exact running an exact search, the value must exactly match the text.
 685      * @return a list of artifacts
 686      * @throws MetadataRepositoryException
 687      */
 688     List<ArtifactMetadata> searchArtifacts( RepositorySession session, String repositoryId, String key, String text, boolean exact )
 689         throws MetadataRepositoryException;
 690
 691 }