Exemplo n.º 1
0
 @Test
 public void testListArchiveContents() throws Exception {
   byte[] archive = createContentArchive();
   try (ByteArrayInputStream stream = new ByteArrayInputStream(archive)) {
     byte[] hash = repository.addContent(stream);
     // hash is different from the simple overlay.xhtml as we add the content folder name in the
     // computation
     assertThat(hash, is(notNullValue()));
     List<String> contents =
         repository
             .listContent(hash, "", ContentFilter.Factory.createContentFilter(-1, false))
             .stream()
             .map(ContentRepositoryElement::getPath)
             .collect(Collectors.toList());
     assertThat(contents.size(), is(5));
     assertThat(
         contents,
         CoreMatchers.hasItems(
             "test.jsp", "overlay.xhtml", "test/empty-file.txt", "test/", "empty-dir/"));
     hash =
         repository.addContentToExploded(
             hash,
             Collections.singletonList(new ExplodedContent("test/empty-file.txt", emptyStream())),
             true);
     hash =
         repository.addContentToExploded(
             hash, Collections.singletonList(new ExplodedContent("empty-dir", null)), true);
     contents =
         repository
             .listContent(hash, "", ContentFilter.Factory.createContentFilter(1, false))
             .stream()
             .map(ContentRepositoryElement::getPath)
             .collect(Collectors.toList());
     assertThat(contents, is(notNullValue()));
     assertThat(contents.size(), is(4));
     assertThat(
         contents, CoreMatchers.hasItems("test.jsp", "overlay.xhtml", "test/", "empty-dir/"));
     contents =
         repository
             .listContent(hash, "", ContentFilter.Factory.createFileFilter(-1, false))
             .stream()
             .map(ContentRepositoryElement::getPath)
             .collect(Collectors.toList());
     assertThat(contents, is(notNullValue()));
     assertThat(contents.size(), is(3));
     assertThat(
         contents, CoreMatchers.hasItems("test.jsp", "overlay.xhtml", "test/empty-file.txt"));
   }
 }
Exemplo n.º 2
0
 /** Test of explodeContent method, of class ContentRepository. */
 @Test
 public void testChangeExplodedContent() throws Exception {
   byte[] archive = createArchive(Collections.singletonList("overlay.xhtml"));
   try (ByteArrayInputStream stream = new ByteArrayInputStream(archive)) {
     byte[] hash = repository.explodeContent(repository.addContent(stream));
     String expResult = "b1f18e286615dda0643633ec31f1a17d90e48875";
     // hash is different from the simple overlay.xhtml as we add the content folder name in the
     // computation
     assertThat(hash, is(notNullValue()));
     Path content = repository.getContent(hash).getPhysicalFile().toPath();
     String contentHtml = readFileContent(content.resolve("overlay.xhtml"));
     String expectedContentHtml = readFileContent(getResourceAsStream("overlay.xhtml"));
     assertThat(contentHtml, is(expectedContentHtml));
     assertThat(HashUtil.bytesToHexString(hash), is(expResult));
     String updatedExpectedResult = "161a2c95b16d5ffede0721c2cec984ca51009082";
     hash =
         repository.addContentToExploded(
             hash,
             Collections.singletonList(
                 new ExplodedContent(
                     "test.jsp",
                     new ByteArrayInputStream("this is a test".getBytes(StandardCharsets.UTF_8)))),
             true);
     assertThat(hash, is(notNullValue()));
     assertThat(HashUtil.bytesToHexString(hash), is(updatedExpectedResult));
     try (InputStream addedContent = repository.readContent(hash, "test.jsp")) {
       assertThat(addedContent, is(notNullValue()));
       assertThat(readFileContent(addedContent), is("this is a test"));
     }
     content = repository.getContent(hash).getPhysicalFile().toPath();
     assertThat(content.toFile().list().length, is(2));
     hash = repository.removeContentFromExploded(hash, Collections.singletonList("test.jsp"));
     assertThat(hash, is(notNullValue()));
     assertThat(HashUtil.bytesToHexString(hash), is(expResult));
     updatedExpectedResult = "a44921155d75009d885db3357005b85b435cf59f";
     hash =
         repository.addContentToExploded(
             hash,
             Collections.singletonList(
                 new ExplodedContent(
                     "test.jsp",
                     new ByteArrayInputStream(
                         "this is an overwrite test".getBytes(StandardCharsets.UTF_8)))),
             true);
     assertThat(hash, is(notNullValue()));
     assertThat(HashUtil.bytesToHexString(hash), is(updatedExpectedResult));
     try (InputStream addedContent = repository.readContent(hash, "test.jsp")) {
       assertThat(addedContent, is(notNullValue()));
       assertThat(readFileContent(addedContent), is("this is an overwrite test"));
     }
     try {
       hash =
           repository.addContentToExploded(
               hash,
               Collections.singletonList(
                   new ExplodedContent(
                       "test.jsp",
                       new ByteArrayInputStream(
                           "this is a failure test".getBytes(StandardCharsets.UTF_8)))),
               false);
       fail("Overwritting shouldn't work");
     } catch (ExplodedContentException ex) {
     }
   }
 }
