org.jboss.shrinkwrap.api.importer.ZipImporter Java Examples

protected static WebArchive exampleDeployment(String name, String contextPath, Consumer<WebArchive> additionalResources) throws IOException {
    URL webXML = Paths.get(EXAMPLES_WEB_XML).toUri().toURL();
    String webXmlContent = IOUtils.toString(webXML.openStream(), "UTF-8")
            .replace("%CONTEXT_PATH%", contextPath);
    WebArchive webArchive = ShrinkWrap.create(ZipImporter.class, name + ".war")
            .importFrom(new File(EXAMPLES_HOME + "/" + name + "-" + EXAMPLES_VERSION_SUFFIX + ".war"))
            .as(WebArchive.class)
            .addAsWebInfResource(jbossDeploymentStructure, JBOSS_DEPLOYMENT_STRUCTURE_XML)
            .add(new StringAsset(webXmlContent), "/WEB-INF/web.xml");

    additionalResources.accept(webArchive);

    modifyOIDCAdapterConfig(webArchive);

    return webArchive;
}
 

/**
 * Import from file and make sure the file is closed.
 *
 * @param log  the logger
 * @param set  the dependency set
 * @param jar  the archive
 * @param file the file, must not be {@code null}
 */
private void embedDependency(Log log, DependencySet set, JavaArchive jar, File file) {
    FileInputStream fis = null;
    try {
        fis = new FileInputStream(file);
        jar.as(ZipImporter.class).importFrom(fis, path -> {
            if (jar.contains(path)) {
                log.debug(path.get() + " already embedded in the jar");
                return false;
            }
            if (!toExclude(set, path)) {
                return true;
            } else {
                log.debug("Excluding " + path.get() + " from " + file.getName());
                return false;
            }
        });
    } catch (FileNotFoundException e) {
        throw new RuntimeException("Unable to read the file " + file.getAbsolutePath(), e);
    } finally {
        IOUtils.closeQuietly(fis);
    }
}
 

public void repackageWar(File file) throws IOException {
    if (!filterWebInfLib) {
        return;
    }

    this.log.info("Repackaging .war: " + file);

    Path backupPath = get(file);
    move(file, backupPath, this.log);

    Archive original = ShrinkWrap.create(JavaArchive.class);
    try (InputStream inputStream = Files.newInputStream(backupPath)) {
        original.as(ZipImporter.class).importFrom(inputStream);
    }

    Archive repackaged = new WebInfLibFilteringArchive(original, this.dependencyManager);
    repackaged.as(ZipExporter.class).exportTo(file, true);
    this.log.info("Repackaged .war: " + file);
}
 

protected boolean setupUsingAppPath(Archive<?> archive) throws IOException {
    final String appPath = System.getProperty(APP_PATH);

    if (appPath != null) {
        final Path path = Paths.get(appPath);
        if (Files.isDirectory(path)) {
            Files.walkFileTree(path, new SimpleFileVisitor<Path>() {
                @Override
                public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
                    Path simple = path.relativize(file);
                    archive.add(new FileAsset(file.toFile()), convertSeparators(simple));
                    return super.visitFile(file, attrs);
                }
            });
        } else {
            archive.as(ZipImporter.class)
                    .importFrom(path.toFile());
        }
        return true;
    }

    return false;
}
 

@Override
protected Archive<?> build(TestClass testClass) {

    if (testClass.isAnnotationPresent(File.class)) {
        final File file = testClass.getAnnotation(File.class);
        final String location = file.value();

        java.io.File archiveLocation = new java.io.File(location);
        if (!archiveLocation.isAbsolute()) {
            String rootPath = Paths.get(".").toAbsolutePath().toString();
            archiveLocation = new java.io.File(rootPath, location);
        }

        return ShrinkWrap
            .create(ZipImporter.class, getArchiveName(location))
            .importFrom(archiveLocation)
            .as(file.type());
    }

    return null;
}
 

