private String onapComponent;
private String onapInstance;
private String action = DEFAULT_ACTION;
+
+ /**
+ * {@code True} if guard operations are disabled.
+ */
+ private boolean disabled = false;
}
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.concurrent.Executor;
+import lombok.Getter;
import org.onap.policy.common.endpoints.http.client.HttpClient;
import org.onap.policy.common.endpoints.http.client.HttpClientFactory;
import org.onap.policy.controlloop.actorserviceprovider.parameters.HttpConfig;
public class GuardConfig extends HttpConfig {
private final Map<String, Object> defaultRequest = new LinkedHashMap<>();
+ /**
+ * {@code True} if the associated guard operation is disabled.
+ */
+ @Getter
+ private boolean disabled;
+
/**
* Constructs the object.
*
addProperty("ONAPInstance", params.getOnapInstance());
addProperty("ONAPName", params.getOnapName());
addProperty("action", params.getAction());
+
+ this.disabled = params.isDisabled();
}
/**
@Override
protected CompletableFuture<OperationOutcome> startOperationAsync(int attempt, OperationOutcome outcome) {
+ if (config.isDisabled()) {
+ // guard is disabled, thus it is always treated as a success
+ return CompletableFuture.completedFuture(params.makeOutcome());
+ }
DecisionRequest request = Util.translate(getName(), makeRequest(), DecisionRequest.class);
private String onapComponent;
private String onapInstance;
private String action;
+
+ /**
+ * {@code True} if the associated guard operation is disabled.
+ */
+ private boolean disabled;
}
params = makeGuardActorParams();
}
+ @Test
+ public void testIsDisabled() {
+ // disabled by default
+ assertFalse(params.isDisabled());
+ }
+
@Test
public void testValidate() {
assertTrue(params.validate(CONTAINER).isValid());
package org.onap.policy.controlloop.actor.guard;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.when;
import java.util.concurrent.Executor;
// repeat, with minimal parameters
params = GuardParams.builder().clientName(MY_CLIENT).path(PATH).timeoutSec(TIMEOUT).build();
config = new GuardConfig(executor, params, factory);
+ assertFalse(config.isDisabled());
actual = Util.translate("", config.makeRequest(), DecisionRequest.class);
assertEquals(new DecisionRequest(), actual);
+
+ // try with disabled=true
+ params = params.toBuilder().disabled(true).build();
+ config = new GuardConfig(executor, params, factory);
+ assertTrue(config.isDisabled());
}
}
import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import java.util.Map;
import java.util.TreeMap;
import java.util.concurrent.CompletableFuture;
+import java.util.function.Consumer;
import org.junit.Before;
import org.junit.Test;
+import org.mockito.Mock;
import org.onap.policy.common.utils.coder.CoderException;
import org.onap.policy.controlloop.actor.test.BasicHttpOperation;
import org.onap.policy.controlloop.actorserviceprovider.OperationOutcome;
public class GuardOperationTest extends BasicHttpOperation<DecisionRequest> {
+ @Mock
+ private Consumer<OperationOutcome> started;
+ @Mock
+ private Consumer<OperationOutcome> completed;
+
+ private GuardConfig guardConfig;
private GuardOperation oper;
/**
public void setUp() throws Exception {
super.setUpBasic();
- GuardConfig cguard = mock(GuardConfig.class);
- when(cguard.makeRequest()).thenAnswer(args -> new TreeMap<>(Map.of("action", "guard")));
+ guardConfig = mock(GuardConfig.class);
+ when(guardConfig.makeRequest()).thenAnswer(args -> new TreeMap<>(Map.of("action", "guard")));
- config = cguard;
+ config = guardConfig;
initConfig();
+ params = params.toBuilder().startCallback(started).completeCallback(completed).build();
+
oper = new GuardOperation(params, config);
}
assertEquals(PolicyResult.SUCCESS, future2.get().getResult());
}
+ /**
+ * Tests startOperationAsync() when the guard is disabled.
+ */
+ @Test
+ public void testStartOperationAsyncDisabled() throws Exception {
+ // indicate that it's disabled
+ when(guardConfig.isDisabled()).thenReturn(true);
+
+ CompletableFuture<OperationOutcome> future2 = oper.start();
+ executor.runAll(100);
+
+ verify(client, never()).post(any(), any(), any(), any());
+
+ // should already be done
+ assertTrue(future2.isDone());
+
+ assertEquals(PolicyResult.SUCCESS, future2.get().getResult());
+
+ // ensure callbacks were invoked
+ verify(started).accept(any());
+ verify(completed).accept(any());
+ }
+
@Test
public void testMakeRequest() throws CoderException {
verifyPayload("makeReqStd.json", makePayload());
.action(MY_ACTION).clientName(CLIENT).path(PATH).timeoutSec(TIMEOUT).build();
}
+ @Test
+ public void testIsDisabled() {
+ // disabled by default
+ assertFalse(params.isDisabled());
+ }
+
@Test
public void testValidate() {
assertTrue(params.validate(CONTAINER).isValid());
private final Map<String, Actor> name2actor;
- private static class LazyHolder {
- static final ActorService INSTANCE = new ActorService();
- }
-
/**
* Constructs the object and loads the list of actors.
*/
name2actor = ImmutableMap.copyOf(map);
}
- /**
- * Get the single instance.
- *
- * @return the instance
- */
- public static ActorService getInstance() {
- return LazyHolder.INSTANCE;
- }
-
/**
* Gets a particular actor.
*
* returned by overridden methods will do the same. Of course, if a class overrides
* {@link #doOperation(int, OperationOutcome) doOperation()}, then there's little that can
* be done to cancel that particular operation.
+ * <p/>
+ * In general tasks in a pipeline are executed by the same thread. However, the following
+ * should always be executed via the executor specified in "params":
+ * <ul>
+ * <li>start callback</li>
+ * <li>completion callback</li>
+ * <li>controller completion (i.e., delayedComplete())</li>
+ * </ul>
*/
public abstract class OperationPartial implements Operation {
private static final Logger logger = LoggerFactory.getLogger(OperationPartial.class);
* canceled. Similarly, when this future completes, any incomplete futures
* will be canceled
*/
- public CompletableFuture<OperationOutcome> anyOf(
- List<Supplier<CompletableFuture<OperationOutcome>>> futureMakers) {
+ public CompletableFuture<OperationOutcome> anyOf(List<Supplier<CompletableFuture<OperationOutcome>>> futureMakers) {
PipelineControllerFuture<OperationOutcome> controller = new PipelineControllerFuture<>();
* canceled. Similarly, when this future completes, any incomplete futures
* will be canceled
*/
- public CompletableFuture<OperationOutcome> allOf(
- List<Supplier<CompletableFuture<OperationOutcome>>> futureMakers) {
+ public CompletableFuture<OperationOutcome> allOf(List<Supplier<CompletableFuture<OperationOutcome>>> futureMakers) {
PipelineControllerFuture<OperationOutcome> controller = new PipelineControllerFuture<>();
Queue<OperationOutcome> outcomes = new LinkedList<>();
// @formatter:off
controller.wrap(nextTask)
- .thenComposeAsync(nextTaskOnSuccess(controller, queue), executor)
+ .thenCompose(nextTaskOnSuccess(controller, queue))
.whenCompleteAsync(controller.delayedComplete(), executor);
// @formatter:on
// @formatter:off
return controller
.wrap(nextTask)
- .thenComposeAsync(nextTaskOnSuccess(controller, taskQueue), params.getExecutor());
+ .thenCompose(nextTaskOnSuccess(controller, taskQueue));
// @formatter:on
};
}
package org.onap.policy.controlloop.actorserviceprovider;
import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
import org.junit.Test;
import org.onap.policy.controlloop.actorserviceprovider.spi.Actor;
@Test
public void testActorServiceProvider() {
- ActorService actorService = ActorService.getInstance();
- assertNotNull(actorService);
+ ActorService actorService = new ActorService();
- assertEquals(1, actorService.getActors().size());
+ assertTrue(actorService.getActors().size() >= 1);
- actorService = ActorService.getInstance();
- assertNotNull(actorService);
-
- Actor dummyActor = ActorService.getInstance().getActors().iterator().next();
- assertNotNull(dummyActor);
+ Actor dummyActor = actorService.getActor(DummyActor.class.getSimpleName());
assertEquals("DummyActor", dummyActor.actor());
iter.next();
}
- @Test
- public void testGetInstance() {
- service = ActorService.getInstance();
- assertNotNull(service);
-
- assertSame(service, ActorService.getInstance());
- }
-
@Test
public void testGetActor() {
assertSame(actor1, service.getActor(ACTOR1));
@Test
public void testLoadActors() {
- assertFalse(ActorService.getInstance().getActors().isEmpty());
- assertNotNull(ActorService.getInstance().getActor("DummyActor"));
+ ActorService service = new ActorService();
+ assertFalse(service.getActors().isEmpty());
+ assertNotNull(service.getActor(DummyActor.class.getSimpleName()));
}
/**
Code Review / policy / models.git / commitdiff