Exemplo n.º 3
0
 @Test
 public void testListContents() throws Exception {
   byte[] archive = createArchive(Collections.singletonList("overlay.xhtml"));
   try (ByteArrayInputStream stream = new ByteArrayInputStream(archive)) {
     byte[] hash = repository.explodeContent(repository.addContent(stream));
     String expResult = "b1f18e286615dda0643633ec31f1a17d90e48875";
     // hash is different from the simple overlay.xhtml as we add the content folder name in the
     // computation
     assertThat(hash, is(notNullValue()));
     Path content = repository.getContent(hash).getPhysicalFile().toPath();
     String contentHtml = readFileContent(content.resolve("overlay.xhtml"));
     String expectedContentHtml = readFileContent(getResourceAsStream("overlay.xhtml"));
     assertThat(contentHtml, is(expectedContentHtml));
     assertThat(HashUtil.bytesToHexString(hash), is(expResult));
     String updatedExpectedResult = "161a2c95b16d5ffede0721c2cec984ca51009082";
     hash =
         repository.addContentToExploded(
             hash,
             Collections.singletonList(
                 new ExplodedContent(
                     "test.jsp",
                     new ByteArrayInputStream("this is a test".getBytes(StandardCharsets.UTF_8)))),
             true);
     assertThat(hash, is(notNullValue()));
     assertThat(HashUtil.bytesToHexString(hash), is(updatedExpectedResult));
     List<String> contents =
         repository
             .listContent(hash, "", ContentFilter.Factory.createContentFilter(-1, false))
             .stream()
             .map(ContentRepositoryElement::getPath)
             .collect(Collectors.toList());
     assertThat(contents.size(), is(2));
     assertThat(contents, CoreMatchers.hasItems("test.jsp", "overlay.xhtml"));
     hash =
         repository.addContentToExploded(
             hash,
             Collections.singletonList(new ExplodedContent("test/empty-file.txt", emptyStream())),
             true);
     hash =
         repository.addContentToExploded(
             hash, Collections.singletonList(new ExplodedContent("empty-dir", null)), true);
     contents =
         repository
             .listContent(hash, "", ContentFilter.Factory.createContentFilter(-1, false))
             .stream()
             .map(ContentRepositoryElement::getPath)
             .collect(Collectors.toList());
     assertThat(contents, is(notNullValue()));
     assertThat(contents.size(), is(5));
     assertThat(
         contents,
         CoreMatchers.hasItems(
             "test.jsp", "overlay.xhtml", "test/empty-file.txt", "test/", "empty-dir/"));
     hash = repository.removeContentFromExploded(hash, Collections.singletonList("test.jsp"));
     contents =
         repository
             .listContent(hash, "", ContentFilter.Factory.createFileFilter(-1, false))
             .stream()
             .map(ContentRepositoryElement::getPath)
             .collect(Collectors.toList());
     assertThat(contents, is(notNullValue()));
     assertThat(contents.size(), is(2));
     assertThat(contents, CoreMatchers.hasItems("overlay.xhtml", "test/empty-file.txt"));
   }
 }
 @Override
 public void execute(OperationContext context, ModelNode operation)
     throws OperationFailedException {
   if (context.getProcessType() == ProcessType.SELF_CONTAINED) {
     throw ServerLogger.ROOT_LOGGER.cannotAddContentToSelfContainedServer();
   }
   final Resource deploymentResource = context.readResourceForUpdate(PathAddress.EMPTY_ADDRESS);
   ModelNode contentItemNode = getContentItem(deploymentResource);
   // Validate this op is available
   if (!isManaged(contentItemNode)) {
     throw ServerLogger.ROOT_LOGGER.cannotAddContentToUnmanagedDeployment();
   } else if (isArchive(contentItemNode)) {
     throw ServerLogger.ROOT_LOGGER.cannotAddContentToUnexplodedDeployment();
   }
   final String managementName = context.getCurrentAddress().getLastElement().getValue();
   final PathAddress address = PathAddress.pathAddress(DEPLOYMENT, managementName);
   final byte[] oldHash = CONTENT_HASH.resolveModelAttribute(context, contentItemNode).asBytes();
   final boolean overwrite = OVERWRITE.resolveModelAttribute(context, operation).asBoolean(true);
   List<ModelNode> contents = EXPLODED_CONTENT.resolveModelAttribute(context, operation).asList();
   final List<ExplodedContent> addedFiles = new ArrayList<>(contents.size());
   final byte[] newHash;
   if (contents.size() == 1 && contents.get(0).hasDefined(HASH)) {
     newHash =
         DeploymentHandlerUtil.addFromHash(
             contentRepository, contents.get(0), managementName, address, context);
     if (operation.hasDefined(DeploymentAttributes.UPDATED_PATHS.getName())) {
       for (ModelNode addedFile :
           DeploymentAttributes.UPDATED_PATHS.resolveModelAttribute(context, operation).asList()) {
         addedFiles.add(new ExplodedContent(addedFile.asString()));
       }
     }
   } else {
     for (ModelNode content : contents) {
       InputStream in;
       if (DeploymentHandlerUtils.hasValidContentAdditionParameterDefined(content)) {
         in = DeploymentHandlerUtils.getInputStream(context, content);
       } else {
         in = null;
       }
       String path = TARGET_PATH.resolveModelAttribute(context, content).asString();
       addedFiles.add(new ExplodedContent(path, in));
     }
     try {
       newHash = contentRepository.addContentToExploded(oldHash, addedFiles, overwrite);
     } catch (ExplodedContentException e) {
       throw createFailureException(e.toString());
     }
   }
   final List<String> relativePaths =
       addedFiles.stream().map(ExplodedContent::getRelativePath).collect(Collectors.toList());
   contentItemNode.get(CONTENT_HASH.getName()).set(newHash);
   contentItemNode.get(CONTENT_ARCHIVE.getName()).set(false);
   if (!addedFiles.isEmpty()
       && ENABLED.resolveModelAttribute(context, deploymentResource.getModel()).asBoolean()) {
     context.addStep(
         new OperationStepHandler() {
           @Override
           public void execute(OperationContext context, ModelNode operation)
               throws OperationFailedException {
             try {
               ExecutorService executor =
                   (ExecutorService)
                       context
                           .getServiceRegistry(false)
                           .getRequiredService(JBOSS_SERVER_EXECUTOR)
                           .getValue();
               CountDownLatch latch = copy(executor, relativePaths, managementName, newHash);
               if (latch != null) {
                 try {
                   if (!latch.await(60, TimeUnit.SECONDS)) {
                     return;
                   }
                 } catch (InterruptedException e) {
                   Thread.currentThread().interrupt();
                   throw createFailureException(e.toString());
                 }
               }
             } catch (IOException e) {
               throw createFailureException(e.toString());
             }
           }
         },
         OperationContext.Stage.RUNTIME);
   }
   context.completeStep(
       new OperationContext.ResultHandler() {
         @Override
         public void handleResult(
             ResultAction resultAction, OperationContext context, ModelNode operation) {
           if (resultAction == ResultAction.KEEP) {
             if (oldHash != null && (newHash == null || !Arrays.equals(oldHash, newHash))) {
               // The old content is no longer used; clean from repos
               contentRepository.removeContent(
                   ModelContentReference.fromModelAddress(address, oldHash));
             }
             if (newHash != null) {
               contentRepository.addContentReference(
                   ModelContentReference.fromModelAddress(address, newHash));
             }
           } else if (newHash != null && (oldHash == null || !Arrays.equals(oldHash, newHash))) {
             // Due to rollback, the new content isn't used; clean from repos
             contentRepository.removeContent(
                 ModelContentReference.fromModelAddress(address, newHash));
           }
         }
       });
 }