private void createShrinkWrapDomain() {
    ClassLoader originalCl = Thread.currentThread().getContextClassLoader();
    try {
        if (isFatJar()) {
            Module appModule = Module.getBootModuleLoader().loadModule(APPLICATION_MODULE_NAME);
            Thread.currentThread().setContextClassLoader(appModule.getClassLoader());
        }
        Domain domain = ShrinkWrap.getDefaultDomain();
        domain.getConfiguration().getExtensionLoader().addOverride(ZipExporter.class, ZipExporterImpl.class);
        domain.getConfiguration().getExtensionLoader().addOverride(ZipImporter.class, ZipImporterImpl.class);
        domain.getConfiguration().getExtensionLoader().addOverride(ExplodedExporter.class, ExplodedExporterImpl.class);
        domain.getConfiguration().getExtensionLoader().addOverride(ExplodedImporter.class, ExplodedImporterImpl.class);
        domain.getConfiguration().getExtensionLoader().addOverride(JavaArchive.class, JavaArchiveImpl.class);
        domain.getConfiguration().getExtensionLoader().addOverride(WebArchive.class, WebArchiveImpl.class);
    } catch (Exception e) {
        SwarmMessages.MESSAGES.shrinkwrapDomainSetupFailed(e);
    } finally {
        Thread.currentThread().setContextClassLoader(originalCl);
    }
}
 

/**
 * Import from file and make sure the file is closed.
 *
 * @param log  the logger
 * @param set  the dependency set
 * @param jar  the archive
 * @param file the file, must not be {@code null}
 */
private void embedDependency(Log log, DependencySet set, JavaArchive jar, File file) {
    try (FileInputStream fis = new FileInputStream(file)) {
        jar.as(ZipImporter.class).importFrom(fis, path -> {
            if (jar.contains(path)) {
                log.debug(path.get() + " already embedded in the jar");
                return false;
            }
            if (!toExclude(set, path)) {
                return true;
            } else {
                log.debug("Excluding " + path.get() + " from " + file.getName());
                return false;
            }
        });
    } catch (Exception e) {
        throw new RuntimeException("Unable to read the file " + file.getAbsolutePath(), e);
    }
}
 

protected boolean setupUsingAppPath(Archive<?> archive) throws IOException {
    final String appPath = System.getProperty(BootstrapProperties.APP_PATH);

    if (appPath != null) {
        final Path path = Paths.get(appPath);
        if (Files.isDirectory(path)) {
            Files.walkFileTree(path, new SimpleFileVisitor<Path>() {
                @Override
                public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
                    Path simple = path.relativize(file);
                    archive.add(new FileAsset(file.toFile()), convertSeparators(simple));
                    return super.visitFile(file, attrs);
                }
            });
        } else {
            archive.as(ZipImporter.class)
                    .importFrom(path.toFile());
        }
        return true;
    }

    return false;
}
 

protected static Stream<Archive> archives(Collection<Path> paths) {
    return paths.stream()
            .map(path -> {
                String simpleName = path.getFileName().toString();
                Archive archive = ShrinkWrap.create(JavaArchive.class, simpleName);
                archive.as(ZipImporter.class).importFrom(path.toFile());
                return archive;
            });
}
 

protected static WebArchive exampleDeployment(String name, Consumer<WebArchive> additionalResources) {
    WebArchive webArchive = ShrinkWrap.create(ZipImporter.class, name + ".war")
            .importFrom(new File(EXAMPLES_HOME + "/" + name + "-" + EXAMPLES_VERSION_SUFFIX + ".war"))
            .as(WebArchive.class)
            .addAsWebInfResource(jbossDeploymentStructure, JBOSS_DEPLOYMENT_STRUCTURE_XML);

    additionalResources.accept(webArchive);

    modifyOIDCAdapterConfig(webArchive);

    return webArchive;
}
 

public void deployProviders(@Observes(precedence = -1) AfterStart event) throws DeploymentException {
    if (isAuthServerRemote() && currentContainerName.contains("auth-server")) {
        this.testsuiteProvidersArchive = ShrinkWrap.create(ZipImporter.class, "testsuiteProviders.jar")
                .importFrom(Maven.configureResolverViaPlugin()
                    .resolve("org.keycloak.testsuite:integration-arquillian-testsuite-providers")
                    .withoutTransitivity()
                    .asSingleFile()
                ).as(JavaArchive.class)
                .addAsManifestResource("jboss-deployment-structure.xml");
                
        event.getDeployableContainer().deploy(testsuiteProvidersArchive);
    }
}
 

