issue 702: NodeRunning predicate throws IllegalStateException when state is terminated

compute/src/main/java/org/jclouds/compute/predicates/NodePresentAndInIntendedState.java

@@ -20,6 +20,8 @@ package org.jclouds.compute.predicates;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
+import java.util.Set;
+
 import javax.annotation.Resource;
 import javax.inject.Singleton;
 
@@ -29,6 +31,7 @@ import org.jclouds.compute.domain.NodeState;
 import org.jclouds.logging.Logger;
 
 import com.google.common.base.Predicate;
+import com.google.common.collect.ImmutableSet;
 import com.google.inject.Inject;
 
 /**
@@ -42,13 +45,19 @@ public class NodePresentAndInIntendedState implements Predicate<NodeMetadata> {
 
    private final ComputeService client;
    private final NodeState intended;
+   private final Set<NodeState> invalids;
    @Resource
    protected Logger logger = Logger.NULL;
 
    @Inject
    public NodePresentAndInIntendedState(NodeState intended, ComputeService client) {
+      this(intended, ImmutableSet.of(NodeState.ERROR), client);
+   }
+
+   public NodePresentAndInIntendedState(NodeState intended, Set<NodeState> invalids, ComputeService client) {
       this.intended = intended;
       this.client = client;
+      this.invalids = invalids;
    }
 
    public boolean apply(NodeMetadata node) {
@@ -57,9 +66,9 @@ public class NodePresentAndInIntendedState implements Predicate<NodeMetadata> {
       if (node == null)
          return false;
       logger.trace("%s: looking for node state %s: currently: %s", node.getId(), intended, node.getState());
-      if (node.getState() == NodeState.ERROR)
+      if (invalids.contains(node.getState()))
          throw new IllegalStateException("node " + node.getId() + " in location " + node.getLocation()
-                  + " is in error state");
+                  + " is in invalid state "+node.getState());
       return node.getState() == intended;
    }
 

compute/src/main/java/org/jclouds/compute/predicates/NodeRunning.java

@@ -23,6 +23,7 @@ import javax.inject.Singleton;
 import org.jclouds.compute.ComputeService;
 import org.jclouds.compute.domain.NodeState;
 
+import com.google.common.collect.ImmutableSet;
 import com.google.inject.Inject;
 
 /**
@@ -36,6 +37,6 @@ public class NodeRunning extends NodePresentAndInIntendedState {
 
    @Inject
    public NodeRunning(ComputeService client) {
-      super(NodeState.RUNNING, client);
+      super(NodeState.RUNNING, ImmutableSet.of(NodeState.ERROR, NodeState.TERMINATED), client);
    }
 }

compute/src/test/java/org/jclouds/compute/predicates/NodePredicatesTest.java

@@ -0,0 +1,82 @@
+/**
+ * Licensed to jclouds, Inc. (jclouds) under one or more
+ * contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  jclouds licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.jclouds.compute.predicates;
+
+import static org.easymock.EasyMock.expect;
+import static org.easymock.classextension.EasyMock.createMock;
+import static org.easymock.classextension.EasyMock.replay;
+
+import org.jclouds.compute.ComputeService;
+import org.jclouds.compute.domain.NodeMetadata;
+import org.jclouds.compute.domain.NodeState;
+import org.testng.Assert;
+import org.testng.annotations.BeforeMethod;
+import org.testng.annotations.Test;
+
+/**
+ * Tests possible uses of OperatingSystemPredicates
+ * 
+ * @author Aled Sage
+ */
+@Test
+public class NodePredicatesTest {
+
+   private NodeMetadata node;
+   private ComputeService computeService;
+
+   @BeforeMethod
+   public void setUp() throws Exception {
+      node = createMock(NodeMetadata.class);
+      computeService = createMock(ComputeService.class);
+      
+      expect(node.getId()).andReturn("myid").anyTimes();
+      expect(computeService.getNodeMetadata("myid")).andReturn(node).anyTimes();
+      expect(node.getLocation()).andReturn(null).anyTimes();
+   }
+   
+   @Test
+   public void testNodeRunningReturnsTrueWhenRunning() {
+       expect(node.getState()).andReturn(NodeState.RUNNING).atLeastOnce();
+       replay(node);
+       replay(computeService);
+	   
+	   NodeRunning nodeRunning = new NodeRunning(computeService);
+	   Assert.assertTrue(nodeRunning.apply(node));
+   }
+
+   @Test(expectedExceptions=IllegalStateException.class)
+   public void testNodeRunningFailsOnTerminated() {
+	   expect(node.getState()).andReturn(NodeState.TERMINATED).atLeastOnce();
+	   replay(node);
+       replay(computeService);
+	   
+	   NodeRunning nodeRunning = new NodeRunning(computeService);
+	   nodeRunning.apply(node);
+   }
+   
+   @Test(expectedExceptions=IllegalStateException.class)
+   public void testNodeRunningFailsOnError() {
+       expect(node.getState()).andReturn(NodeState.ERROR).atLeastOnce();
+       replay(node);
+       replay(computeService);
+
+       NodeRunning nodeRunning = new NodeRunning(computeService);
+       nodeRunning.apply(node);
+   }
+}