Merge 8296782 into 5f8d4d3

event-store-management/event-store-management-core/src/main/java/uk/gov/justice/services/eventstore/management/rebuild/commands/RebuildCommandHandler.java

@@ -1,37 +1,30 @@
 package uk.gov.justice.services.eventstore.management.rebuild.commands;
 
-import static java.lang.String.format;
 import static uk.gov.justice.services.jmx.api.command.RebuildCommand.REBUILD;
 
-import uk.gov.justice.services.common.util.UtcClock;
-import uk.gov.justice.services.eventstore.management.events.rebuild.RebuildRequestedEvent;
+import uk.gov.justice.services.eventstore.management.rebuild.process.RebuildProcessRunner;
 import uk.gov.justice.services.jmx.api.command.RebuildCommand;
 import uk.gov.justice.services.jmx.command.HandlesSystemCommand;
+import uk.gov.justice.services.jmx.logging.MdcLogger;
 
-import java.time.ZonedDateTime;
 import java.util.UUID;
 
-import javax.enterprise.event.Event;
 import javax.inject.Inject;
 
-import org.slf4j.Logger;
-
 public class RebuildCommandHandler {
 
     @Inject
-    private Event<RebuildRequestedEvent> rebuildRequestedEventEventFirer;
+    private RebuildProcessRunner rebuildProcessRunner;
 
     @Inject
-    private UtcClock clock;
+    private MdcLogger mdcLogger;
 
-    @Inject
-    private Logger logger;
 
     @HandlesSystemCommand(REBUILD)
     public void doRebuild(final RebuildCommand rebuildCommand, final UUID commandId) {
 
-        final ZonedDateTime now = clock.now();
-        logger.info(format("Received command '%s' at %tr", rebuildCommand, now));
-        rebuildRequestedEventEventFirer.fire(new RebuildRequestedEvent(commandId, now, rebuildCommand));
+        mdcLogger.mdcLoggerConsumer().accept(() -> {
+            rebuildProcessRunner.runRebuild(commandId, rebuildCommand);
+        });
     }
 }

event-store-management/event-store-management-core/src/main/java/uk/gov/justice/services/eventstore/management/rebuild/process/RebuildProcessRunner.java

@@ -0,0 +1,82 @@
+package uk.gov.justice.services.eventstore.management.rebuild.process;
+
+import static java.lang.String.format;
+import static java.time.temporal.ChronoUnit.MILLIS;
+import static uk.gov.justice.services.jmx.api.domain.CommandState.COMMAND_COMPLETE;
+import static uk.gov.justice.services.jmx.api.domain.CommandState.COMMAND_FAILED;
+import static uk.gov.justice.services.jmx.api.domain.CommandState.COMMAND_IN_PROGRESS;
+
+import uk.gov.justice.services.common.util.UtcClock;
+import uk.gov.justice.services.eventsourcing.publishedevent.rebuild.PublishedEventRebuilder;
+import uk.gov.justice.services.jmx.api.command.RebuildCommand;
+import uk.gov.justice.services.jmx.state.events.SystemCommandStateChangedEvent;
+
+import java.time.ZonedDateTime;
+import java.util.UUID;
+
+import javax.enterprise.event.Event;
+import javax.inject.Inject;
+
+import org.slf4j.Logger;
+
+public class RebuildProcessRunner {
+
+    @Inject
+    private PublishedEventRebuilder publishedEventRebuilder;
+
+    @Inject
+    private Event<SystemCommandStateChangedEvent> systemCommandStateChangedEventFirer;
+
+    @Inject
+    private UtcClock clock;
+
+    @Inject
+    private Logger logger;
+
+    public void runRebuild(final UUID commandId, final RebuildCommand rebuildCommand) {
+
+        final String commandName = rebuildCommand.getName();
+        final ZonedDateTime rebuildStartedAt = clock.now();
+        final String startMessage = format("%s started at %tc", commandName, rebuildStartedAt);
+
+        systemCommandStateChangedEventFirer.fire(new SystemCommandStateChangedEvent(
+                commandId,
+                rebuildCommand,
+                COMMAND_IN_PROGRESS,
+                rebuildStartedAt,
+                startMessage
+        ));
+
+        logger.info(startMessage);
+
+        try {
+            publishedEventRebuilder.rebuild();
+
+            final ZonedDateTime rebuildCompletedAt = clock.now();
+            logger.info(format("%s command completed at %tc", commandName, rebuildCompletedAt));
+            final String endMessage = format("Rebuild took %d milliseconds", MILLIS.between(rebuildStartedAt, rebuildCompletedAt));
+
+            systemCommandStateChangedEventFirer.fire(new SystemCommandStateChangedEvent(
+                    commandId,
+                    rebuildCommand,
+                    COMMAND_COMPLETE,
+                    rebuildCompletedAt,
+                    endMessage
+            ));
+
+            logger.info(endMessage);
+
+        } catch (final Exception e) {
+
+            logger.error(format("%s failed", commandName), e);
+
+            systemCommandStateChangedEventFirer.fire(new SystemCommandStateChangedEvent(
+                    commandId,
+                    rebuildCommand,
+                    COMMAND_FAILED,
+                    clock.now(),
+                    format("Rebuild failed: %s: %s", e.getClass().getSimpleName(), e.getMessage())
+            ));
+        }
+    }
+}

event-store-management/event-store-management-core/src/test/java/uk/gov/justice/services/eventstore/management/rebuild/commands/RebuildCommandHandlerTest.java

@@ -1,54 +1,46 @@
 package uk.gov.justice.services.eventstore.management.rebuild.commands;
 
-import static java.time.ZoneOffset.UTC;
-import static java.time.ZonedDateTime.of;
 import static java.util.UUID.randomUUID;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
-import uk.gov.justice.services.common.util.UtcClock;
-import uk.gov.justice.services.eventstore.management.events.rebuild.RebuildRequestedEvent;
+import uk.gov.justice.services.eventstore.management.rebuild.process.RebuildProcessRunner;
 import uk.gov.justice.services.jmx.api.command.RebuildCommand;
+import uk.gov.justice.services.jmx.logging.MdcLogger;
 
-import java.time.ZonedDateTime;
 import java.util.UUID;
-
-import javax.enterprise.event.Event;
+import java.util.function.Consumer;
 
 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 RebuildCommandHandlerTest {
 
     @Mock
-    private Event<RebuildRequestedEvent> rebuildRequestedEventEventFirer;
-
-    @Mock
-    private UtcClock clock;
+    private RebuildProcessRunner rebuildProcessRunner;
 
     @Mock
-    private Logger logger;
+    private MdcLogger mdcLogger;
 
     @InjectMocks
     private RebuildCommandHandler rebuildCommandHandler;
 
+    private Consumer<Runnable> testConsumer = Runnable::run;
+
     @Test
     public void shouldFireRebuildEvent() throws Exception {
 
         final UUID commandId = randomUUID();
         final RebuildCommand rebuildCommand = new RebuildCommand();
-        final ZonedDateTime now = of(2019, 8, 23, 11, 22, 1, 0, UTC);
 
-        when(clock.now()).thenReturn(now);
+        when(mdcLogger.mdcLoggerConsumer()).thenReturn(testConsumer);
 
         rebuildCommandHandler.doRebuild(rebuildCommand, commandId);
 
-        verify(logger).info("Received command 'REBUILD' at 11:22:01 AM");
-        verify(rebuildRequestedEventEventFirer).fire(new RebuildRequestedEvent(commandId, now, rebuildCommand));
+        verify(rebuildProcessRunner).runRebuild(commandId, rebuildCommand);
     }
 }