AuthenticationSelector authenticationSelector) {
        injectMirror(mavenExecutionRequest.getRemoteRepositories(), mavenExecutionRequest.getMirrors());
        injectProxy(proxySelector, mavenExecutionRequest.getRemoteRepositories());
        injectAuthentication(authenticationSelector, mavenExecutionRequest.getRemoteRepositories());

     *
     * @param repositories The repositories into which to inject the mirror information, may be {@code null}.
     * @param mirrors The available mirrors, may be {@code null}.
     */
    void injectMirror(List<ArtifactRepository> repositories, List<Mirror> mirrors);

    /**
     * Injects the proxy information into the specified repositories. For each repository that is matched by a proxy,

    }

    @Override
    public void injectMirror(List<ArtifactRepository> repositories, List<Mirror> mirrors) {
        if (repositories != null && mirrors != null) {
            for (ArtifactRepository repository : repositories) {
                Mirror mirror = getMirror(repository, mirrors);
                injectMirror(repository, mirror);
            }
        }
    }

        RepositorySystemSession session = rss(c);

        ArtifactRepository repository = repositorySystem.buildArtifactRepository(repo);

        if (session != null) {
            repositorySystem.injectMirror(session, Arrays.asList(repository));
            repositorySystem.injectProxy(session, Arrays.asList(repository));
            repositorySystem.injectAuthentication(session, Arrays.asList(repository));
        }

    }

    public void injectMirror(List<ArtifactRepository> repositories, List<Mirror> mirrors) {
        if (repositories != null && mirrors != null) {
            for (ArtifactRepository repository : repositories) {
                Mirror mirror = getMirror(repository, mirrors);
                injectMirror(repository, mirror);
            }
        }
    }

        return null;
    }

    @Override
    public void injectAuthentication(List<ArtifactRepository> repositories, List<Server> servers) {}

    @Override
    public void injectMirror(List<ArtifactRepository> repositories, List<Mirror> mirrors) {}

    @Override
    public void injectProxy(List<ArtifactRepository> repositories, List<Proxy> proxies) {}

    @Override
    public void publish(

                throw new IllegalStateException("Unable to lookup " + RepositorySystem.class.getName());
            }

            if (mirrors) {
                repositorySystem.injectMirror(session, repositories);
            }

            repositorySystem.injectProxy(session, repositories);

            repositorySystem.injectAuthentication(session, repositories);
        }

        for (Repository repository : pomRepositories) {
            internalRepositories.add(MavenRepositorySystem.buildArtifactRepository(repository));
        }

        repositorySystem.injectMirror(request.getRepositorySession(), internalRepositories);

        repositorySystem.injectProxy(request.getRepositorySession(), internalRepositories);

                    try {
                        ArtifactRepository repo = repositorySystem.buildArtifactRepository(repositoryInstance);
                        repositorySystem.injectMirror(request.getRepositorySession(), Arrays.asList(repo));
                        repositorySystem.injectProxy(request.getRepositorySession(), Arrays.asList(repo));

            } catch (InvalidRepositoryException e) {
                // cannot use this then
            }
        }
        mavenRepositorySystem.injectMirror(repositorySession, pomRepositories);
        mavenRepositorySystem.injectProxy(repositorySession, pomRepositories);
        mavenRepositorySystem.injectAuthentication(repositorySession, pomRepositories);