Fixing proxy connector handling

archiva-modules/archiva-base/archiva-proxy/src/main/java/org/apache/archiva/proxy/ArchivaProxyRegistry.java

 import org.apache.archiva.proxy.model.ProxyConnector;
 import org.apache.archiva.proxy.model.RepositoryProxyHandler;
 import org.apache.archiva.repository.*;
+import org.apache.archiva.repository.events.Event;
+import org.apache.archiva.repository.events.RepositoryEventListener;
+import org.apache.archiva.repository.events.RepositoryRegistryEvent;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.stereotype.Service;
  */
 @SuppressWarnings( "SpringJavaInjectionPointsAutowiringInspection" )
 @Service("proxyRegistry#default")
-public class ArchivaProxyRegistry implements ProxyRegistry, ConfigurationListener {
+public class ArchivaProxyRegistry implements ProxyRegistry, RepositoryEventListener {
 
     private static final Logger log = LoggerFactory.getLogger(ArchivaProxyRegistry.class);
 
         if (repositoryProxyHandlers == null) {
             repositoryProxyHandlers = new ArrayList<>();
         }
-        archivaConfiguration.addListener( this );
         updateHandler();
         updateConnectors();
         updateNetworkProxies();
+        repositoryRegistry.register(this, RepositoryRegistryEvent.RegistryEventType.RELOADED);
     }
 
     private ArchivaConfiguration getArchivaConfiguration() {
             getArchivaConfiguration().getConfiguration().getProxyConnectors();
 
         connectorList = proxyConnectorConfigurations.stream()
-                .map(configuration -> buildProxyConnector(configuration))
+                .map(this::buildProxyConnector)
+                .filter(Optional::isPresent)
+                .map(Optional::get)
                 .sorted(comparator).collect(Collectors.toList());
         connectorMap = connectorList.stream().collect(Collectors.groupingBy(a -> a.getSourceRepository().getId()));
         for (RepositoryProxyHandler handler : repositoryProxyHandlers) {
         return policies.stream().collect( Collectors.toMap( Function.identity(), p -> PolicyUtil.findOption( policyConfig.get(p.getId()), p ) ) );
     }
 
-    private ProxyConnector buildProxyConnector(ProxyConnectorConfiguration configuration) {
+    private Optional<ProxyConnector> buildProxyConnector(ProxyConnectorConfiguration configuration) {
         ProxyConnector proxyConnector = new ProxyConnector();
         proxyConnector.setOrder(configuration.getOrder());
         proxyConnector.setBlacklist(configuration.getBlackListPatterns());
         proxyConnector.setProperties(configuration.getProperties());
         proxyConnector.setProxyId(configuration.getProxyId());
         ManagedRepository srcRepo = repositoryRegistry.getManagedRepository(configuration.getSourceRepoId());
+        if (srcRepo==null) {
+            return Optional.empty();
+        }
         proxyConnector.setSourceRepository(srcRepo);
         RemoteRepository targetRepo = repositoryRegistry.getRemoteRepository(configuration.getTargetRepoId());
+        if (targetRepo==null) {
+            return Optional.empty();
+        }
         proxyConnector.setTargetRepository(targetRepo);
-        return proxyConnector;
+        return Optional.of(proxyConnector);
     }
 
     @Override
         return this.handlerMap.containsKey(type);
     }
 
-    @Override
-    public void configurationEvent(ConfigurationEvent event) {
-        log.debug("Config changed updating proxy list");
-        init( );
-    }
 
     @Override
     public List<ProxyConnector> getProxyConnectors() {
     {
         init();
     }
+
+    @Override
+    public void raise(Event event) {
+        log.debug("Reload happened, updating proxy list");
+        if (event.getType()== RepositoryRegistryEvent.RegistryEventType.RELOADED) {
+            init();
+        }
+    }
 }

archiva-modules/archiva-base/archiva-repository-admin/archiva-repository-admin-default/src/test/java/org/apache/archiva/admin/repository/managed/ManagedRepositoryAdminTest.java

         managedRepositoryAdmin.updateManagedRepository( repo, true, getFakeAuditInformation(), false );
 
         repo = managedRepositoryAdmin.getManagedRepository( repoId );
-        System.err.println("REPOSITORY "+repo.getLocation());
         assertNotNull( repo );
         assertEquals( newName, repo.getName() );
         assertEquals( Paths.get( repoLocation ).toAbsolutePath(), Paths.get( repo.getLocation() ).toAbsolutePath() );

archiva-modules/archiva-maven/archiva-maven-proxy/src/test/java/org/apache/archiva/proxy/HttpProxyTransferTest.java

         // Configure Connector (usually done within archiva.xml configuration)
         addConnector();
 
+        managedDefaultRepository = repositoryRegistry.getManagedRepository(MANAGED_ID).getContent();
+
         Path expectedFile = Paths.get( managedDefaultRepository.getRepoRoot() ).resolve( path );
         Files.deleteIfExists( expectedFile );
         ArtifactReference artifact = managedDefaultRepository.toArtifactReference( path );

archiva-modules/archiva-maven/archiva-maven-repository/src/main/java/org/apache/archiva/dependency/tree/maven2/ArchivaRepositoryConnectorFactory.java

  */
 
 import org.eclipse.aether.connector.basic.BasicRepositoryConnectorFactory;
+import org.eclipse.aether.internal.impl.DefaultRepositoryLayoutProvider;
 import org.eclipse.aether.spi.connector.RepositoryConnectorFactory;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
     public ArchivaRepositoryConnectorFactory()
     {
         // no op but empty constructor needed by aether
+        delegate.setRepositoryLayoutProvider(new DefaultRepositoryLayoutProvider());
     }
 
     @Override

archiva-modules/archiva-maven/archiva-maven-repository/src/main/java/org/apache/archiva/repository/maven2/MavenRepositoryProvider.java

 import org.apache.archiva.common.filelock.FileLockManager;
 import org.apache.archiva.configuration.*;
 import org.apache.archiva.repository.*;
+import org.apache.archiva.repository.events.Event;
+import org.apache.archiva.repository.events.RepositoryValueEvent;
 import org.apache.archiva.repository.storage.FilesystemStorage;
 import org.apache.archiva.repository.features.ArtifactCleanupFeature;
 import org.apache.archiva.repository.features.IndexCreationFeature;
         cfg.setPackedIndexDir(convertUriToPath(indexCreationFeature.getPackedIndexPath()));
 
         RemoteIndexFeature remoteIndexFeature = remoteRepository.getFeature(RemoteIndexFeature.class).get();
-        cfg.setRemoteIndexUrl(remoteIndexFeature.getIndexUri().toString());
+        if (remoteIndexFeature.getIndexUri()!=null) {
+            cfg.setRemoteIndexUrl(remoteIndexFeature.getIndexUri().toString());
+        }
         cfg.setRemoteDownloadTimeout((int) remoteIndexFeature.getDownloadTimeout().get(ChronoUnit.SECONDS));
         cfg.setDownloadRemoteIndexOnStartup(remoteIndexFeature.isDownloadRemoteIndexOnStartup());
         cfg.setDownloadRemoteIndex(remoteIndexFeature.isDownloadRemoteIndex());
     }
 
     @Override
-    public <T> void raise(RepositoryEvent<T> event) {
+    public void raise(Event event) {
         //
     }
 

archiva-modules/archiva-maven/archiva-maven-repository/src/test/java/org/apache/archiva/dependency/tree/maven2/DependencyTreeBuilderTestMaven3.java

         repoConfig.setId( TEST_REPO_ID );
         repoConfig.setLocation(Paths.get("target/test-repository").toAbsolutePath().toString() );
         configuration.addManagedRepository( repoConfig );
+
+        config.getConfiguration().getProxyConnectors().clear();
         config.save( configuration );
 
         repositoryRegistry.reload();