a couple of workarounds to force "offline" behaviour

git-svn-id: https://svn.apache.org/repos/asf/archiva/trunk@645751 13f79535-47bb-0310-9956-ffa450edef68

archiva-cli/pom.xml

       <groupId>org.apache.archiva</groupId>
       <artifactId>archiva-converter</artifactId>
     </dependency>
+    <dependency>
+      <groupId>org.apache.maven.wagon</groupId>
+      <artifactId>wagon-file</artifactId>
+      <version>1.0-beta-2</version>
+    </dependency>
     <dependency>
       <groupId>com.google.code.cli-parser</groupId>
       <artifactId>cli</artifactId>

archiva-cli/src/main/java/org/apache/maven/archiva/cli/ArchivaCli.java

  * under the License.
  */
 
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.net.MalformedURLException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+
 import org.apache.commons.lang.StringUtils;
-import org.apache.maven.archiva.configuration.ArchivaConfiguration;
 import org.apache.maven.archiva.configuration.ManagedRepositoryConfiguration;
 import org.apache.maven.archiva.consumers.ConsumerException;
 import org.apache.maven.archiva.consumers.InvalidRepositoryContentConsumer;
 import org.apache.maven.archiva.repository.RepositoryException;
 import org.apache.maven.archiva.repository.scanner.RepositoryScanStatistics;
 import org.apache.maven.archiva.repository.scanner.RepositoryScanner;
+import org.apache.maven.artifact.manager.WagonManager;
 import org.codehaus.plexus.spring.PlexusClassPathXmlApplicationContext;
 import org.codehaus.plexus.spring.PlexusToSpringUtils;
 
 import com.sampullara.cli.Args;
 import com.sampullara.cli.Argument;
 
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.FileNotFoundException;
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-import java.util.Properties;
-
 /**
  * ArchivaCli
  * 
     }
 
     private void doScan( String path, String[] consumers )
-        throws ConsumerException
+        throws ConsumerException, MalformedURLException
     {
+        // hack around poorly configurable project builder by pointing all repositories back at this location to be self
+        // contained
+        WagonManager wagonManager =
+            (WagonManager) applicationContext.getBean( PlexusToSpringUtils.buildSpringId( WagonManager.class.getName() ) );
+        wagonManager.addMirror( "internal", "*", new File( path ).toURL().toExternalForm() );
+
         ManagedRepositoryConfiguration repo = new ManagedRepositoryConfiguration();
         repo.setId( "cliRepo" );
         repo.setName( "Archiva CLI Provided Repo" );
         }
     }
 
-    @SuppressWarnings("unchecked")
+    @SuppressWarnings( "unchecked" )
     private Map<String, KnownRepositoryContentConsumer> getConsumers()
     {
         return PlexusToSpringUtils.lookupMap( "knownRepositoryContentConsumer", applicationContext );

archiva-modules/archiva-base/archiva-consumers/archiva-dependency-tree-consumer/src/main/java/org/apache/archiva/consumers/dependencytree/DependencyTreeGeneratorConsumer.java

 import java.io.File;
 import java.io.FileWriter;
 import java.io.IOException;
+import java.lang.reflect.Field;
 import java.net.MalformedURLException;
 import java.util.Collections;
+import java.util.HashMap;
 import java.util.List;
 
 import org.apache.commons.io.IOUtils;
 import org.apache.maven.artifact.repository.layout.DefaultRepositoryLayout;
 import org.apache.maven.artifact.resolver.ArtifactCollector;
 import org.apache.maven.artifact.resolver.filter.ArtifactFilter;
+import org.apache.maven.project.DefaultMavenProjectBuilder;
 import org.apache.maven.project.MavenProject;
 import org.apache.maven.project.MavenProjectBuilder;
 import org.apache.maven.project.ProjectBuildingException;
 
     private String repositoryLocation;
 
+    private final DefaultRepositoryLayout layout = new DefaultRepositoryLayout();
+
+    private ArtifactRepository localArtifactRepository;
+
+    private Field rawProjectCacheField;
+
+    private Field processedProjectCacheField;
+
     public String getDescription()
     {
         return "Generate dependency tree metadata for tracking changes across algorithms";
             // This is a bit crappy, it would be better to operate entirely within
             // the base repository, but would need to adjust maven-artifact
             localRepository = new File( System.getProperty( "user.home" ), ".m2/repository" );
+            try
+            {
+                localArtifactRepository =
+                    artifactRepositoryFactory.createArtifactRepository( "local",
+                                                                        localRepository.toURL().toExternalForm(),
+                                                                        layout, null, null );
+            }
+            catch ( MalformedURLException e )
+            {
+                throw new ConsumerException( e.getMessage(), e );
+            }
         }
     }
 
     public void processFile( String path )
         throws ConsumerException
     {
-        DefaultRepositoryLayout layout = new DefaultRepositoryLayout();
-
-        ArtifactRepository localRepository;
         MavenProject project;
         try
         {
-            localRepository =
-                artifactRepositoryFactory.createArtifactRepository( "local",
-                                                                    this.localRepository.toURL().toExternalForm(),
-                                                                    layout, null, null );
+            project = projectBuilder.build( new File( repositoryLocation, path ), localArtifactRepository, null, false );
 
-            project = projectBuilder.build( new File( repositoryLocation, path ), localRepository, null, false );
+            // manually flush out the cache for memory concerns and more accurate building
+            flushProjectCache( projectBuilder );
         }
         catch ( ProjectBuildingException e )
         {
             throw new ConsumerException( e.getMessage(), e );
         }
-        catch ( MalformedURLException e )
-        {
-            throw new ConsumerException( e.getMessage(), e );
-        }
 
         DependencyNode rootNode;
         try
             ArtifactFilter artifactFilter = null;
 
             rootNode =
-                dependencyTreeBuilder.buildDependencyTree( project, localRepository, artifactFactory,
+                dependencyTreeBuilder.buildDependencyTree( project, localArtifactRepository, artifactFactory,
                                                            artifactMetadataSource, artifactFilter, artifactCollector );
         }
         catch ( DependencyTreeBuilderException e )
         }
     }
 
+    private void flushProjectCache( MavenProjectBuilder projectBuilder )
+    {
+        try
+        {
+            if ( rawProjectCacheField == null )
+            {
+                rawProjectCacheField = DefaultMavenProjectBuilder.class.getDeclaredField( "rawProjectCache" );
+                rawProjectCacheField.setAccessible( true );
+            }
+
+            if ( processedProjectCacheField == null )
+            {
+                processedProjectCacheField =
+                    DefaultMavenProjectBuilder.class.getDeclaredField( "processedProjectCache" );
+                processedProjectCacheField.setAccessible( true );
+            }
+
+            rawProjectCacheField.set( projectBuilder, new HashMap() );
+
+            processedProjectCacheField.set( projectBuilder, new HashMap() );
+        }
+        catch ( Exception e )
+        {
+            throw new RuntimeException( e );
+        }
+    }
+
     private static class XmlSerializingDependencyNodeVisitor
         implements DependencyNodeVisitor
     {