[JBAS-8690] - Execute deployment updates as a service with the proper dependencies

Author: John E. Bailey

server/src/main/java/org/jboss/as/server/DeploymentUpdateService.java

@@ -0,0 +1,100 @@
+/*
+ * JBoss, Home of Professional Open Source.
+ * Copyright 2010, Red Hat, Inc., and individual contributors
+ * as indicated by the @author tags. See the copyright.txt file in the
+ * distribution for a full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+
+package org.jboss.as.server;
+
+import java.util.List;
+import org.jboss.as.deployment.ServerDeploymentRepository;
+import org.jboss.as.deployment.unit.DeploymentUnitProcessor;
+import org.jboss.as.model.AbstractServerModelUpdate;
+import org.jboss.as.model.BootUpdateContext;
+import org.jboss.msc.service.BatchBuilder;
+import org.jboss.msc.service.Service;
+import org.jboss.msc.service.ServiceContainer;
+import org.jboss.msc.service.ServiceName;
+import org.jboss.msc.service.ServiceRegistryException;
+import org.jboss.msc.service.StartContext;
+import org.jboss.msc.service.StartException;
+import org.jboss.msc.service.StopContext;
+
+/**
+ * Service used to execute deployment updates once required deployment dependencies are available.
+ *
+ * @author John Bailey
+ */
+public class DeploymentUpdateService implements Service<Void> {
+    private static final ServiceName SERVICE_NAME = ServiceName.JBOSS.append("deployment", "updates");
+    private final List<AbstractServerModelUpdate<?>> updates;
+    private final ServerStartupListener serverStartupListener;
+
+    static final void addService(final BatchBuilder batchBuilder, final List<AbstractServerModelUpdate<?>> updates, final ServerStartupListener serverStartupListener) {
+        batchBuilder.addService(SERVICE_NAME, new DeploymentUpdateService(updates, serverStartupListener))
+            .addDependency(ServerDeploymentRepository.SERVICE_NAME);
+    }
+
+    public DeploymentUpdateService(final List<AbstractServerModelUpdate<?>> updates, final ServerStartupListener serverStartupListener) {
+        this.updates = updates;
+        this.serverStartupListener = serverStartupListener;
+    }
+
+    public void start(StartContext context) throws StartException {
+        final ServiceContainer serviceContainer = context.getController().getServiceContainer();
+
+        final ServerStartBatchBuilder batchBuilder = new ServerStartBatchBuilder(serviceContainer.batchBuilder(), serverStartupListener);
+        batchBuilder.addListener(serverStartupListener);
+
+        final BootUpdateContext updateContext = new BootUpdateContext() {
+            public BatchBuilder getBatchBuilder() {
+                return batchBuilder;
+            }
+
+            public ServiceContainer getServiceContainer() {
+                return serviceContainer;
+            }
+
+            public void addDeploymentProcessor(DeploymentUnitProcessor processor, long priority) {
+                throw new UnsupportedOperationException("Deployments are not allowed to add deployment unit processors");
+            }
+        };
+
+        // Deployment chain should be configured now..
+        for (AbstractServerModelUpdate<?> update : updates) {
+            if(update.isDeploymentUpdate()) {
+                update.applyUpdateBootAction(updateContext);
+            }
+        }
+
+        try {
+            batchBuilder.install();
+            serverStartupListener.finish();
+        } catch (ServiceRegistryException e) {
+            throw new IllegalStateException("Failed to install deployment services", e);
+        }
+    }
+
+    public void stop(StopContext context) {
+    }
+
+    public Void getValue() throws IllegalStateException {
+        return null;
+    }
+}

server/src/main/java/org/jboss/as/server/ServerStartTask.java

@@ -74,8 +74,7 @@
 /**
  * @author <a href="mailto:[email protected]">David M. Lloyd</a>
  */
-public final class
-        ServerStartTask implements ServerTask, Serializable, ObjectInputValidation {
+public final class ServerStartTask implements ServerTask, Serializable, ObjectInputValidation {
 
     public static final ServiceName AS_SERVER_SERVICE_NAME = ServiceName.JBOSS.append("as", "server");
 
@@ -234,19 +233,12 @@ public void addDeploymentProcessor(DeploymentUnitProcessor processor, long prior
             }
         }
 
-        // Deployment chain should be configured now..
-        for (AbstractServerModelUpdate<?> update : updates) {
-            if(update.isDeploymentUpdate()) {
-                update.applyUpdateBootAction(context);
-            }
-        }
+        DeploymentUpdateService.addService(batchBuilder, updates, serverStartupListener);
 
         StandaloneServerManagementServices.addServices(serverModel, container, batchBuilder);
 
         try {
-            serverStartupListener.finish();
             batchBuilder.install();
-            serverStartupListener.finishBatch();
         } catch (ServiceRegistryException e) {
             throw new IllegalStateException("Failed to install boot services", e);
         }

server/src/main/java/org/jboss/as/server/ServerStartupListener.java

@@ -50,9 +50,7 @@ public class ServerStartupListener extends AbstractServiceListener<Object>{
     private final long start = Module.getStartTime();
     private final Map<ServiceName, StartException> serviceFailures = new HashMap<ServiceName, StartException>();
     private final Callback finishCallback;
-    private Runnable batchCallback;
     private final Set<ServiceName> expectedNonActiveServices = new HashSet<ServiceName>();
-    private final AtomicBoolean finished = new AtomicBoolean();
     private final AtomicBoolean callbackRan = new AtomicBoolean();
 
     private static final AtomicIntegerFieldUpdater<ServerStartupListener> countUpdater = AtomicIntegerFieldUpdater.newUpdater(ServerStartupListener.class, "count");
@@ -84,7 +82,7 @@ public void serviceStarted(final ServiceController<? extends Object> serviceCont
             startedOnDemandServicesUpdater.incrementAndGet(this);
         }
         if (!expectedNonActiveServices.contains(serviceController.getName()) && countUpdater.decrementAndGet(this) == 0) {
-            batchComplete();
+            complete();
         }
         serviceController.removeListener(this);
     }
@@ -95,37 +93,19 @@ public void serviceFailed(ServiceController<? extends Object> serviceController,
         log.errorf(reason, "Service [%s] start failed", serviceName);
         serviceFailures.put(serviceName, reason);
         if (!expectedNonActiveServices.contains(serviceController.getName()) && countUpdater.decrementAndGet(this) == 0) {
-            batchComplete();
+            complete();
         }
         serviceController.removeListener(this);
     }
 
-    public void startBatch(final Runnable batchCallback) {
-        if(finished.get()) {
-            throw new IllegalStateException("Listener is already finished");
-        }
-        if(!countUpdater.compareAndSet(this, 0, 1)) {
-            throw new IllegalStateException("Listener already has a started batch");
-        }
-        this.batchCallback = batchCallback;
-    }
-
-    public void finishBatch() {
+    public void finish() {
         if (countUpdater.decrementAndGet(this) == 0) {
-            batchComplete();
+            complete();
         }
     }
 
-    public void finish() {
-        finished.set(true);
-    }
-
-    private void batchComplete() {
-        boolean finished = this.finished.get(); // Check first in case the batch callback invokes finish, which would not be valid for this batch
-        if(batchCallback != null) {
-            batchCallback.run();
-        }
-        if(finished && callbackRan.compareAndSet(false, true)) {
+    private void complete() {
+        if(callbackRan.compareAndSet(false, true)) {
             final long end = System.currentTimeMillis();
             finishCallback.run(serviceFailures, end - start, totalServices, expectedNonActiveServices.size() - startedOnDemandServicesUpdater.get(this), startedServices);
         }