private File downloadUsingHttp() {
    final String distribution = targetAdapter.distribution();
    final String serverName = new FileNameFromUrlExtractor(distribution).extract();
    final File targetDirectory = new File(new File(distributionDownloadFolder, "server"),
        serverName);

    if (serverAlreadyDownloaded(targetDirectory)) {
        return getDistributionHome(targetDirectory);
    }

    System.out.println("Arquillian Chameleon: downloading distribution from " + distribution);
    final String targetArchive = targetDirectory + "/" + serverName + ".zip";
    final Execution<File> download =
        Spacelift.task(DownloadTool.class).from(distribution).to(targetArchive).execute();
    try {
        while (!download.isFinished()) {
            System.out.print(PROGRESS_INDICATOR);
            Thread.sleep(HALF_A_SECOND);
        }
        System.out.print(PROGRESS_INDICATOR);

        final File compressedServer = download.await();
        ShrinkWrap.create(ZipImporter.class, serverName)
            .importFrom(compressedServer)
            .as(ExplodedExporter.class)
            .exportExploded(targetDirectory, ".");
        compressedServer.delete();
        return getDistributionHome(targetDirectory);
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    }
}
 

protected JavaArchive createBootstrapArchive(String mainClassName, String appArtifact) throws IOException {
    JavaArchive archive = ShrinkWrap.create(JavaArchive.class);
    archive.as(ZipImporter.class).importFrom(new JarFile(findBootstrapJar()));


    Properties props = new Properties();
    if (appArtifact != null) {
        props.put(BootstrapProperties.APP_ARTIFACT, appArtifact);
    }
    ByteArrayOutputStream propsOut = new ByteArrayOutputStream();
    props.store(propsOut, "");
    propsOut.close();
    archive.addAsManifestResource(new ByteArrayAsset(propsOut.toByteArray()), "wildfly-swarm.properties");

    if (appArtifact != null) {
        String conf = "path:" + appArtifact + "\n";
        archive.addAsManifestResource(new ByteArrayAsset(conf.getBytes()), "wildfly-swarm-application.conf");
    }

    if (mainClassName != null) {
        Manifest manifest = new Manifest();
        manifest.getMainAttributes().put(Attributes.Name.MANIFEST_VERSION, "1.0");
        manifest.getMainAttributes().put(new Attributes.Name("Wildfly-Swarm-Main-Class"), mainClassName);

        ByteArrayOutputStream out = new ByteArrayOutputStream();
        manifest.write(out);
        out.close();
        archive.addAsManifestResource(new ByteArrayAsset(out.toByteArray()), "MANIFEST.MF");
    }
    return archive;
}
 

protected boolean setupUsingAppArtifact(Archive<?> archive) throws IOException {
    final String appArtifact = System.getProperty(BootstrapProperties.APP_ARTIFACT);

    if (appArtifact != null) {
        try (InputStream in = ClassLoader.getSystemClassLoader().getResourceAsStream("_bootstrap/" + appArtifact)) {
            archive.as(ZipImporter.class)
                    .importFrom(in);
        }
        return true;
    }

    return false;
}
 

public JavaArchive artifact(String gav, String asName) throws IOException, ModuleLoadException {
    final File file = findFile(gav);

    if (file == null) {
        throw new RuntimeException("Artifact not found.");
    }

    return ShrinkWrap.create(ZipImporter.class, asName == null ? file.getName() : asName)
            .importFrom(file)
            .as(JavaArchive.class);
}
 

@Override
public InputStream openStream() {
    return filter(ShrinkWrap.create(ZipImporter.class)
            .importFrom(this.delegate.openStream())
            .as(JavaArchive.class))
            .as(ZipExporter.class)
            .exportAsInputStream();
}
 

