How to use

withRemoteRepo

method

in

org.jboss.shrinkwrap.resolver.api.maven.ConfigurableMavenResolverSystem

private ConfigurableMavenResolverSystem getResolver(DeployUnit deployUnit) {
  String offlineProp = System.getProperty("offline", "false");
  boolean offline = Boolean.valueOf(offlineProp);
  ConfigurableMavenResolverSystem resolver = Maven
      .configureResolver()
      .useLegacyLocalRepo(true)
      .workOffline(offline);
  try {
    LogManager.getLogManager().readConfiguration(new FileInputStream(propFile));
  } catch (IOException e) {
    throw new RuntimeException("Unable to read " + propFile.getAbsolutePath());
  }
  // hacky way to treat Maven repositories as I don't want to change the Kevoree MM
  for (Value val : deployUnit.getFilters()) {
    if (val.getName().startsWith("repo_")) {
      try {
        resolver.withRemoteRepo(val.getName().substring(5), new URL(val.getValue()), "default");
      } catch (MalformedURLException e) {
        throw new RuntimeException("Invalid repository URL: " + val.getValue());
      }
    }
  }
  return resolver;
}

.withRemoteRepo(MavenRemoteRepositories.createRemoteRepository("repo" + Math.abs(repo.hashCode()), repo, "default")
    .setUpdatePolicy(MavenUpdatePolicy.UPDATE_POLICY_NEVER));

        "https://oss.sonatype.org/content/repositories/snapshots", "default");
sonatypeSnapshots.setUpdatePolicy(MavenUpdatePolicy.UPDATE_POLICY_DAILY);
resolver = resolver.withRemoteRepo(sonatypeSnapshots);

.withRemoteRepo(jbossPublic);

private void addSpringScannerDependencies() {
  if (springScannerOne) {
    if (debug) {
      log.info("Generating Spring Scanner 1 compatible test plugin");
    }
    final File springScannerAnnotation = Maven.configureResolver()
        .withRemoteRepo(ATLASSIAN_MAVEN)
        .resolve("com.atlassian.plugin:atlassian-spring-scanner-annotation:" + SPRING_SCANNER_1_VERSION)
        .withoutTransitivity()
        .asSingleFile();
    final File springScannerRuntime = Maven.configureResolver()
        .withRemoteRepo(ATLASSIAN_MAVEN)
        .resolve("com.atlassian.plugin:atlassian-spring-scanner-runtime:" + SPRING_SCANNER_1_VERSION)
        .withoutTransitivity()
        .asSingleFile();
    addAsLibrary(springScannerAnnotation);
    addAsLibrary(springScannerRuntime);
  } else if (debug) {
    log.info("Generating Spring Scanner 2+ compatible test plugin");
  }
}

final ConfigurableMavenResolverSystem resolver = Maven.configureResolver()
    .withMavenCentralRepo(true)
    .withRemoteRepo(jbossPublic)
    .withRemoteRepo(gradleTools)
    .workOffline(offline);
        repo.setChecksumPolicy(MavenChecksumPolicy.CHECKSUM_POLICY_IGNORE);
        repo.setUpdatePolicy(MavenUpdatePolicy.UPDATE_POLICY_NEVER);
        resolver.withRemoteRepo(repo);
      });

protected List<JavaArchive> resolveContracts() {
  List<JavaArchive> contracts = new ArrayList<>();
  final ConfigurableMavenResolverSystem configurableMavenResolverSystem = Maven.configureResolver();
  if (!"".equals(contractsMavenDependency.customSettings())) {
    configurableMavenResolverSystem.fromClassloaderResource(
      RunnerExpressionParser.parseExpressions(contractsMavenDependency.customSettings()));
  }
  if (contractsMavenDependency.offline()) {
    configurableMavenResolverSystem.workOffline();
  }
  if (!"".equals(contractsMavenDependency.remoteRepository())) {
    final String[] remoteRepository =
      getRemoteRepository(RunnerExpressionParser.parseExpressions(contractsMavenDependency.remoteRepository()));
    configurableMavenResolverSystem.withRemoteRepo(remoteRepository[NAME], remoteRepository[URL],
      remoteRepository[LAYOUT]);
  }
  String[] coordinates = contractsMavenDependency.value();
  for (String coordinate : coordinates) {
    contracts.add(resolve(RunnerExpressionParser.parseExpressions(coordinate), configurableMavenResolverSystem));
  }
  return contracts;
}

