Use Java 1.8, and its Optional.

[rhynodge.git] / src / main / java / net / pterodactylus / rhynodge / engine / Engine.java

diff --git a/src/main/java/net/pterodactylus/rhynodge/engine/Engine.java b/src/main/java/net/pterodactylus/rhynodge/engine/Engine.java
index 423eaaf..861bfba 100644 (file)
--- a/src/main/java/net/pterodactylus/rhynodge/engine/Engine.java
+++ b/src/main/java/net/pterodactylus/rhynodge/engine/Engine.java
@@ -17,14 +17,15 @@
 
 package net.pterodactylus.rhynodge.engine;
 
-import static com.google.common.base.Optional.absent;
-import static com.google.common.base.Optional.of;
 import static com.google.common.collect.Maps.newTreeMap;
 import static java.lang.String.format;
+import static java.util.Optional.empty;
+import static java.util.Optional.of;
 
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Map.Entry;
+import java.util.Optional;
 import java.util.SortedMap;
 
 import net.pterodactylus.rhynodge.Filter;
@@ -35,7 +36,6 @@ import net.pterodactylus.rhynodge.states.AbstractState;
 import net.pterodactylus.rhynodge.states.FailedState;
 import net.pterodactylus.rhynodge.states.StateManager;
 
-import com.google.common.base.Optional;
 import com.google.common.util.concurrent.AbstractExecutionThreadService;
 import org.apache.commons.lang3.tuple.Pair;
 import org.apache.log4j.Logger;
@@ -122,49 +122,23 @@ public class Engine extends AbstractExecutionThreadService {
 
                        /* wait until the next reaction has to run. */
                        Optional<net.pterodactylus.rhynodge.State> lastState = stateManager.loadLastState(reactionName);
-                       long lastStateTime = lastState.isPresent() ? lastState.get().time() : 0;
                        int lastStateFailCount = lastState.isPresent() ? lastState.get().failCount() : 0;
-                       long waitTime = (lastStateTime + nextReaction.get().getReaction().updateInterval()) - System.currentTimeMillis();
+                       long waitTime = nextReaction.get().getNextTime() - System.currentTimeMillis();
                        logger.debug(format("Time to wait for next Reaction: %d millseconds.", waitTime));
                        if (waitTime > 0) {
-                               synchronized (reactions) {
-                                       try {
-                                               logger.info(format("Waiting until %tc.", lastStateTime + nextReaction.get().getReaction().updateInterval()));
-                                               reactions.wait(waitTime);
-                                       } catch (InterruptedException ie1) {
-                                               /* we’re looping! */
-                                       }
-                               }
+                               waitForNextReactionToStart(nextReaction, waitTime);
 
                                /* re-start loop to check for new reactions. */
                                continue;
                        }
 
-                       /* run reaction. */
-                       logger.info(format("Running Query for %s...", reactionName));
-                       Query query = nextReaction.get().getReaction().query();
-                       net.pterodactylus.rhynodge.State state;
-                       try {
-                               logger.debug("Querying system...");
-                               state = query.state();
-                               if (state == null) {
-                                       state = FailedState.INSTANCE;
-                               }
-                               logger.debug("System queried.");
-                       } catch (Throwable t1) {
-                               logger.warn("Querying system failed!", t1);
-                               state = new AbstractState(t1) {
-                                       /* no further state. */
-                               };
-                       }
+                       net.pterodactylus.rhynodge.State state = runReaction(nextReaction, reactionName);
                        logger.debug(format("State is %s.", state));
 
                        /* convert states. */
                        for (Filter filter : nextReaction.get().getReaction().filters()) {
                                if (state.success()) {
-                                       net.pterodactylus.rhynodge.State newState = filter.filter(state);
-                                       //logger.debug(String.format("Old state is %s, new state is %s.", state, newState));
-                                       state = newState;
+                                       state = filter.filter(state);
                                }
                        }
                        if (!state.success()) {
@@ -197,6 +171,36 @@ public class Engine extends AbstractExecutionThreadService {
                }
        }
 
+       private net.pterodactylus.rhynodge.State runReaction(Optional<NextReaction> nextReaction, String reactionName) {
+               logger.info(format("Running Query for %s...", reactionName));
+               Query query = nextReaction.get().getReaction().query();
+               net.pterodactylus.rhynodge.State state;
+               try {
+                       logger.debug("Querying system...");
+                       state = query.state();
+                       if (state == null) {
+                               state = FailedState.INSTANCE;
+                       }
+                       logger.debug("System queried.");
+               } catch (Throwable t1) {
+                       logger.warn("Querying system failed!", t1);
+                       state = new AbstractState(t1) {
+                       };
+               }
+               return state;
+       }
+
+       private void waitForNextReactionToStart(Optional<NextReaction> nextReaction, long waitTime) {
+               synchronized (reactions) {
+                       try {
+                               logger.info(format("Waiting until %tc.", nextReaction.get().getNextTime()));
+                               reactions.wait(waitTime);
+                       } catch (InterruptedException ie1) {
+                               /* we’re looping! */
+                       }
+               }
+       }
+
        private Optional<NextReaction> getNextReaction() {
                while (isRunning()) {
                        synchronized (reactions) {
@@ -223,7 +227,7 @@ public class Engine extends AbstractExecutionThreadService {
                                return of(new NextReaction(keyReaction.getKey(), keyReaction.getValue(), nextReactions.firstKey()));
                        }
                }
-               return absent();
+               return empty();
        }
 
        private static class NextReaction {