@Override
public List<JavaArchive> allArtifacts(String... groupIdExclusions) throws IOException {
    Map<String, JavaArchive> archives = new HashMap<>();
    Set<String> archivesPaths;

    final List<String> exclusions = Arrays.asList(groupIdExclusions);

    ApplicationEnvironment env = ApplicationEnvironment.get();
    archivesPaths = env.resolveDependencies(exclusions);

    // package the shrinkwrap bits
    for (final String element : archivesPaths) {

        final File artifact = new File(element);

        if (artifact.isFile()) {
            archives.put(artifact.getName(), ShrinkWrap.create(ZipImporter.class, artifact.getName())
                    .importFrom(artifact)
                    .as(JavaArchive.class));
        } else {

            final String archiveName = FileSystemLayout.archiveNameForClassesDir(artifact.toPath());

            // pack resources and classes of the same project into one archive
            if (archives.containsKey(archiveName)) {
                archives.get(archiveName).as(ExplodedImporter.class).importDirectory(artifact);
            } else {
                archives.put(archiveName, ShrinkWrap.create(ExplodedImporter.class, archiveName)
                        .importDirectory(artifact)
                        .as(JavaArchive.class));
            }
        }
    }

    return new ArrayList<>(archives.values());
}
 

public JavaArchive artifact(String gav, String asName) throws IOException, ModuleLoadException {
    final File file = findFile(gav);

    if (file == null) {
        throw SwarmMessages.MESSAGES.artifactNotFound(gav);
    }

    return ShrinkWrap.create(ZipImporter.class, asName == null ? file.getName() : asName)
            .importFrom(file)
            .as(JavaArchive.class);
}
 

protected boolean setupUsingAppArtifact(Archive<?> archive) throws IOException {
    final String appArtifact = System.getProperty(APP_ARTIFACT);

    if (appArtifact != null) {
        try (InputStream in = ClassLoader.getSystemClassLoader().getResourceAsStream("_bootstrap/" + appArtifact)) {
            archive.as(ZipImporter.class)
                    .importFrom(in);
        }
        return true;
    }

    return false;
}
 

private static InputStream getKeycloakJsonFromClasspath(String resourceName) {
    InputStream keycloakJson = Thread.currentThread().getContextClassLoader().getResourceAsStream(resourceName);
    if (keycloakJson == null) {

        String appArtifact = System.getProperty(BootstrapProperties.APP_ARTIFACT);

        if (appArtifact != null) {
            try (InputStream in = loadAppArtifact(appArtifact)) {
                Archive<?> tmpArchive = ShrinkWrap.create(JARArchive.class);
                tmpArchive.as(ZipImporter.class).importFrom(in);
                Node jsonNode = tmpArchive.get(resourceName);
                if (jsonNode == null) {
                    jsonNode = getKeycloakJsonNodeFromWebInf(tmpArchive, resourceName, true);
                }
                if (jsonNode == null) {
                    jsonNode = getKeycloakJsonNodeFromWebInf(tmpArchive, resourceName, false);
                }
                if (jsonNode != null && jsonNode.getAsset() != null) {
                    keycloakJson = jsonNode.getAsset().openStream();
                }
            } catch (IOException e) {
                // ignore
            }
        }
    }
    return keycloakJson;
}
 

/**
 * Indexes the given archive.
 * 
 * @param config
 * @param indexer
 * @param archive
 */
