private void writeScenarios(Domain domain, List<Contingency> contingencies, OutputStream os) throws IOException { GenericArchive archive = new EurostagScenario(parameters, config).writeFaultSeqArchive(domain, contingencies, network, dictionary, faultNum -> FAULT_SEQ_FILE_NAME.replace(CommandConstants.EXECUTION_NUMBER_PATTERN, Integer.toString(faultNum))); archive.as(ZipExporter.class).exportTo(os); }
Builder addArchive(Archive<?> archive) { this.archive.add(archive, ROOT_ARCHIVE_PATH, ZipExporter.class); return this; }
private void writeDtaAndControls(Domain domain, OutputStream ddbOs, OutputStream dictGensOs) throws IOException { GenericArchive archive = domain.getArchiveFactory().create(GenericArchive.class); try (FileSystem fileSystem = ShrinkWrapFileSystems.newFileSystem(archive)) { Path rootDir = fileSystem.getPath("/"); ddbClient.dumpDtaFile(rootDir, DTA_FILE_NAME, network, parallelIndexes.toMap(), EurostagUtil.VERSION, dictionary.toMap(), parameters); } archive.as(ZipExporter.class).exportTo(ddbOs); //put just the generators dict csv file (extracted from the ddb files) in the common files set, to be used by wp43 transient stability index if (archive.get(DDB_DICT_GENS_CSV) != null) { ByteStreams.copy(archive.get(DDB_DICT_GENS_CSV).getAsset().openStream(), dictGensOs); } else { LOGGER.warn(DDB_DICT_GENS_CSV + " is missing in the dynamic data files set: some security indexers (e.g. transient stability) need this file"); } }
/** * Create CLI archive for deployment testing * * @param archiveName Name of archive * @param content Content in archive file deploy.scr * @return Return created {@link File} instance */ public static File createCliArchive(String archiveName, String content) { final GenericArchive cliArchive = ShrinkWrap.create(GenericArchive.class, archiveName); cliArchive.add(new StringAsset(content), "deploy.scr"); final String tempDir = TestSuiteEnvironment.getTmpDir(); final File file = new File(tempDir, cliArchive.getName()); cliArchive.as(ZipExporter.class).exportTo(file, true); return file; }
public static Payload tarredDockerfile() throws IOException { ByteArrayOutputStream bytes = new ByteArrayOutputStream(); ShrinkWrap.create(GenericArchive.class, "archive.tar") .add(new ClassLoaderAsset("Dockerfile"), "Dockerfile") .as(TarExporter.class).exportTo(bytes); return Payloads.newByteArrayPayload(bytes.toByteArray()); } }
@Test public void testImportArchiveAsTypeFromFilterUsingDefaultFormat() throws Exception { String resourcePath = "/test/cl-test.jar"; GenericArchive archive = ShrinkWrap.create(GenericArchive.class).add( new FileAsset(TestIOUtil.createFileFromResourceName("cl-test.jar")), resourcePath); Collection<JavaArchive> jars = archive.getAsType(JavaArchive.class, Filters.include(".*jar")); Assert.assertEquals("Unexpected result found", 1, jars.size()); JavaArchive jar = jars.iterator().next().add(new StringAsset("test file content"), "test.txt"); Assert.assertEquals("JAR imported with wrong name", resourcePath, jar.getName()); Assert.assertNotNull("Class in JAR not imported", jar.get("test/classloader/DummyClass.class")); Assert.assertNotNull("Inner Class in JAR not imported", jar.get("test/classloader/DummyClass$DummyInnerClass.class")); Assert.assertNotNull("Should contain a new asset", ((ArchiveAsset) archive.get(resourcePath).getAsset()) .getArchive().get("test.txt")); }
@Override public void inboundBufferUpdated(final ChannelHandlerContext ctx, final ByteBuf in) throws Exception { if (log.isLoggable(Level.FINEST)) { log.finest("Using the " + this.getClass().getSimpleName()); } try { // Read in the archive using the isolated CL context of this domain final InputStream instream = new ByteBufInputStream(in); final GenericArchive archive = NettyServer.this.getShrinkwrapDomain().getArchiveFactory() .create(ZipImporter.class).importFrom(instream).as(GenericArchive.class); instream.close(); if (log.isLoggable(Level.FINEST)) { log.finest("Got archive: " + archive.toString(true)); } // Store the archive final String id = archive.getId(); NettyServer.this.getDeployedArchives().put(id, archive); // Tell the client OK, and let it know the ID of the archive (so it may be undeployed) final ByteBuf out = ctx.nextOutboundByteBuffer(); NettyServer.sendResponse(ctx, out, WireProtocol.RESPONSE_OK_PREFIX + WireProtocol.COMMAND_DEPLOY_PREFIX + id); } finally { NettyServer.this.resetPipeline(ctx.pipeline()); } } }
/** * Ensure we can get a added Archive as a specific type * * @throws Exception */ @Test public void testGetAsTypeWithFilter() throws Exception { GenericArchive child1 = ShrinkWrap.create(GenericArchive.class); GenericArchive child2 = ShrinkWrap.create(GenericArchive.class); // Create one not to be found by filter. GenericArchive child3 = ShrinkWrap.create(GenericArchive.class, "SHOULD_NOT_BE_FOUND.xxx"); Archive<?> archive = getArchive().add(child1, "/", ZipExporter.class).add(child2, "/", ZipExporter.class) .add(child3, "/", ZipExporter.class); Collection<GenericArchive> matches = archive.getAsType(GenericArchive.class, Filters.include(".*\\.jar")); Assert.assertNotNull(matches); Assert.assertEquals("Two archives should be found", 2, matches.size()); for (GenericArchive match : matches) { if (!match.getName().equals(child1.getName()) && !match.getName().equals(child2.getName())) { Assert.fail("Wrong archive found, " + match.getName() + ". Expected " + child1.getName() + " or " + child2.getName()); } } }
/** * Test to ensure that the export process accepts an archive with only directories, no assets. * * @throws Exception */ @Test public void testExportArchiveWithOnlyDirectories() throws IOException { // Create an archive with directories final ArchivePath path = ArchivePaths.create("/test/game"); final Archive<?> archive = ShrinkWrap.create(JavaArchive.class, NAME_ARCHIVE).addAsDirectories(path); // Fully export by reading all content (export is on-demand) final InputStream content = this.exportAsInputStream(archive); final ByteArrayOutputStream exportedContents = new ByteArrayOutputStream(); IOUtil.copyWithClose(content, exportedContents); final GenericArchive roundtrip = ShrinkWrap.create(this.getImporterClass(), "roundtrip.zip") .importFrom(new ByteArrayInputStream(exportedContents.toByteArray())).as(GenericArchive.class); log.info(roundtrip.toString(true)); Assert.assertTrue(roundtrip.contains(path)); }
@Test public void getRootUri() { final GenericArchive archive = ShrinkWrap.create(GenericArchive.class); final URI uri = ShrinkWrapFileSystems.getRootUri(archive); final String expected = "shrinkwrap://" + archive.getId() + "/"; Assert.assertEquals("Root URI is not as expected", expected, uri.toString()); }
/** * Ensures that an import of {@link InputStream} results in {@link ArchiveImportException} if an unexpected error * occurred. * * @throws Exception */ @Test(expected = ArchiveImportException.class) public void shouldThrowExceptionOnErrorInImportFromStream() throws Exception { final InputStream exceptionIn = this.getExceptionThrowingInputStream(); // Get the importer final Class<T> importerClass = this.getImporterClass(); assert importerClass != null : "Importer class must be specified by implementations"; final T importer = ShrinkWrap.create(importerClass, "test.jar"); try { final GenericArchive archive = importer.importFrom(exceptionIn).as(GenericArchive.class); log.info("Imported: " + archive.toString(true)); } finally { exceptionIn.close(); } }
@Override @BeforeClass(groups = "live") public void setup() { super.setup(); for (String regionId : regions) { boolean created = getApi().getContainerApi(regionId).create(containerName); if (!created) { deleteAllObjectsInContainer(regionId, containerName); } } GenericArchive files = ShrinkWrap.create(GenericArchive.class, "files.tar.gz"); StringAsset content = new StringAsset("foo"); for (int i = 0; i < OBJECT_COUNT; i++) { paths.add(containerName + "/file" + i); files.add(content, "/file" + i); } try { tarGz = ByteStreams2.toByteArrayAndClose(files.as(TarGzExporter.class).exportAsInputStream()); } catch (IOException e) { throw Throwables.propagate(e); } }
@Test public void testImportArchiveAsTypeFromFilter() throws Exception { String resourcePath = "/test/cl-test.jar"; GenericArchive archive = ShrinkWrap.create(GenericArchive.class).add( new FileAsset(TestIOUtil.createFileFromResourceName("cl-test.jar")), resourcePath); Collection<JavaArchive> jars = archive .getAsType(JavaArchive.class, Filters.include(".*jar"), ArchiveFormat.ZIP); Assert.assertEquals("Unexpected result found", 1, jars.size()); JavaArchive jar = jars.iterator().next().add(new StringAsset("test file content"), "test.txt"); Assert.assertEquals("JAR imported with wrong name", resourcePath, jar.getName()); Assert.assertNotNull("Class in JAR not imported", jar.get("test/classloader/DummyClass.class")); Assert.assertNotNull("Inner Class in JAR not imported", jar.get("test/classloader/DummyClass$DummyInnerClass.class")); Assert.assertNotNull("Should contain a new asset", ((ArchiveAsset) archive.get(resourcePath).getAsset()) .getArchive().get("test.txt")); }
/** * SHRINKWRAP-259 */ @Test public void createZipImporter() { final GenericArchive importer = ShrinkWrap.create(ZipImporter.class).as(GenericArchive.class); Assert.assertTrue("Archive did not have expected suffix", importer.getName().endsWith(".jar")); } }
private Builder add(final Archive<?> webArchive, final File dir, final String root) { if (dir == null || !dir.exists()) { return this; } final KnownResourcesFilter filter = new KnownResourcesFilter(dir, root, this.filter); filter.update( webArchive.merge( ShrinkWrap.create(GenericArchive.class).as(ExplodedImporter.class) .importDirectory(dir).as(GenericArchive.class), root, filter)); return this; } }
public Builder addResource(Asset resource, String target) { archive.add(resource, target); return this; }
@Test public void testImportArchiveAsTypeFromString() throws Exception { String resourcePath = "/test/cl-test.jar"; GenericArchive archive = ShrinkWrap.create(GenericArchive.class).add( new FileAsset(TestIOUtil.createFileFromResourceName("cl-test.jar")), resourcePath); JavaArchive jar = archive.getAsType(JavaArchive.class, resourcePath, ArchiveFormat.ZIP).add( new StringAsset("test file content"), "test.txt"); Assert.assertEquals("JAR imported with wrong name", resourcePath, jar.getName()); Assert.assertNotNull("Class in JAR not imported", jar.get("test/classloader/DummyClass.class")); Assert.assertNotNull("Inner Class in JAR not imported", jar.get("test/classloader/DummyClass$DummyInnerClass.class")); Assert.assertNotNull("Should contain a new asset", ((ArchiveAsset) archive.get(resourcePath).getAsset()) .getArchive().get("test.txt")); }
/** * Ensure we can get a added Archive as a specific type * * @throws Exception */ @Test public void testGetAsTypeString() throws Exception { Archive<?> archive = getArchive(); GenericArchive child = ShrinkWrap.create(GenericArchive.class); archive.add(child, "/", ZipExporter.class); GenericArchive found = archive.getAsType(GenericArchive.class, child.getName()); Assert.assertNotNull(found); }