SWARM-612: jboss-cli reload results in 404 / no deployment

core/container/pom.xml

@@ -139,6 +139,11 @@
       <artifactId>wildfly-logging</artifactId>
       <scope>provided</scope>
     </dependency>
+    <dependency>
+      <groupId>org.wildfly.core</groupId>
+      <artifactId>wildfly-controller</artifactId>
+      <scope>provided</scope>
+    </dependency>
 
     <dependency>
       <groupId>org.wildfly.core</groupId>

core/container/src/main/java/org/wildfly/swarm/container/internal/Deployer.java

@@ -18,6 +18,7 @@
 import java.nio.file.Path;
 import java.util.Collection;
 
+import org.jboss.dmr.ModelNode;
 import org.jboss.shrinkwrap.api.Archive;
 import org.wildfly.swarm.container.DeploymentException;
 

core/container/src/main/java/org/wildfly/swarm/container/runtime/RuntimeDeployer.java

@@ -73,10 +73,12 @@
 import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.OP;
 import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.OPERATION_HEADERS;
 import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.OP_ADDR;
+import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.PERSISTENT;
 import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.RUNTIME_NAME;
 
 /**
  * @author Bob McWhirter
+ * @author Heiko Braun
  */
 @Singleton
 public class RuntimeDeployer implements Deployer {
@@ -250,6 +252,7 @@ public void deploy(Archive<?> deployment) throws DeploymentException {
         deploymentAdd.get(OP_ADDR).set("deployment", deployment.getName());
         deploymentAdd.get(RUNTIME_NAME).set(deployment.getName());
         deploymentAdd.get(ENABLED).set(true);
+        deploymentAdd.get(PERSISTENT).set(true);
 
         int deploymentTimeout = Integer.getInteger(SwarmProperties.DEPLOYMENT_TIMEOUT, 300);
 

core/container/src/main/java/org/wildfly/swarm/container/runtime/RuntimeServer.java

@@ -15,11 +15,13 @@
  */
 package org.wildfly.swarm.container.runtime;
 
+import java.io.File;
+import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.UUID;
-import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.Executor;
+import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 
 import javax.enterprise.context.ApplicationScoped;
@@ -31,7 +33,10 @@
 
 import org.jboss.as.controller.ModelController;
 import org.jboss.as.controller.client.ModelControllerClient;
+import org.jboss.as.controller.persistence.ExtensibleConfigurationPersister;
+import org.jboss.as.server.Bootstrap;
 import org.jboss.as.server.SelfContainedContainer;
+import org.jboss.as.server.ServerEnvironment;
 import org.jboss.as.server.Services;
 import org.jboss.dmr.ModelNode;
 import org.jboss.msc.service.ServiceActivator;
@@ -43,12 +48,15 @@
 import org.jboss.msc.value.ImmediateValue;
 import org.jboss.shrinkwrap.api.Archive;
 import org.wildfly.swarm.bootstrap.logging.BootstrapLogger;
+import org.wildfly.swarm.bootstrap.util.TempFileManager;
 import org.wildfly.swarm.container.internal.Deployer;
 import org.wildfly.swarm.container.internal.Server;
 import org.wildfly.swarm.container.runtime.deployments.DefaultDeploymentCreator;
 import org.wildfly.swarm.container.runtime.marshal.DMRMarshaller;
 import org.wildfly.swarm.container.runtime.wildfly.SimpleContentProvider;
 import org.wildfly.swarm.container.runtime.wildfly.UUIDFactory;
+import org.wildfly.swarm.container.runtime.xmlconfig.BootstrapConfiguration;
+import org.wildfly.swarm.container.runtime.xmlconfig.BootstrapPersister;
 import org.wildfly.swarm.internal.SwarmMessages;
 import org.wildfly.swarm.spi.api.Customizer;
 import org.wildfly.swarm.spi.api.StageConfig;
@@ -100,7 +108,7 @@ public class RuntimeServer implements Server {
 
     public RuntimeServer() {
         Runtime.getRuntime().addShutdownHook(new Thread(() -> {
-            if(serviceContainer!=null) {
+            if(container!=null) {
                 try {
                     LOG.info("Shutdown requested ...");
                     stop();
@@ -122,6 +130,24 @@ public Deployer start(boolean eagerOpen) throws Exception {
         UUID uuid = UUIDFactory.getUUID();
         System.setProperty("jboss.server.management.uuid", uuid.toString());
 
+        File configurationFile;
+        try {
+            configurationFile = TempFileManager.INSTANCE.newTempFile("swarm-config-", ".xml");
+            LOG.debug("Temporarily storing configuration at: "+ configurationFile.getAbsolutePath());
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+
+        List<ModelNode> bootstrapOperations = new ArrayList<>();
+        BootstrapConfiguration bootstrapConfiguration = () -> bootstrapOperations;
+
+        this.container = new SelfContainedContainer(new Bootstrap.ConfigurationPersisterFactory() {
+            @Override
+            public ExtensibleConfigurationPersister createConfigurationPersister(ServerEnvironment serverEnvironment, ExecutorService executorService) {
+                return new BootstrapPersister(bootstrapConfiguration, configurationFile);
+            }
+        });
+
         for (Customizer each : this.preCustomizers) {
             SwarmMessages.MESSAGES.callingPreCustomizer(each);
             each.customize();
@@ -132,7 +158,7 @@ public Deployer start(boolean eagerOpen) throws Exception {
             each.customize();
         }
 
-        List<ModelNode> bootstrapOperations = new ArrayList<>();
+
         this.dmrMarshaller.marshal(bootstrapOperations);
 
         SwarmMessages.MESSAGES.wildflyBootstrap(bootstrapOperations.toString());
@@ -143,23 +169,23 @@ public Deployer start(boolean eagerOpen) throws Exception {
 
         this.serviceActivators.forEach(activators::add);
 
-        this.serviceContainer = this.container.start(bootstrapOperations, this.contentProvider, activators);
-        for (ServiceName serviceName : this.serviceContainer.getServiceNames()) {
-            ServiceController<?> serviceController = this.serviceContainer.getService(serviceName);
+        final ServiceContainer serviceContainer = this.container.start(bootstrapOperations, this.contentProvider, activators);
+        for (ServiceName serviceName : serviceContainer.getServiceNames()) {
+            ServiceController<?> serviceController = serviceContainer.getService(serviceName);
             StartException exception = serviceController.getStartException();
             if (exception != null) {
                 throw exception;
             }
         }
 
-        ModelController controller = (ModelController) this.serviceContainer.getService(Services.JBOSS_SERVER_CONTROLLER).getValue();
+        ModelController controller = (ModelController) serviceContainer.getService(Services.JBOSS_SERVER_CONTROLLER).getValue();
         Executor executor = Executors.newSingleThreadExecutor();
 
         this.client = controller.createClient(executor);
 
         RuntimeDeployer deployer = this.deployer.get();
 
-        this.serviceContainer.addService(ServiceName.of("swarm", "deployer"), new ValueService<>(new ImmediateValue<Deployer>(deployer))).install();
+        serviceContainer.addService(ServiceName.of("swarm", "deployer"), new ValueService<>(new ImmediateValue<Deployer>(deployer))).install();
 
         configureUserSpaceExtensions();
 
@@ -181,13 +207,8 @@ private void configureUserSpaceExtensions() {
     }
 
     public void stop() throws Exception {
-        final CountDownLatch latch = new CountDownLatch(1);
-        this.serviceContainer.addTerminateListener(info -> latch.countDown());
-        this.serviceContainer.shutdown();
 
-        latch.await();
-
-        this.serviceContainer = null;
+        this.container.stop();
         this.client = null;
         this.deployer = null;
     }
@@ -197,9 +218,7 @@ public Deployer deployer() {
         return this.deployer.get();
     }
 
-    private SelfContainedContainer container = new SelfContainedContainer();
-
-    private ServiceContainer serviceContainer;
+    private SelfContainedContainer container;
 
     private ModelControllerClient client;
 

core/container/src/main/java/org/wildfly/swarm/container/runtime/xmlconfig/BootstrapConfiguration.java

@@ -0,0 +1,13 @@
+package org.wildfly.swarm.container.runtime.xmlconfig;
+
+import java.util.List;
+
+import org.jboss.dmr.ModelNode;
+
+/**
+ * @author Heiko Braun
+ * @since 14/09/16
+ */
+public interface BootstrapConfiguration {
+    List<ModelNode> get();
+}

core/container/src/main/java/org/wildfly/swarm/container/runtime/xmlconfig/BootstrapPersister.java

@@ -0,0 +1,112 @@
+package org.wildfly.swarm.container.runtime.xmlconfig;
+
+import java.io.File;
+import java.io.OutputStream;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.Executors;
+
+import javax.xml.namespace.QName;
+
+import org.jboss.as.controller.PathAddress;
+import org.jboss.as.controller.ProcessType;
+import org.jboss.as.controller.RunningMode;
+import org.jboss.as.controller.RunningModeControl;
+import org.jboss.as.controller.extension.ExtensionRegistry;
+import org.jboss.as.controller.parsing.Namespace;
+import org.jboss.as.controller.persistence.ConfigurationPersistenceException;
+import org.jboss.as.controller.persistence.ConfigurationPersister;
+import org.jboss.as.controller.persistence.ExtensibleConfigurationPersister;
+import org.jboss.as.controller.persistence.SubsystemMarshallingContext;
+import org.jboss.as.controller.persistence.XmlConfigurationPersister;
+import org.jboss.as.server.parsing.StandaloneXml;
+import org.jboss.dmr.ModelNode;
+import org.jboss.modules.Module;
+import org.jboss.staxmapper.XMLElementWriter;
+
+/**
+ * Bootstrap from a precomputed set of operations and then switch to an XML based storage model.
+ * In the later stages the XML config will be store in the java.io.tmpdir as <code>swarm-config-UUID.xml</code>.
+ * This step leverages the default Wildfly components for persistence, in particular the {@link XmlConfigurationPersister}
+ *
+ * @author Heiko Braun
+ * @since 14/09/16
+ *
+ */
+public class BootstrapPersister implements ExtensibleConfigurationPersister {
+
+    private final File configurationFile;
+
+    private final XmlConfigurationPersister delegate;
+
+    private BootstrapConfiguration bootstrapConfig;
+
+    public BootstrapPersister(BootstrapConfiguration bootstrapConfig, File configurationFile) {
+        this.bootstrapConfig = bootstrapConfig;
+        this.configurationFile = configurationFile;
+        this.delegate = createDelegate(configurationFile);
+    }
+
+    @Override
+    public PersistenceResource store(ModelNode model, Set<PathAddress> affectedAddresses) throws ConfigurationPersistenceException {
+        return delegate.store(model, affectedAddresses);
+    }
+
+    @Override
+    public void marshallAsXml(ModelNode model, OutputStream output) throws ConfigurationPersistenceException {
+        delegate.marshallAsXml(model, output);
+    }
+
+    @Override
+    public List<ModelNode> load() throws ConfigurationPersistenceException {
+        if(!configurationFile.exists()) {
+            return bootstrapConfig.get();
+        } else {
+            return delegate.load();
+        }
+    }
+
+    @Override
+    public void successfulBoot() throws ConfigurationPersistenceException {
+
+    }
+
+    @Override
+    public String snapshot() throws ConfigurationPersistenceException {
+        return null;
+    }
+
+    @Override
+    public SnapshotInfo listSnapshots() {
+        return ConfigurationPersister.NULL_SNAPSHOT_INFO;
+    }
+
+    @Override
+    public void deleteSnapshot(String name) {
+
+    }
+
+    @Override
+    public void registerSubsystemWriter(String name, XMLElementWriter<SubsystemMarshallingContext> writer) {
+        delegate.registerSubsystemWriter(name, writer);
+    }
+
+    @Override
+    public void unregisterSubsystemWriter(String name) {
+        delegate.unregisterSubsystemWriter(name);
+    }
+
+    private XmlConfigurationPersister createDelegate(File configFile) {
+
+        QName rootElement = new QName(Namespace.CURRENT.getUriString(), "server");
+        ExtensionRegistry extensionRegistry = new ExtensionRegistry(ProcessType.SELF_CONTAINED, new RunningModeControl(RunningMode.NORMAL));
+        StandaloneXml parser = new StandaloneXml(Module.getBootModuleLoader(), Executors.newSingleThreadExecutor(), extensionRegistry);
+
+        XmlConfigurationPersister persister = new XmlConfigurationPersister(
+                configFile, rootElement, parser, parser, false
+        );
+
+        return persister;
+
+    }
+}

core/container/src/main/java/org/wildfly/swarm/container/runtime/xmlconfig/StandaloneXMLParser.java

@@ -73,6 +73,7 @@ public void writeExtensions(XMLExtendedStreamWriter writer, ModelNode modelNode)
         }, ParsingOption.IGNORE_SUBSYSTEM_FAILURES);
 
         xmlMapper = XMLMapper.Factory.create();
+        xmlMapper.registerRootElement(new QName(Namespace.CURRENT.getUriString(), "server"), parserDelegate);
 
         QName serverElementName = new QName("urn:jboss:domain:4.0", "server");
         this.recognizedNames.add( serverElementName );

core/container/src/main/resources/modules/org/wildfly/swarm/container/api/module.xml

@@ -36,6 +36,9 @@
   <dependencies>
     <module name="org.wildfly.swarm.configuration" export="true"/>
     <module name="org.wildfly.swarm.spi" export="true" services="export"/>
+    <module name="org.jboss.as.server"/>
+    <module name="org.jboss.as.controller" export="true"/>
+    <module name="org.jboss.as.server"/>
     <module name="org.jboss.modules" export="true"/>
     <module name="org.jboss.shrinkwrap" export="true"/>
     <module name="org.jboss.shrinkwrap.descriptors" export="true"/>
@@ -48,5 +51,10 @@
     <module name="javax.enterprise.api"/>
     <module name="javax.inject.api"/>
     <module name="javax.annotation.api" export="true"/>
+
+    <!-- the following have been added to support xml parsing -->
+    <module name="javax.api" export="true"/>
+    <module name="org.jboss.staxmapper" export="true"/>
+    <module name="org.jboss.as.logging" export="true"/>
   </dependencies>
 </module>