private static void indexArchive(OpenApiConfig config, Indexer indexer, Archive<?> archive) {
    FilteredIndexView filter = new FilteredIndexView(null, config);
    Map<ArchivePath, Node> c = archive.getContent();
    try {
        for (Map.Entry<ArchivePath, Node> each : c.entrySet()) {
            ArchivePath archivePath = each.getKey();
            if (archivePath.get().endsWith(OpenApiConstants.CLASS_SUFFIX)
                    && acceptClassForScanning(filter, archivePath.get())) {
                try (InputStream contentStream = each.getValue().getAsset().openStream()) {
                    TckLogging.log.indexing(archivePath.get(), archive.getName());
                    indexer.index(contentStream);
                }
                continue;
            }
            if (archivePath.get().endsWith(OpenApiConstants.JAR_SUFFIX)
                    && acceptJarForScanning(config, archivePath.get())) {
                try (InputStream contentStream = each.getValue().getAsset().openStream()) {
                    JavaArchive jarArchive = ShrinkWrap.create(JavaArchive.class, archivePath.get())
                            .as(ZipImporter.class).importFrom(contentStream).as(JavaArchive.class);
                    indexArchive(config, indexer, jarArchive);
                }
                continue;
            }
        }
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}
 

private Archive<?> runBuild(GradleBuild conf) {
  	
  	ProjectConnection projectConnector = GradleConnector
  		.newConnector()
  		.forProjectDirectory(new File(conf.path()))
  		.connect();
  	
  	BuildLauncher launcher = projectConnector
  		.newBuild()
  		.forTasks(conf.tasks())
  		.withArguments("-x", "test");
  	
  	if (!conf.quiet()) {
   	launcher.withArguments("--info", "--stacktrace");
   	launcher.setStandardOutput(System.out);
       launcher.setStandardError(System.err);
  	}
  	launcher.run();
  	
  	GradleProject projectModel = projectConnector.getModel(GradleProject.class);
final Path artifactDir = projectModel.getBuildDirectory().toPath().resolve("libs");

Path artifactPath = null;
try (DirectoryStream<Path> filesInArtifactDir = Files.newDirectoryStream(artifactDir)) {
	for (Path file : filesInArtifactDir) {
              if (file.toString().endsWith(".war")) {
              	artifactPath = file;
              	break;
              }
          }
} catch (Exception e) {
	throw new RuntimeException(e);
}
	
if (artifactPath == null) {
	throw new RuntimeException("No .war-file found in " + artifactDir.toString() + ".");
}

return ShrinkWrap
		  .create(ZipImporter.class, artifactPath.getFileName().toString())
		  .importFrom(artifactPath.toFile())
		  .as(WebArchive.class);

  }
 

@Produces
public Archive swaggerWebApp() throws ModuleLoadException, IOException {

    // Load the swagger-ui webjars.
    Module module = Module.getBootModuleLoader().loadModule("org.webjars.swagger-ui");
    URL resource = module.getExportedResource("swagger-ui.jar");
    JARArchive webJar = ShrinkWrap.create(JARArchive.class);
    webJar.as(ZipImporter.class).importFrom(resource.openStream());


    JARArchive relocatedJar = ShrinkWrap.create(JARArchive.class);

    Map<ArchivePath, Node> content = webJar.getContent();

    // relocate out the webjars/swagger-ui/${VERISON}

    for (ArchivePath path : content.keySet()) {
        Node node = content.get(path);
        Asset asset = node.getAsset();
        if (asset != null) {
            Matcher matcher = PATTERN.matcher(path.get());
            if (matcher.matches()) {
                MatchResult result = matcher.toMatchResult();
                String newPath = "/META-INF/resources/" + result.group(2);
                relocatedJar.add(asset, newPath);
            }
        }
    }

    WARArchive war = ShrinkWrap.create(WARArchive.class, "swagger-ui.war")
            .addAsLibrary(relocatedJar)
            .setContextRoot(this.fraction.getContext());
    war.addClass(SwaggerDefaultUrlChangerServlet.class);

    // If any user content has been provided, merge that with the swagger-ui bits
    Archive<?> userContent = this.fraction.getWebContent();
    if (userContent != null) {
        war.merge(userContent);
    }

    return war;
}
 

/**
 * Helper method that gets and imports a ZipFileEntry resource from a ShrinkWrapResource as
 * another ShrinkWrapResource.
 * 
 * @param resource the ShrinkWrapResource used as the source
 * @param location the location of the target resource within the resource
 * @return a ShrinkWrapResource version of the target resource
 */
private ShrinkWrapResource importAsShrinkWrapResource(ShrinkWrapResource resource, String location) {
    return new ShrinkWrapResource(
        ShrinkWrap.create(ZipImporter.class, location.substring(1))
                  .importFrom(
                      resource.getResourceAsStreamByLocation(location))
                  .as(JavaArchive.class));
}