public MavenResolvedArtifact resolveArtifact(String artifact) {
  try {
    /* do offline check first */
    return Maven.configureResolver().workOffline().resolve(artifact).withoutTransitivity().asSingleResolvedArtifact();
  } catch (NoResolvedResultException nre) {
    return Maven
        .configureResolver()
        .withRemoteRepo("Sonatype Nexus Snapshots",
            "https://oss.sonatype.org/content/repositories/snapshots/", "default")
        .resolve(artifact).withoutTransitivity().asSingleResolvedArtifact();
  }
}

public MavenResolvedArtifact[] resolveArtifacts(String artifact) {
  try {
    /* do offline check first */
    return Maven.configureResolver().workOffline().resolve(artifact).withTransitivity().asResolvedArtifact();
  } catch (NoResolvedResultException nre) {
    return Maven
        .configureResolver()
        .withRemoteRepo("Sonatype Nexus Snapshots",
            "https://oss.sonatype.org/content/repositories/snapshots/", "default")
        .resolve(artifact).withTransitivity().asResolvedArtifact();
  }
}

public MavenResolvedArtifact[] resolveArtifacts(String artifact) {
  try {
    /* do offline check first */
    return Maven.configureResolver().workOffline().resolve(artifact).withTransitivity().asResolvedArtifact();
  } catch (NoResolvedResultException nre) {
    return Maven
        .configureResolver()
        .withRemoteRepo("Sonatype Nexus Snapshots",
            "https://oss.sonatype.org/content/repositories/snapshots/", "default")
        .resolve(artifact).withTransitivity().asResolvedArtifact();
  }
}

public MavenResolvedArtifact resolveArtifact(String artifact) {
  try {
    /* do offline check first */
    return Maven.configureResolver().workOffline().resolve(artifact).withoutTransitivity().asSingleResolvedArtifact();
  } catch (NoResolvedResultException nre) {
    return Maven
        .configureResolver()
        .withRemoteRepo("Sonatype Nexus Snapshots",
            "https://oss.sonatype.org/content/repositories/snapshots/", "default")
        .resolve(artifact).withoutTransitivity().asSingleResolvedArtifact();
  }
}

public MavenResolvedArtifact[] resolveArtifacts(String artifact) {
  try {
    /* do offline check first */
    return Maven.configureResolver().workOffline().resolve(artifact).withTransitivity().asResolvedArtifact();
  } catch (NoResolvedResultException nre) {
    return Maven
        .configureResolver()
        .withRemoteRepo("Sonatype Nexus Snapshots",
            "https://oss.sonatype.org/content/repositories/snapshots/", "default")
        .resolve(artifact).withTransitivity().asResolvedArtifact();
  }
}

public MavenResolvedArtifact resolveArtifact(String artifact) {
  try {
    /* do offline check first */
    return Maven.configureResolver().workOffline().resolve(artifact).withoutTransitivity().asSingleResolvedArtifact();
  } catch (NoResolvedResultException nre) {
    return Maven
        .configureResolver()
        .withRemoteRepo("Sonatype Nexus Snapshots",
            "https://oss.sonatype.org/content/repositories/snapshots/", "default")
        .resolve(artifact).withoutTransitivity().asSingleResolvedArtifact();
  }
}

  @Test(expected = NoResolvedResultException.class)
  public void testFailingDependency() throws Exception
  {
    jqmlogger.debug("**********************************************************");
    jqmlogger.debug("Starting test testFailingDependency");

    SLF4JBridgeHandler.install();

    Maven.configureResolver()
        .withRemoteRepo(MavenRemoteRepositories.createRemoteRepository("marsu", "http://marsupilami.com", "default"))
        .withMavenCentralRepo(false).resolve("com.enioka.jqm:marsu:1.1.4").withTransitivity().asFile();
  }
}

.withRemoteRepo(jbossPublic);
    repo.setChecksumPolicy(MavenChecksumPolicy.CHECKSUM_POLICY_IGNORE);
    repo.setUpdatePolicy(MavenUpdatePolicy.UPDATE_POLICY_NEVER);
    resolver.withRemoteRepo(repo);
  });