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

   1 package org.apache.archiva.repository.mock;
   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.ContentAccessException;
  27 import org.apache.archiva.repository.ContentNotFoundException;
  28 import org.apache.archiva.repository.ManagedRepositoryContent;
  29 import org.apache.archiva.repository.ItemDeleteStatus;
  30 import org.apache.archiva.repository.LayoutException;
  31 import org.apache.archiva.repository.ManagedRepository;
  32 import org.apache.archiva.repository.BaseRepositoryContentLayout;
  33 import org.apache.archiva.repository.ManagedRepositoryContentLayout;
  34 import org.apache.archiva.repository.content.Artifact;
  35 import org.apache.archiva.repository.content.BaseDataItemTypes;
  36 import org.apache.archiva.repository.content.ContentItem;
  37 import org.apache.archiva.repository.content.DataItem;
  38 import org.apache.archiva.repository.content.ItemNotFoundException;
  39 import org.apache.archiva.repository.content.ItemSelector;
  40 import org.apache.archiva.repository.content.Namespace;
  41 import org.apache.archiva.repository.content.Project;
  42 import org.apache.archiva.repository.content.Version;
  43 import org.apache.archiva.repository.content.base.ArchivaContentItem;
  44 import org.apache.archiva.repository.content.base.ArchivaDataItem;
  45 import org.apache.archiva.repository.content.base.ArchivaNamespace;
  46 import org.apache.archiva.repository.content.base.ArchivaProject;
  47 import org.apache.archiva.repository.content.base.ArchivaVersion;
  48 import org.apache.archiva.repository.storage.StorageAsset;
  49 import org.springframework.stereotype.Service;
  50
  51 import java.nio.file.Path;
  52 import java.util.List;
  53 import java.util.function.Consumer;
  54 import java.util.stream.Stream;
  55
  56 /**
  57  * @author Martin Stockhammer <martin_s@apache.org>
  58  */
  59 @Service("managedRepositoryContent#mock")
  60 public class ManagedRepositoryContentMock implements BaseRepositoryContentLayout, ManagedRepositoryContent
  61 {
  62     private ManagedRepository repository;
  63
  64     @Override
  65     public VersionedReference toVersion( String groupId, String artifactId, String version )
  66     {
  67         return null;
  68     }
  69
  70     @Override
  71     public VersionedReference toVersion( ArtifactReference artifactReference )
  72     {
  73         return null;
  74     }
  75
  76     @Override
  77     public void deleteAllItems( ItemSelector selector, Consumer<ItemDeleteStatus> consumer ) throws ContentAccessException, IllegalArgumentException
  78     {
  79
  80     }
  81
  82     @Override
  83     public <T extends ContentItem> T adaptItem( Class<T> clazz, ContentItem item ) throws LayoutException
  84     {
  85         if (clazz.isAssignableFrom( Version.class ))
  86         {
  87             if ( !item.hasCharacteristic( Version.class ) )
  88             {
  89                 item.setCharacteristic( Version.class, createVersionFromPath( item.getAsset() ) );
  90             }
  91             return (T) item.adapt( Version.class );
  92         } else if ( clazz.isAssignableFrom( Project.class )) {
  93             if ( !item.hasCharacteristic( Project.class ) )
  94             {
  95                 item.setCharacteristic( Project.class, createProjectFromPath( item.getAsset() ) );
  96             }
  97             return (T) item.adapt( Project.class );
  98         } else if ( clazz.isAssignableFrom( Namespace.class )) {
  99             if ( !item.hasCharacteristic( Namespace.class ) )
 100             {
 101                 item.setCharacteristic( Namespace.class, createNamespaceFromPath( item.getAsset() ) );
 102             }
 103             return (T) item.adapt( Namespace.class );
 104         }
 105         throw new LayoutException( "Could not convert item to class " + clazz);
 106     }
 107
 108     private Version createVersionFromPath( StorageAsset asset )
 109     {
 110         Project proj = createProjectFromPath( asset.getParent( ) );
 111         return ArchivaVersion.withRepository( this ).withAsset( asset )
 112             .withProject( proj ).withVersion( asset.getName( ) ).build();
 113     }
 114
 115     private Project createProjectFromPath( StorageAsset asset)  {
 116         Namespace ns = createNamespaceFromPath( asset );
 117         return ArchivaProject.withRepository( this ).withAsset( asset )
 118             .withNamespace( ns ).withId( asset.getName( ) ).build( );
 119     }
 120
 121     private Namespace createNamespaceFromPath( StorageAsset asset) {
 122         String namespace = asset.getPath( ).replace( "/", "." );
 123         return ArchivaNamespace.withRepository( this )
 124             .withAsset( asset ).withNamespace( namespace ).build();
 125     }
 126
 127
 128     @Override
 129     public void deleteItem( ContentItem item ) throws ItemNotFoundException, ContentAccessException
 130     {
 131
 132     }
 133
 134     @Override
 135     public ContentItem getItem( ItemSelector selector ) throws ContentAccessException, IllegalArgumentException
 136     {
 137         return null;
 138     }
 139
 140     @Override
 141     public Namespace getNamespace( ItemSelector namespaceSelector ) throws ContentAccessException, IllegalArgumentException
 142     {
 143         return null;
 144     }
 145
 146     @Override
 147     public Project getProject( ItemSelector projectSelector ) throws ContentAccessException, IllegalArgumentException
 148     {
 149         return null;
 150     }
 151
 152
 153     @Override
 154     public void deleteVersion( VersionedReference reference ) throws ContentNotFoundException, ContentAccessException
 155     {
 156
 157     }
 158
 159
 160     @Override
 161     public Version getVersion( ItemSelector versionCoordinates ) throws ContentAccessException, IllegalArgumentException
 162     {
 163         return null;
 164     }
 165
 166     @Override
 167     public void deleteArtifact( ArtifactReference artifactReference ) throws ContentNotFoundException, ContentAccessException
 168     {
 169
 170     }
 171
 172
 173     @Override
 174     public Artifact getArtifact( ItemSelector selector ) throws ContentAccessException
 175     {
 176         return null;
 177     }
 178
 179     @Override
 180     public List<? extends Artifact> getArtifacts( ItemSelector selector ) throws ContentAccessException
 181     {
 182         return null;
 183     }
 184
 185     @Override
 186     public Stream<? extends Artifact> newArtifactStream( ItemSelector selector ) throws ContentAccessException
 187     {
 188         return null;
 189     }
 190
 191     @Override
 192     public Stream<? extends ContentItem> newItemStream( ItemSelector selector, boolean parallel ) throws ContentAccessException, IllegalArgumentException
 193     {
 194         return null;
 195     }
 196
 197     @Override
 198     public List<? extends Project> getProjects( Namespace namespace ) throws ContentAccessException
 199     {
 200         return null;
 201     }
 202
 203     @Override
 204     public List<? extends Project> getProjects( ItemSelector selector ) throws ContentAccessException, IllegalArgumentException
 205     {
 206         return null;
 207     }
 208
 209     @Override
 210     public List<? extends Version> getVersions( Project project ) throws ContentAccessException
 211     {
 212         return null;
 213     }
 214
 215     @Override
 216     public List<? extends Version> getVersions( ItemSelector selector ) throws ContentAccessException, IllegalArgumentException
 217     {
 218         return null;
 219     }
 220
 221     @Override
 222     public List<String> getArtifactVersions( ItemSelector selector ) throws ContentAccessException, IllegalArgumentException
 223     {
 224         return null;
 225     }
 226
 227     @Override
 228     public List<? extends Artifact> getArtifacts( ContentItem item ) throws ContentAccessException
 229     {
 230         return null;
 231     }
 232
 233     @Override
 234     public Stream<? extends Artifact> newArtifactStream( ContentItem item ) throws ContentAccessException
 235     {
 236         return null;
 237     }
 238
 239     @Override
 240     public boolean hasContent( ItemSelector selector )
 241     {
 242         return false;
 243     }
 244
 245     @Override
 246     public ContentItem getParent( ContentItem item )
 247     {
 248         try
 249         {
 250             return toItem( item.getAsset( ).getParent( ) );
 251         }
 252         catch ( LayoutException e )
 253         {
 254             throw new RuntimeException( "Bad layout error " + e.getMessage( ) );
 255         }
 256     }
 257
 258     @Override
 259     public List<? extends ContentItem> getChildren( ContentItem item )
 260     {
 261         return null;
 262     }
 263
 264     @Override
 265     public <T extends ContentItem> T applyCharacteristic( Class<T> clazz, ContentItem item ) throws LayoutException
 266     {
 267         return null;
 268     }
 269
 270     @Override
 271     public <T extends ManagedRepositoryContentLayout> T getLayout( Class<T> clazz ) throws LayoutException
 272     {
 273         return null;
 274     }
 275
 276     @Override
 277     public <T extends ManagedRepositoryContentLayout> boolean supportsLayout( Class<T> clazz )
 278     {
 279         return false;
 280     }
 281
 282     @Override
 283     public void addArtifact( Path sourceFile, Artifact destination ) throws IllegalArgumentException
 284     {
 285
 286     }
 287
 288     @Override
 289     public DataItem getMetadataItem( Version version )
 290     {
 291         return ArchivaDataItem.withAsset( version.getAsset( ).resolve( "maven-metadata.xml" ) ).withId( "maven-metadata.xml" )
 292             .withDataType( BaseDataItemTypes.METADATA ).build();
 293     }
 294
 295     @Override
 296     public DataItem getMetadataItem( Project project )
 297     {
 298         return ArchivaDataItem.withAsset( project.getAsset( ).resolve( "maven-metadata.xml" ) ).withId( "maven-metadata.xml" )
 299             .withDataType( BaseDataItemTypes.METADATA ).build( );
 300     }
 301
 302
 303     @Override
 304     public ContentItem toItem( String path ) throws LayoutException
 305     {
 306         StorageAsset asset = repository.getAsset( "" ).resolve( path );
 307         return toItem( asset );
 308     }
 309
 310     @Override
 311     public ContentItem toItem( StorageAsset asset ) throws LayoutException
 312     {
 313         if (asset.isLeaf()) {
 314             return ArchivaDataItem.withAsset( asset ).withId( asset.getName() ).build();
 315         } else
 316         {
 317             return ArchivaContentItem.withRepository( this )
 318                 .withAsset( asset ).build( );
 319         }
 320     }
 321
 322
 323     @Override
 324     public void deleteGroupId( String groupId ) throws ContentNotFoundException, ContentAccessException
 325     {
 326
 327     }
 328
 329
 330     @Override
 331     public void deleteProject( String namespace, String projectId ) throws ContentNotFoundException, ContentAccessException
 332     {
 333
 334     }
 335
 336     @Override
 337     public void deleteProject( ProjectReference reference ) throws ContentNotFoundException, ContentAccessException
 338     {
 339
 340     }
 341
 342     @Override
 343     public String toPath( ContentItem item )
 344     {
 345         return null;
 346     }
 347
 348     @Override
 349     public String getId( )
 350     {
 351         return null;
 352     }
 353
 354     @Override
 355     public List<ArtifactReference> getRelatedArtifacts( VersionedReference reference ) throws ContentNotFoundException, LayoutException, ContentAccessException
 356     {
 357         return null;
 358     }
 359
 360     @Override
 361     public List<ArtifactReference> getArtifacts( VersionedReference reference ) throws ContentNotFoundException, LayoutException, ContentAccessException
 362     {
 363         return null;
 364     }
 365
 366     @Override
 367     public String getRepoRoot( )
 368     {
 369         return null;
 370     }
 371
 372     @Override
 373     public ManagedRepository getRepository( )
 374     {
 375         return repository;
 376     }
 377
 378     @Override
 379     public boolean hasContent( ArtifactReference reference ) throws ContentAccessException
 380     {
 381         return false;
 382     }
 383
 384     @Override
 385     public boolean hasContent( VersionedReference reference ) throws ContentAccessException
 386     {
 387         return false;
 388     }
 389
 390     @Override
 391     public void setRepository( ManagedRepository repo )
 392     {
 393         this.repository = repo;
 394     }
 395
 396     @Override
 397     public StorageAsset toFile( VersionedReference reference )
 398     {
 399         return null;
 400     }
 401
 402     @Override
 403     public ArtifactReference toArtifactReference( String path ) throws LayoutException
 404     {
 405         return null;
 406     }
 407
 408     @Override
 409     public StorageAsset toFile( ArtifactReference reference )
 410     {
 411         return null;
 412     }
 413
 414     @Override
 415     public StorageAsset toFile( ArchivaArtifact reference )
 416     {
 417         return null;
 418     }
 419
 420     @Override
 421     public String toPath( ArtifactReference reference )
 422     {
 423         return null;
 424     }
 425
 426     @Override
 427     public String toPath( ItemSelector selector )
 428     {
 429         return null;
 430     }
 431
 432     @Override
 433     public ItemSelector toItemSelector( String path ) throws LayoutException
 434     {
 435         return null;
 436     }
 437
 438     @Override
 439     public ManagedRepositoryContent getGenericContent( )
 440     {
 441         return null;
 442     }
 443 }