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