Merge pull request #768 from CJSCommonPlatform/make-system-commands-asynchronous

Make SystemCommands run asynchronously

Author: allanmckenzie

CHANGELOG.md

@@ -5,6 +5,13 @@ on [Keep a CHANGELOG](http://keepachangelog.com/). This project adheres to
 
 ## [Unreleased]
 
+## [6.0.12] - 2018-09-08
+### Changed
+- All JMX SystemCommands are now run asynchronously. i.e the call to the JMX bean will return immediately
+- The JMX SystemCommandBean now only throws 2 Exceptions
+    1. UnsupportedSystemCommandException. If the command is unrecognised by the context. 
+    2. SystemCommandFailedException. On any other failure. NB. this Exception also contains the stacktrace of the server side exception
+
 ## [6.0.11] - 2018-08-30
 ### Added
 - ordering to subscriptions descriptor yamls

framework-utilities/pom.xml

@@ -21,6 +21,10 @@
             <groupId>com.google.guava</groupId>
             <artifactId>guava</artifactId>
         </dependency>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-lang3</artifactId>
+        </dependency>
 
         <!-- Test dependencies -->
         <dependency>

framework-utilities/src/main/java/uk/gov/justice/services/framework/utilities/exceptions/StackTraceProvider.java

@@ -0,0 +1,10 @@
+package uk.gov.justice.services.framework.utilities.exceptions;
+
+import org.apache.commons.lang3.exception.ExceptionUtils;
+
+public class StackTraceProvider {
+
+    public String getStackTrace(final Throwable throwable) {
+        return ExceptionUtils.getStackTrace(throwable);
+    }
+}

framework-utilities/src/test/java/uk/gov/justice/services/framework/utilities/exceptions/StackTraceProviderTest.java

@@ -0,0 +1,27 @@
+package uk.gov.justice.services.framework.utilities.exceptions;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.runners.MockitoJUnitRunner;
+
+@RunWith(MockitoJUnitRunner.class)
+public class StackTraceProviderTest {
+
+    @InjectMocks
+    private StackTraceProvider stackTraceProvider;
+
+    @Test
+    public void shouldGetTheStackTraceOfAnExceptionAsAString() throws Exception {
+
+        final String stackTrace = stackTraceProvider.getStackTrace(new Exception("Ooops"));
+
+        final String stackTracePrefix = "java.lang.Exception: Ooops\n" +
+                "\tat uk.gov.justice.services.framework.utilities.exceptions.StackTraceProviderTest.shouldGetTheStackTraceOfAnExceptionAsAString(StackTraceProviderTest.java";
+
+        assertThat(stackTrace.startsWith(stackTracePrefix), is(true));
+    }
+}

jmx/jmx-api/src/main/java/uk/gov/justice/services/jmx/api/SystemCommandFailedException.java

@@ -0,0 +1,15 @@
+package uk.gov.justice.services.jmx.api;
+
+public class SystemCommandFailedException extends RuntimeException {
+
+    private final String serverStackTrace;
+
+    public SystemCommandFailedException(final String message, final String serverStackTrace) {
+        super(message);
+        this.serverStackTrace = serverStackTrace;
+    }
+
+    public String getServerStackTrace() {
+        return serverStackTrace;
+    }
+}

jmx/jmx-api/src/main/java/uk/gov/justice/services/jmx/api/UnsupportedSystemCommandException.java

@@ -0,0 +1,8 @@
+package uk.gov.justice.services.jmx.api;
+
+public class UnsupportedSystemCommandException extends RuntimeException {
+
+    public UnsupportedSystemCommandException(final String message) {
+        super(message);
+    }
+}

jmx/jmx-command-handling/src/main/java/uk/gov/justice/services/jmx/api/mbean/AsynchronousCommandRunnerBean.java

@@ -0,0 +1,45 @@
+package uk.gov.justice.services.jmx.api.mbean;
+
+import static java.lang.String.format;
+
+import uk.gov.justice.services.framework.utilities.exceptions.StackTraceProvider;
+import uk.gov.justice.services.jmx.api.SystemCommandFailedException;
+import uk.gov.justice.services.jmx.api.command.SystemCommand;
+import uk.gov.justice.services.jmx.command.SystemCommandStore;
+
+import javax.ejb.Asynchronous;
+import javax.ejb.Stateless;
+import javax.inject.Inject;
+
+import org.slf4j.Logger;
+
+@Stateless
+public class AsynchronousCommandRunnerBean {
+
+    @Inject
+    private SystemCommandStore systemCommandStore;
+
+    @Inject
+    private StackTraceProvider stackTraceProvider;
+
+    @Inject
+    private Logger logger;
+
+    public boolean isSupported(final SystemCommand systemCommand) {
+        return systemCommandStore.isSupported(systemCommand);
+    }
+
+    @Asynchronous
+    public void run(final SystemCommand systemCommand) {
+        try {
+            systemCommandStore.findCommandProxy(systemCommand).invokeCommand(systemCommand);
+        } catch (final Throwable e) {
+            final String message = format("Failed to run System Command '%s'", systemCommand.getName());
+            logger.error(message, e);
+
+            throw new SystemCommandFailedException(
+                    message + ". Caused by " + e.getClass().getName() + ": " + e.getMessage(),
+                    stackTraceProvider.getStackTrace(e));
+        }
+    }
+}

jmx/jmx-command-handling/src/main/java/uk/gov/justice/services/jmx/api/mbean/SystemCommander.java

@@ -2,13 +2,11 @@
 
 import static java.lang.String.format;
 
-import uk.gov.justice.services.jmx.api.SystemCommandException;
-import uk.gov.justice.services.jmx.api.SystemCommandInvocationException;
+import uk.gov.justice.services.jmx.api.UnsupportedSystemCommandException;
 import uk.gov.justice.services.jmx.api.command.SystemCommand;
 import uk.gov.justice.services.jmx.api.state.ApplicationManagementState;
 import uk.gov.justice.services.jmx.command.ApplicationManagementStateRegistry;
 import uk.gov.justice.services.jmx.command.SystemCommandScanner;
-import uk.gov.justice.services.jmx.command.SystemCommandStore;
 
 import java.util.List;
 
@@ -22,7 +20,7 @@ public class SystemCommander implements SystemCommanderMBean {
     private Logger logger;
 
     @Inject
-    private SystemCommandStore systemCommandStore;
+    private AsynchronousCommandRunnerBean asynchronousCommandRunnerBean;
 
     @Inject
     private SystemCommandScanner systemCommandScanner;
@@ -33,15 +31,12 @@ public class SystemCommander implements SystemCommanderMBean {
     @Override
     public void call(final SystemCommand systemCommand) {
 
-        final String commandName = systemCommand.getName();
-        logger.info(format("Received System Command '%s'", commandName));
+        logger.info(format("Received System Command '%s'", systemCommand.getName()));
 
-        try {
-            systemCommandStore.findCommandProxy(systemCommand).invokeCommand(systemCommand);
-        } catch (final SystemCommandInvocationException e) {
-            final String message = format("Failed to run System Command '%s'", commandName);
-            logger.error(message, e);
-            throw new SystemCommandException(message, e);
+        if(asynchronousCommandRunnerBean.isSupported(systemCommand)) {
+            asynchronousCommandRunnerBean.run(systemCommand);
+        } else {
+           throw new UnsupportedSystemCommandException(format("The system command '%s' is not supported on this context.", systemCommand.getName()));
         }
     }
 

jmx/jmx-command-handling/src/main/java/uk/gov/justice/services/jmx/command/SystemCommandStore.java

@@ -9,19 +9,23 @@
 import java.util.List;
 import java.util.Map;
 
-import javax.enterprise.context.ApplicationScoped;
 import javax.inject.Inject;
+import javax.inject.Singleton;
 
 import org.slf4j.Logger;
 
-@ApplicationScoped
+@Singleton
 public class SystemCommandStore {
 
     private Map<String, SystemCommandHandlerProxy> handlers = new HashMap<>();
 
     @Inject
     private Logger logger;
 
+    public boolean isSupported(final SystemCommand systemCommand) {
+        return handlers.containsKey(systemCommand.getName());
+    }
+
     public SystemCommandHandlerProxy findCommandProxy(final SystemCommand systemCommand) {
 
         final SystemCommandHandlerProxy systemCommandHandlerProxy = handlers.get(

jmx/jmx-command-handling/src/test/java/uk/gov/justice/services/jmx/api/mbean/AsynchronousCommandRunnerBeanTest.java

@@ -0,0 +1,91 @@
+package uk.gov.justice.services.jmx.api.mbean;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.nullValue;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import uk.gov.justice.services.framework.utilities.exceptions.StackTraceProvider;
+import uk.gov.justice.services.jmx.api.SystemCommandException;
+import uk.gov.justice.services.jmx.api.SystemCommandFailedException;
+import uk.gov.justice.services.jmx.command.SystemCommandHandlerProxy;
+import uk.gov.justice.services.jmx.command.SystemCommandStore;
+import uk.gov.justice.services.jmx.command.TestCommand;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.runners.MockitoJUnitRunner;
+import org.slf4j.Logger;
+
+
+@RunWith(MockitoJUnitRunner.class)
+public class AsynchronousCommandRunnerBeanTest {
+
+    @Mock
+    private SystemCommandStore systemCommandStore;
+
+    @Mock
+    private StackTraceProvider stackTraceProvider;
+
+    @Mock
+    private Logger logger;
+
+    @InjectMocks
+    private AsynchronousCommandRunnerBean asynchronousCommandRunnerBean;
+
+    @Test
+    public void shouldReturnFalseIfCommandUnsupported() throws Exception {
+
+        final TestCommand testCommand = new TestCommand();
+        final boolean supported = true;
+
+        when(systemCommandStore.isSupported(testCommand)).thenReturn(supported);
+
+        assertThat(asynchronousCommandRunnerBean.isSupported(testCommand), is(supported));
+    }
+
+    @Test
+    public void shouldFindTheCorrectProxyForTheCommandAndInvoke() throws Exception {
+
+        final TestCommand testCommand = new TestCommand();
+
+        final SystemCommandHandlerProxy systemCommandHandlerProxy = mock(SystemCommandHandlerProxy.class);
+
+        when(systemCommandStore.findCommandProxy(testCommand)).thenReturn(systemCommandHandlerProxy);
+
+        asynchronousCommandRunnerBean.run(testCommand);
+
+        verify(systemCommandHandlerProxy).invokeCommand(testCommand);
+    }
+
+    @Test
+    public void shouldThrowSystemCommandFailedExceptionIfCommandFails() throws Exception {
+
+        final TestCommand testCommand = new TestCommand();
+        final SystemCommandException systemCommandException = new SystemCommandException("Ooops");
+        final String stackTrace = "stack trace";
+
+        final SystemCommandHandlerProxy systemCommandHandlerProxy = mock(SystemCommandHandlerProxy.class);
+
+        when(systemCommandStore.findCommandProxy(testCommand)).thenReturn(systemCommandHandlerProxy);
+        doThrow(systemCommandException).when(systemCommandHandlerProxy).invokeCommand(testCommand);
+        when(stackTraceProvider.getStackTrace(systemCommandException)).thenReturn(stackTrace);
+
+        try {
+            asynchronousCommandRunnerBean.run(testCommand);
+            fail();
+        } catch (final SystemCommandFailedException expected) {
+            assertThat(expected.getMessage(), is("Failed to run System Command 'TEST_COMMAND'. Caused by uk.gov.justice.services.jmx.api.SystemCommandException: Ooops"));
+            assertThat(expected.getServerStackTrace(), is(stackTrace));
+            assertThat(expected.getCause(), is(nullValue()));
+        }
+
+
+    }
+}