import org.onap.policy.common.utils.coder.StandardCoderObject;
import org.onap.policy.controlloop.actorserviceprovider.OperationOutcome;
import org.onap.policy.controlloop.actorserviceprovider.OperationProperties;
+import org.onap.policy.controlloop.actorserviceprovider.OperationResult;
import org.onap.policy.controlloop.actorserviceprovider.impl.HttpOperation;
import org.onap.policy.controlloop.actorserviceprovider.parameters.ControlLoopOperationParams;
import org.onap.policy.controlloop.actorserviceprovider.parameters.HttpConfig;
-import org.onap.policy.controlloop.policy.PolicyResult;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
}
@Override
- public OperationOutcome setOutcome(OperationOutcome outcome, PolicyResult result, Response rawResponse,
+ public OperationOutcome setOutcome(OperationOutcome outcome, OperationResult result, Response rawResponse,
String response) {
super.setOutcome(outcome, result, rawResponse, response);
import org.onap.policy.common.utils.coder.StandardCoderObject;
import org.onap.policy.controlloop.actorserviceprovider.OperationOutcome;
import org.onap.policy.controlloop.actorserviceprovider.OperationProperties;
+import org.onap.policy.controlloop.actorserviceprovider.OperationResult;
import org.onap.policy.controlloop.actorserviceprovider.Util;
import org.onap.policy.controlloop.actorserviceprovider.impl.HttpOperation;
import org.onap.policy.controlloop.actorserviceprovider.impl.HttpOperator;
import org.onap.policy.controlloop.actorserviceprovider.parameters.HttpConfig;
import org.onap.policy.controlloop.actorserviceprovider.parameters.HttpParams;
import org.onap.policy.controlloop.actorserviceprovider.spi.Actor;
-import org.onap.policy.controlloop.policy.PolicyResult;
public class AaiCustomQueryOperationTest extends BasicAaiOperation {
private static final StandardCoder coder = new StandardCoder();
oper.setProperty(OperationProperties.AAI_VSERVER_LINK, MY_LINK);
outcome = oper.start().get();
- assertEquals(PolicyResult.SUCCESS, outcome.getResult());
+ assertEquals(OperationResult.SUCCESS, outcome.getResult());
assertNotNull(outcome.getResponse());
}
CompletableFuture<OperationOutcome> future2 = oper.start();
- assertEquals(PolicyResult.SUCCESS, getResult(future2));
+ assertEquals(OperationResult.SUCCESS, getResult(future2));
// tenant response should have been cached within the context
assertNotNull(context.getProperty(AaiGetTenantOperation.getKey(MY_VSERVER)));
CompletableFuture<OperationOutcome> future2 = oper.start();
- assertEquals(PolicyResult.SUCCESS, getResult(future2));
+ assertEquals(OperationResult.SUCCESS, getResult(future2));
// should not have replaced tenant response
assertSame(data, context.getProperty(AaiGetTenantOperation.getKey(MY_VSERVER)));
@Test
public void testSetOutcome() {
- outcome = oper.setOutcome(params.makeOutcome(null), PolicyResult.SUCCESS, null, null);
+ outcome = oper.setOutcome(params.makeOutcome(null), OperationResult.SUCCESS, null, null);
assertNull(outcome.getResponse());
- outcome = oper.setOutcome(params.makeOutcome(null), PolicyResult.SUCCESS, null, "{}");
+ outcome = oper.setOutcome(params.makeOutcome(null), OperationResult.SUCCESS, null, "{}");
assertTrue(outcome.getResponse() instanceof AaiCqResponse);
}
context.setProperty(AaiGetTenantOperation.getKey(SIM_VSERVER), data);
}
- private PolicyResult getResult(CompletableFuture<OperationOutcome> future2)
+ private OperationResult getResult(CompletableFuture<OperationOutcome> future2)
throws InterruptedException, ExecutionException, TimeoutException {
executor.runAll(100);
import org.onap.policy.common.utils.coder.StandardCoderObject;
import org.onap.policy.controlloop.actorserviceprovider.OperationOutcome;
import org.onap.policy.controlloop.actorserviceprovider.OperationProperties;
+import org.onap.policy.controlloop.actorserviceprovider.OperationResult;
import org.onap.policy.controlloop.actorserviceprovider.parameters.HttpConfig;
import org.onap.policy.controlloop.actorserviceprovider.parameters.HttpParams;
-import org.onap.policy.controlloop.policy.PolicyResult;
public class AaiGetPnfOperationTest extends BasicAaiOperation {
private static final String INPUT_FIELD = "input";
oper.setProperty(OperationProperties.AAI_TARGET_ENTITY, "OzVServer");
outcome = oper.start().get();
- assertEquals(PolicyResult.SUCCESS, outcome.getResult());
+ assertEquals(OperationResult.SUCCESS, outcome.getResult());
assertTrue(outcome.getResponse() instanceof StandardCoderObject);
}
oper.setProperty(OperationProperties.AAI_TARGET_ENTITY, "getFail");
outcome = oper.start().get();
- assertEquals(PolicyResult.FAILURE, outcome.getResult());
+ assertEquals(OperationResult.FAILURE, outcome.getResult());
}
@Test
executor.runAll(100);
assertTrue(future2.isDone());
- assertEquals(PolicyResult.SUCCESS, future2.get().getResult());
+ assertEquals(OperationResult.SUCCESS, future2.get().getResult());
// data should have been cached within the context
StandardCoderObject data = context.getProperty(AaiGetPnfOperation.getKey(TARGET_ENTITY));
executor.runAll(100);
assertTrue(future2.isDone());
- assertEquals(PolicyResult.FAILURE, future2.get().getResult());
+ assertEquals(OperationResult.FAILURE, future2.get().getResult());
// data should NOT have been cached within the context
assertNull(context.getProperty(AaiGetPnfOperation.getKey(TARGET_ENTITY)));
import org.onap.policy.common.utils.coder.StandardCoderObject;
import org.onap.policy.controlloop.actorserviceprovider.OperationOutcome;
import org.onap.policy.controlloop.actorserviceprovider.OperationProperties;
+import org.onap.policy.controlloop.actorserviceprovider.OperationResult;
import org.onap.policy.controlloop.actorserviceprovider.parameters.HttpConfig;
import org.onap.policy.controlloop.actorserviceprovider.parameters.HttpParams;
-import org.onap.policy.controlloop.policy.PolicyResult;
public class AaiGetTenantOperationTest extends BasicAaiOperation {
private static final String INPUT_FIELD = "input";
oper.setProperty(OperationProperties.AAI_TARGET_ENTITY, "OzVServer");
outcome = oper.start().get();
- assertEquals(PolicyResult.SUCCESS, outcome.getResult());
+ assertEquals(OperationResult.SUCCESS, outcome.getResult());
assertTrue(outcome.getResponse() instanceof StandardCoderObject);
}
oper.setProperty(OperationProperties.AAI_TARGET_ENTITY, "failedVserver");
outcome = oper.start().get();
- assertEquals(PolicyResult.FAILURE, outcome.getResult());
+ assertEquals(OperationResult.FAILURE, outcome.getResult());
}
@Test
executor.runAll(100);
assertTrue(future2.isDone());
- assertEquals(PolicyResult.SUCCESS, future2.get().getResult());
+ assertEquals(OperationResult.SUCCESS, future2.get().getResult());
// data should have been cached within the context
StandardCoderObject data = context.getProperty(AaiGetTenantOperation.getKey(TARGET_ENTITY));
executor.runAll(100);
assertTrue(future2.isDone());
- assertEquals(PolicyResult.FAILURE, future2.get().getResult());
+ assertEquals(OperationResult.FAILURE, future2.get().getResult());
// data should NOT have been cached within the context
assertNull(context.getProperty(AaiGetTenantOperation.getKey(TARGET_ENTITY)));
import org.onap.policy.common.utils.coder.StandardCoder;
import org.onap.policy.common.utils.coder.StandardCoderInstantAsMillis;
import org.onap.policy.controlloop.actorserviceprovider.OperationOutcome;
+import org.onap.policy.controlloop.actorserviceprovider.OperationResult;
import org.onap.policy.controlloop.actorserviceprovider.impl.BidirectionalTopicOperation;
import org.onap.policy.controlloop.actorserviceprovider.parameters.BidirectionalTopicConfig;
import org.onap.policy.controlloop.actorserviceprovider.parameters.ControlLoopOperationParams;
import org.onap.policy.controlloop.actorserviceprovider.topic.SelectorKey;
-import org.onap.policy.controlloop.policy.PolicyResult;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
* Sets the message to the status description, if available.
*/
@Override
- public OperationOutcome setOutcome(OperationOutcome outcome, PolicyResult result, Response response) {
+ public OperationOutcome setOutcome(OperationOutcome outcome, OperationResult result, Response response) {
outcome.setResponse(response);
if (response.getStatus() == null || response.getStatus().getDescription() == null) {
throw new IllegalStateException("target vnf-id could not be determined");
}
- GenericVnf genvnf = cq.getGenericVnfByModelInvariantId(params.getTarget().getResourceID());
+ GenericVnf genvnf = cq.getGenericVnfByModelInvariantId(params.getTargetEntityIds()
+ .get(ControlLoopOperationParams.PARAMS_ENTITY_RESOURCEID));
if (genvnf == null) {
logger.info("{}: target entity could not be found for {}", getFullName(), params.getRequestId());
throw new IllegalArgumentException("target vnf-id could not be found");
import org.onap.policy.appc.Request;
import org.onap.policy.appc.ResponseCode;
import org.onap.policy.appc.ResponseStatus;
+import org.onap.policy.controlloop.actorserviceprovider.OperationResult;
import org.onap.policy.controlloop.actorserviceprovider.impl.BidirectionalTopicOperation.Status;
import org.onap.policy.controlloop.actorserviceprovider.parameters.BidirectionalTopicConfig;
import org.onap.policy.controlloop.actorserviceprovider.parameters.ControlLoopOperationParams;
-import org.onap.policy.controlloop.policy.PolicyResult;
public class AppcOperationTest extends BasicAppcOperation {
private AppcOperation oper;
// null status
response.setStatus(null);
- assertSame(outcome, oper.setOutcome(outcome, PolicyResult.SUCCESS, response));
- assertEquals(PolicyResult.SUCCESS, outcome.getResult());
+ assertSame(outcome, oper.setOutcome(outcome, OperationResult.SUCCESS, response));
+ assertEquals(OperationResult.SUCCESS, outcome.getResult());
assertNotNull(outcome.getMessage());
assertSame(response, outcome.getResponse());
response.setStatus(status);
// null description
status.setDescription(null);
- assertSame(outcome, oper.setOutcome(outcome, PolicyResult.FAILURE, response));
- assertEquals(PolicyResult.FAILURE, outcome.getResult());
+ assertSame(outcome, oper.setOutcome(outcome, OperationResult.FAILURE, response));
+ assertEquals(OperationResult.FAILURE, outcome.getResult());
assertNotNull(outcome.getMessage());
assertSame(response, outcome.getResponse());
status.setDescription(MY_DESCRIPTION);
- for (PolicyResult result : PolicyResult.values()) {
+ for (OperationResult result : OperationResult.values()) {
assertSame(outcome, oper.setOutcome(outcome, result, response));
assertEquals(result, outcome.getResult());
assertEquals(MY_DESCRIPTION, outcome.getMessage());
import org.onap.policy.common.utils.coder.StandardCoderObject;
import org.onap.policy.controlloop.actor.test.BasicBidirectionalTopicOperation;
import org.onap.policy.controlloop.actorserviceprovider.OperationOutcome;
+import org.onap.policy.controlloop.actorserviceprovider.OperationResult;
import org.onap.policy.controlloop.actorserviceprovider.Util;
import org.onap.policy.controlloop.actorserviceprovider.impl.OperationMaker;
import org.onap.policy.controlloop.actorserviceprovider.parameters.BidirectionalTopicConfig;
-import org.onap.policy.controlloop.policy.PolicyResult;
-import org.onap.policy.controlloop.policy.Target;
+import org.onap.policy.controlloop.actorserviceprovider.parameters.ControlLoopOperationParams;
import org.onap.policy.simulators.AppcLegacyTopicServer;
import org.onap.policy.simulators.TopicServer;
import org.powermock.reflect.Whitebox;
super.tearDownBasic();
}
+ @Override
protected TopicServer<Request> makeServer(TopicSink sink, TopicSource source) {
return new AppcLegacyTopicServer(sink, source);
}
assertTrue(future2.isDone());
outcome = future2.get();
- assertEquals(PolicyResult.SUCCESS, outcome.getResult());
+ assertEquals(OperationResult.SUCCESS, outcome.getResult());
assertEquals(MY_DESCRIPTION, outcome.getMessage());
}
protected void makeContext() {
super.makeContext();
- Target target = new Target();
- target.setResourceID(RESOURCE_ID);
+ Map<String, String> entities = Map.of(ControlLoopOperationParams.PARAMS_ENTITY_RESOURCEID, RESOURCE_ID);
- params = params.toBuilder().target(target).build();
+ params = params.toBuilder().targetEntityIds(entities).build();
}
/**
import org.onap.policy.common.utils.coder.CoderException;
import org.onap.policy.controlloop.actorserviceprovider.OperationOutcome;
import org.onap.policy.controlloop.actorserviceprovider.OperationProperties;
+import org.onap.policy.controlloop.actorserviceprovider.OperationResult;
import org.onap.policy.controlloop.actorserviceprovider.controlloop.ControlLoopEventContext;
import org.onap.policy.controlloop.actorserviceprovider.parameters.BidirectionalTopicConfig;
import org.onap.policy.controlloop.actorserviceprovider.parameters.BidirectionalTopicParams;
-import org.onap.policy.controlloop.policy.PolicyResult;
public class ModifyConfigOperationTest extends BasicAppcOperation {
oper.setProperty(OperationProperties.AAI_RESOURCE_VNF, genvnf);
outcome = oper.start().get();
- assertEquals(PolicyResult.SUCCESS, outcome.getResult());
+ assertEquals(OperationResult.SUCCESS, outcome.getResult());
assertTrue(outcome.getResponse() instanceof Response);
}
future2.complete(params.makeOutcome(null));
assertTrue(executor.runAll(100));
assertTrue(future3.isDone());
- assertEquals(PolicyResult.SUCCESS, future3.get().getResult());
+ assertEquals(OperationResult.SUCCESS, future3.get().getResult());
}
/**
import org.onap.policy.common.utils.coder.CoderException;
import org.onap.policy.controlloop.actorserviceprovider.OperationOutcome;
import org.onap.policy.controlloop.actorserviceprovider.OperationProperties;
+import org.onap.policy.controlloop.actorserviceprovider.OperationResult;
import org.onap.policy.controlloop.actorserviceprovider.impl.BidirectionalTopicOperation;
import org.onap.policy.controlloop.actorserviceprovider.parameters.BidirectionalTopicConfig;
import org.onap.policy.controlloop.actorserviceprovider.parameters.ControlLoopOperationParams;
import org.onap.policy.controlloop.actorserviceprovider.topic.SelectorKey;
-import org.onap.policy.controlloop.policy.PolicyResult;
public class AppcLcmOperation extends BidirectionalTopicOperation<AppcLcmDmaapWrapper, AppcLcmDmaapWrapper> {
* Sets the message to the status description, if available.
*/
@Override
- public OperationOutcome setOutcome(OperationOutcome outcome, PolicyResult result, AppcLcmDmaapWrapper response) {
+ public OperationOutcome setOutcome(OperationOutcome outcome, OperationResult result, AppcLcmDmaapWrapper response) {
outcome.setResponse(response);
AppcLcmResponseStatus status = getStatus(response);
import static org.mockito.Mockito.when;
import java.util.Arrays;
+import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.onap.policy.controlloop.actor.test.BasicBidirectionalTopicOperation;
import org.onap.policy.controlloop.actorserviceprovider.OperationOutcome;
import org.onap.policy.controlloop.actorserviceprovider.OperationProperties;
+import org.onap.policy.controlloop.actorserviceprovider.OperationResult;
import org.onap.policy.controlloop.actorserviceprovider.controlloop.ControlLoopEventContext;
import org.onap.policy.controlloop.actorserviceprovider.impl.BidirectionalTopicOperation.Status;
import org.onap.policy.controlloop.actorserviceprovider.parameters.BidirectionalTopicConfig;
import org.onap.policy.controlloop.actorserviceprovider.parameters.BidirectionalTopicParams;
-import org.onap.policy.controlloop.policy.PolicyResult;
-import org.onap.policy.controlloop.policy.Target;
+import org.onap.policy.controlloop.actorserviceprovider.parameters.ControlLoopOperationParams;
import org.onap.policy.simulators.AppcLcmTopicServer;
import org.onap.policy.simulators.TopicServer;
super.tearDownBasic();
}
+ @Override
protected TopicServer<AppcLcmDmaapWrapper> makeServer(TopicSink sink, TopicSource source) {
return new AppcLcmTopicServer(sink, source);
}
};
outcome = oper.start().get();
- assertEquals(PolicyResult.SUCCESS, outcome.getResult());
+ assertEquals(OperationResult.SUCCESS, outcome.getResult());
assertTrue(outcome.getResponse() instanceof AppcLcmDmaapWrapper);
}
assertTrue(executor.runAll(100));
assertTrue(future2.isDone());
outcome = future2.get();
- assertEquals(PolicyResult.SUCCESS, outcome.getResult());
+ assertEquals(OperationResult.SUCCESS, outcome.getResult());
}
@Test
@Test
public void testSetOutcome() {
- oper.setOutcome(outcome, PolicyResult.SUCCESS, response);
- assertEquals(PolicyResult.SUCCESS, outcome.getResult());
+ oper.setOutcome(outcome, OperationResult.SUCCESS, response);
+ assertEquals(OperationResult.SUCCESS, outcome.getResult());
assertEquals(MY_MESSAGE, outcome.getMessage());
assertSame(response, outcome.getResponse());
// failure
- oper.setOutcome(outcome, PolicyResult.FAILURE, response);
- assertEquals(PolicyResult.FAILURE, outcome.getResult());
+ oper.setOutcome(outcome, OperationResult.FAILURE, response);
+ assertEquals(OperationResult.FAILURE, outcome.getResult());
assertEquals(MY_MESSAGE, outcome.getMessage());
assertSame(response, outcome.getResponse());
// null message
response.getBody().getOutput().getStatus().setMessage(null);
- oper.setOutcome(outcome, PolicyResult.SUCCESS, response);
+ oper.setOutcome(outcome, OperationResult.SUCCESS, response);
assertEquals(ControlLoopOperation.SUCCESS_MSG, outcome.getMessage());
assertSame(response, outcome.getResponse());
// null status
response.getBody().getOutput().setStatus(null);
- oper.setOutcome(outcome, PolicyResult.SUCCESS, response);
+ oper.setOutcome(outcome, OperationResult.SUCCESS, response);
assertEquals(ControlLoopOperation.SUCCESS_MSG, outcome.getMessage());
assertSame(response, outcome.getResponse());
}
protected void makeContext() {
super.makeContext();
- Target target = new Target();
- target.setResourceID(RESOURCE_ID);
+ Map<String, String> targetEntities = new HashMap<>();
+ targetEntities.put(ControlLoopOperationParams.PARAMS_ENTITY_RESOURCEID, RESOURCE_ID);
- params = params.toBuilder().target(target).build();
+ params = params.toBuilder().targetEntityIds(targetEntities).build();
}
@Override
import org.onap.ccsdk.cds.controllerblueprints.processing.api.ExecutionServiceOutput;
import org.onap.policy.cds.api.CdsProcessorListener;
import org.onap.policy.controlloop.actorserviceprovider.OperationOutcome;
-import org.onap.policy.controlloop.policy.PolicyResult;
+import org.onap.policy.controlloop.actorserviceprovider.OperationResult;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
LOGGER.info("CDS is processing the message: {}", message);
break;
case EVENT_COMPONENT_EXECUTED:
- outcome.setResult(PolicyResult.SUCCESS);
+ outcome.setResult(OperationResult.SUCCESS);
outcome.setResponse(message);
future.complete(outcome);
break;
default:
- outcome.setResult(PolicyResult.FAILURE);
+ outcome.setResult(OperationResult.FAILURE);
outcome.setResponse(message);
future.complete(outcome);
break;
import org.onap.policy.controlloop.actor.cds.request.CdsActionRequest;
import org.onap.policy.controlloop.actorserviceprovider.OperationOutcome;
import org.onap.policy.controlloop.actorserviceprovider.OperationProperties;
+import org.onap.policy.controlloop.actorserviceprovider.TargetType;
import org.onap.policy.controlloop.actorserviceprovider.Util;
import org.onap.policy.controlloop.actorserviceprovider.impl.OperationPartial;
import org.onap.policy.controlloop.actorserviceprovider.parameters.ControlLoopOperationParams;
import org.onap.policy.controlloop.actorserviceprovider.pipeline.PipelineControllerFuture;
-import org.onap.policy.controlloop.policy.TargetType;
/**
* Operation that uses gRPC to send request to CDS.
super(params, config, Collections.emptyList());
this.config = config;
- if (TargetType.PNF.equals(params.getTarget().getType())) {
+ if (TargetType.PNF.equals(params.getTargetType())) {
aaiRequestor = this::getPnf;
aaiConverter = this::convertPnfToAaiProperties;
} else {
@Override
public List<String> getPropertyNames() {
- return (TargetType.PNF.equals(params.getTarget().getType()) ? PNF_PROPERTY_NAMES : VNF_PROPERTY_NAMES);
+ return (TargetType.PNF.equals(params.getTargetType()) ? PNF_PROPERTY_NAMES : VNF_PROPERTY_NAMES);
}
/**
AaiCqResponse aaicq = params.getContext().getProperty(AaiCqResponse.CONTEXT_KEY);
- genericVnf = aaicq.getGenericVnfByModelInvariantId(params.getTarget().getResourceID());
+ genericVnf = aaicq.getGenericVnfByModelInvariantId(params.getTargetEntityIds()
+ .get(ControlLoopOperationParams.PARAMS_ENTITY_RESOURCEID));
if (genericVnf == null) {
throw new IllegalArgumentException("Target generic vnf could not be found");
}
import org.onap.ccsdk.cds.controllerblueprints.common.api.Status;
import org.onap.ccsdk.cds.controllerblueprints.processing.api.ExecutionServiceOutput;
import org.onap.policy.controlloop.actorserviceprovider.OperationOutcome;
-import org.onap.policy.controlloop.policy.PolicyResult;
+import org.onap.policy.controlloop.actorserviceprovider.OperationResult;
public class GrpcActorServiceManagerTest {
output = ExecutionServiceOutput.newBuilder().setStatus(status).build();
manager.onMessage(output);
OperationOutcome outcome = future.get(2, TimeUnit.SECONDS);
- assertEquals(PolicyResult.SUCCESS, outcome.getResult());
+ assertEquals(OperationResult.SUCCESS, outcome.getResult());
assertSame(output, outcome.getResponse());
}
output = ExecutionServiceOutput.newBuilder().setStatus(status).build();
manager.onMessage(output);
OperationOutcome outcome = future.get(2, TimeUnit.SECONDS);
- assertEquals(PolicyResult.FAILURE, outcome.getResult());
+ assertEquals(OperationResult.FAILURE, outcome.getResult());
assertSame(output, outcome.getResponse());
}
import org.onap.policy.controlloop.actorserviceprovider.ActorService;
import org.onap.policy.controlloop.actorserviceprovider.OperationOutcome;
import org.onap.policy.controlloop.actorserviceprovider.OperationProperties;
+import org.onap.policy.controlloop.actorserviceprovider.OperationResult;
+import org.onap.policy.controlloop.actorserviceprovider.TargetType;
import org.onap.policy.controlloop.actorserviceprovider.controlloop.ControlLoopEventContext;
import org.onap.policy.controlloop.actorserviceprovider.parameters.ControlLoopOperationParams;
-import org.onap.policy.controlloop.policy.PolicyResult;
-import org.onap.policy.controlloop.policy.Target;
-import org.onap.policy.controlloop.policy.TargetType;
import org.onap.policy.simulators.CdsSimulator;
import org.onap.policy.simulators.Util;
private CdsServerProperties cdsProps;
private VirtualControlLoopEvent onset;
private PseudoExecutor executor;
- private Target target;
+ private TargetType targetType;
+ private Map<String, String> targetEntityIds;
private ControlLoopOperationParams params;
private GrpcConfig config;
private CompletableFuture<OperationOutcome> cqFuture;
// Setup executor
executor = new PseudoExecutor();
- target = new Target();
- target.setType(TargetType.VM);
- target.setResourceID(RESOURCE_ID);
+ targetType = TargetType.VM;
+ targetEntityIds = new HashMap<>();
+ targetEntityIds.put(ControlLoopOperationParams.PARAMS_ENTITY_RESOURCEID, RESOURCE_ID);
cqFuture = new CompletableFuture<>();
when(context.obtain(eq(AaiCqResponse.CONTEXT_KEY), any())).thenReturn(cqFuture);
when(context.getEvent()).thenReturn(onset);
- params = ControlLoopOperationParams.builder().actor(CdsActorConstants.CDS_ACTOR).operation(GrpcOperation.NAME)
- .context(context).actorService(new ActorService()).targetEntity(TARGET_ENTITY).target(target)
- .build();
+ params = ControlLoopOperationParams.builder().actor(CdsActorConstants.CDS_ACTOR)
+ .operation(GrpcOperation.NAME).context(context).actorService(new ActorService())
+ .targetEntity(TARGET_ENTITY).targetType(targetType).targetEntityIds(targetEntityIds)
+ .build();
}
/**
Map<String, Object> payload = Map.of("artifact_name", "my_artifact", "artifact_version", "1.0");
params = ControlLoopOperationParams.builder().actor(CdsActorConstants.CDS_ACTOR).operation("subscribe")
- .context(context).actorService(new ActorService()).targetEntity(TARGET_ENTITY).target(target)
+ .context(context).actorService(new ActorService()).targetEntity(TARGET_ENTITY)
+ .targetType(targetType).targetEntityIds(targetEntityIds)
.retry(0).timeoutSec(5).executor(blockingExecutor).payload(payload).build();
cdsProps.setHost("localhost");
};
OperationOutcome outcome = operation.start().get();
- assertEquals(PolicyResult.SUCCESS, outcome.getResult());
+ assertEquals(OperationResult.SUCCESS, outcome.getResult());
assertTrue(outcome.getResponse() instanceof ExecutionServiceOutput);
}
Map<String, Object> payload = Map.of("artifact_name", "my_artifact", "artifact_version", "1.0");
params = ControlLoopOperationParams.builder().actor(CdsActorConstants.CDS_ACTOR).operation("subscribe")
- .context(context).actorService(new ActorService()).targetEntity(TARGET_ENTITY).target(target)
+ .context(context).actorService(new ActorService()).targetEntity(TARGET_ENTITY)
+ .targetType(targetType).targetEntityIds(targetEntityIds)
.retry(0).timeoutSec(5).executor(blockingExecutor).payload(payload).preprocessed(true).build();
cdsProps.setHost("localhost");
operation.setProperty(OperationProperties.OPT_CDS_GRPC_AAI_PROPERTIES, Collections.emptyMap());
OperationOutcome outcome = operation.start().get();
- assertEquals(PolicyResult.SUCCESS, outcome.getResult());
+ assertEquals(OperationResult.SUCCESS, outcome.getResult());
assertTrue(outcome.getResponse() instanceof ExecutionServiceOutput);
}
/*
* check PNF case
*/
- target.setType(TargetType.PNF);
+ params = params.toBuilder().targetType(TargetType.PNF).build();
operation = new GrpcOperation(params, config);
// @formatter:off
cqFuture.complete(params.makeOutcome(null));
assertTrue(executor.runAll(100));
- assertEquals(PolicyResult.SUCCESS, future3.get(2, TimeUnit.SECONDS).getResult());
+ assertEquals(OperationResult.SUCCESS, future3.get(2, TimeUnit.SECONDS).getResult());
assertTrue(future3.isDone());
}
public void testStartPreprocessorAsyncPnf() throws InterruptedException, ExecutionException, TimeoutException {
AtomicBoolean guardStarted = new AtomicBoolean();
- target.setType(TargetType.PNF);
+ params = params.toBuilder().targetType(TargetType.PNF).build();
operation = new GrpcOperation(params, config) {
@Override
cqFuture.complete(params.makeOutcome(null));
assertTrue(executor.runAll(100));
- assertEquals(PolicyResult.SUCCESS, future3.get(2, TimeUnit.SECONDS).getResult());
+ assertEquals(OperationResult.SUCCESS, future3.get(2, TimeUnit.SECONDS).getResult());
assertTrue(future3.isDone());
}
@Test
public void testStartOperationAsyncPnf() throws Exception {
- target.setType(TargetType.PNF);
+ targetType = TargetType.PNF;
ControlLoopEventContext context = new ControlLoopEventContext(onset);
loadPnfData(context);
ControlLoopOperationParams params = ControlLoopOperationParams.builder().actor(CdsActorConstants.CDS_ACTOR)
.operation(GrpcOperation.NAME).context(context).actorService(new ActorService())
- .targetEntity(TARGET_ENTITY).target(target).payload(payloadMap).build();
+ .targetEntity(TARGET_ENTITY).targetType(targetType).targetEntityIds(targetEntityIds)
+ .payload(payloadMap).build();
GrpcConfig config = new GrpcConfig(executor, cdsProps);
operation = new GrpcOperation(params, config);
import org.onap.policy.controlloop.VirtualControlLoopEvent;
import org.onap.policy.controlloop.actor.cds.constants.CdsActorConstants;
import org.onap.policy.controlloop.actorserviceprovider.Operation;
+import org.onap.policy.controlloop.actorserviceprovider.TargetType;
import org.onap.policy.controlloop.actorserviceprovider.Util;
import org.onap.policy.controlloop.actorserviceprovider.controlloop.ControlLoopEventContext;
import org.onap.policy.controlloop.actorserviceprovider.parameters.ControlLoopOperationParams;
import org.onap.policy.controlloop.actorserviceprovider.parameters.ParameterValidationRuntimeException;
-import org.onap.policy.controlloop.policy.Target;
-import org.onap.policy.controlloop.policy.TargetType;
public class GrpcOperatorTest {
public void testBuildOperation() {
VirtualControlLoopEvent event = new VirtualControlLoopEvent();
ControlLoopEventContext context = new ControlLoopEventContext(event);
- Target target = new Target();
- target.setType(TargetType.VM);
ControlLoopOperationParams params = ControlLoopOperationParams.builder().actor(CdsActorConstants.CDS_ACTOR)
- .operation(GrpcOperation.NAME).context(context).target(target).build();
+ .operation(GrpcOperation.NAME).context(context).targetType(TargetType.VM).build();
// not configured yet
assertThatIllegalStateException().isThrownBy(() -> operation.buildOperation(params));
import org.onap.policy.common.endpoints.utils.NetLoggerUtil.EventType;
import org.onap.policy.controlloop.actorserviceprovider.CallbackManager;
import org.onap.policy.controlloop.actorserviceprovider.OperationOutcome;
+import org.onap.policy.controlloop.actorserviceprovider.OperationResult;
import org.onap.policy.controlloop.actorserviceprovider.impl.HttpOperation;
import org.onap.policy.controlloop.actorserviceprovider.impl.OperationPartial;
import org.onap.policy.controlloop.actorserviceprovider.parameters.ControlLoopOperationParams;
import org.onap.policy.controlloop.actorserviceprovider.parameters.HttpConfig;
-import org.onap.policy.controlloop.policy.PolicyResult;
import org.onap.policy.models.decisions.concepts.DecisionRequest;
import org.onap.policy.models.decisions.concepts.DecisionResponse;
import org.slf4j.Logger;
// determine the result
String status = response.getStatus();
if (status == null) {
- outcome.setResult(PolicyResult.FAILURE);
+ outcome.setResult(OperationResult.FAILURE);
outcome.setMessage("response contains no status");
return CompletableFuture.completedFuture(outcome);
}
if (PERMIT.equalsIgnoreCase(status) || INDETERMINATE.equalsIgnoreCase(status)) {
- outcome.setResult(PolicyResult.SUCCESS);
+ outcome.setResult(OperationResult.SUCCESS);
} else {
- outcome.setResult(PolicyResult.FAILURE);
+ outcome.setResult(OperationResult.FAILURE);
}
// set the message
import org.onap.policy.common.utils.coder.CoderException;
import org.onap.policy.controlloop.actor.test.BasicHttpOperation;
import org.onap.policy.controlloop.actorserviceprovider.OperationOutcome;
+import org.onap.policy.controlloop.actorserviceprovider.OperationResult;
import org.onap.policy.controlloop.actorserviceprovider.Util;
-import org.onap.policy.controlloop.policy.PolicyResult;
import org.onap.policy.models.decisions.concepts.DecisionRequest;
import org.onap.policy.models.decisions.concepts.DecisionResponse;
import org.onap.policy.simulators.GuardSimulatorJaxRs;
oper = new DecisionOperation(params, config);
outcome = oper.start().get();
- assertEquals(PolicyResult.SUCCESS, outcome.getResult());
+ assertEquals(OperationResult.SUCCESS, outcome.getResult());
assertTrue(outcome.getResponse() instanceof DecisionResponse);
}
oper = new DecisionOperation(params, config);
outcome = oper.start().get();
- assertEquals(PolicyResult.FAILURE, outcome.getResult());
+ assertEquals(OperationResult.FAILURE, outcome.getResult());
assertTrue(outcome.getResponse() instanceof DecisionResponse);
}
assertTrue(future2.isDone());
outcome = future2.get();
- assertEquals(PolicyResult.SUCCESS, outcome.getResult());
+ assertEquals(OperationResult.SUCCESS, outcome.getResult());
assertEquals(resp, outcome.getResponse());
assertNotNull(oper.getSubRequestId());
assertTrue(future2.isDone());
outcome = future2.get();
- assertEquals(PolicyResult.SUCCESS, outcome.getResult());
+ assertEquals(OperationResult.SUCCESS, outcome.getResult());
assertNull(outcome.getResponse());
// ensure callbacks were invoked
// null status
response.setStatus(null);
- verifyOutcome(response, PolicyResult.FAILURE, "response contains no status");
+ verifyOutcome(response, OperationResult.FAILURE, "response contains no status");
// permit, mixed case
response.setStatus("peRmit");
- verifyOutcome(response, PolicyResult.SUCCESS, "peRmit");
+ verifyOutcome(response, OperationResult.SUCCESS, "peRmit");
// indeterminate, mixed case
response.setStatus("inDETerminate");
- verifyOutcome(response, PolicyResult.SUCCESS, "inDETerminate");
+ verifyOutcome(response, OperationResult.SUCCESS, "inDETerminate");
// deny, mixed case
response.setStatus("deNY");
- verifyOutcome(response, PolicyResult.FAILURE, "deNY");
+ verifyOutcome(response, OperationResult.FAILURE, "deNY");
// unknown status
response.setStatus("unknown");
- verifyOutcome(response, PolicyResult.FAILURE, "unknown");
+ verifyOutcome(response, OperationResult.FAILURE, "unknown");
}
- private void verifyOutcome(DecisionResponse response, PolicyResult expectedResult, String expectedMessage) {
+ private void verifyOutcome(DecisionResponse response, OperationResult expectedResult, String expectedMessage) {
oper.postProcessResponse(outcome, BASE_URI, rawResponse, response);
assertEquals(expectedResult, outcome.getResult());
assertEquals(expectedMessage, outcome.getMessage());
import org.junit.Test;
import org.onap.policy.common.endpoints.http.client.HttpClientFactoryInstance;
import org.onap.policy.controlloop.actorserviceprovider.OperationProperties;
+import org.onap.policy.controlloop.actorserviceprovider.OperationResult;
import org.onap.policy.controlloop.actorserviceprovider.controlloop.ControlLoopEventContext;
import org.onap.policy.controlloop.actorserviceprovider.parameters.HttpConfig;
import org.onap.policy.controlloop.actorserviceprovider.parameters.HttpParams;
-import org.onap.policy.controlloop.policy.PolicyResult;
import org.onap.policy.sdnc.SdncRequest;
import org.onap.policy.sdnc.SdncResponse;
/**
* Set up.
*/
+ @Override
@Before
public void setUp() throws Exception {
super.setUp();
oper.setProperty(OperationProperties.ENRICHMENT_VNF_ID, MY_VNF);
outcome = oper.start().get();
- assertEquals(PolicyResult.SUCCESS, outcome.getResult());
+ assertEquals(OperationResult.SUCCESS, outcome.getResult());
assertTrue(outcome.getResponse() instanceof SdncResponse);
}
import org.onap.policy.common.utils.coder.StandardCoder;
import org.onap.policy.controlloop.actor.test.BasicHttpOperation;
import org.onap.policy.controlloop.actorserviceprovider.OperationOutcome;
+import org.onap.policy.controlloop.actorserviceprovider.OperationResult;
import org.onap.policy.controlloop.actorserviceprovider.impl.OperationMaker;
import org.onap.policy.controlloop.actorserviceprovider.parameters.HttpConfig;
-import org.onap.policy.controlloop.policy.PolicyResult;
import org.onap.policy.sdnc.SdncRequest;
import org.onap.policy.sdnc.SdncResponse;
import org.onap.policy.sdnc.SdncResponseOutput;
assertTrue(future2.isDone());
outcome = future2.get();
- assertEquals(PolicyResult.SUCCESS, outcome.getResult());
+ assertEquals(OperationResult.SUCCESS, outcome.getResult());
assertTrue(outcome.getResponse() instanceof SdncResponse);
assertNotNull(outcome.getSubRequestId());
.withMessageContaining("missing").withMessageContaining(expectedText);
}
+ @Override
protected abstract Map<String, String> makeEnrichment();
}
import org.junit.Test;
import org.onap.policy.common.endpoints.http.client.HttpClientFactoryInstance;
import org.onap.policy.controlloop.actorserviceprovider.OperationProperties;
+import org.onap.policy.controlloop.actorserviceprovider.OperationResult;
import org.onap.policy.controlloop.actorserviceprovider.controlloop.ControlLoopEventContext;
import org.onap.policy.controlloop.actorserviceprovider.parameters.HttpConfig;
import org.onap.policy.controlloop.actorserviceprovider.parameters.HttpParams;
-import org.onap.policy.controlloop.policy.PolicyResult;
import org.onap.policy.sdnc.SdncRequest;
import org.onap.policy.sdnc.SdncResponse;
/**
* Set up.
*/
+ @Override
@Before
public void setUp() throws Exception {
super.setUp();
oper.setProperty(OperationProperties.ENRICHMENT_NETWORK_ID, MY_NETWORK);
outcome = oper.start().get();
- assertEquals(PolicyResult.SUCCESS, outcome.getResult());
+ assertEquals(OperationResult.SUCCESS, outcome.getResult());
assertTrue(outcome.getResponse() instanceof SdncResponse);
}
import java.util.concurrent.CompletableFuture;
import org.onap.policy.controlloop.actorserviceprovider.OperationOutcome;
import org.onap.policy.controlloop.actorserviceprovider.OperationProperties;
+import org.onap.policy.controlloop.actorserviceprovider.OperationResult;
import org.onap.policy.controlloop.actorserviceprovider.impl.BidirectionalTopicOperation;
import org.onap.policy.controlloop.actorserviceprovider.parameters.BidirectionalTopicConfig;
import org.onap.policy.controlloop.actorserviceprovider.parameters.ControlLoopOperationParams;
import org.onap.policy.controlloop.actorserviceprovider.topic.SelectorKey;
-import org.onap.policy.controlloop.policy.PolicyResult;
import org.onap.policy.sdnr.PciBody;
import org.onap.policy.sdnr.PciCommonHeader;
import org.onap.policy.sdnr.PciMessage;
* Sets the message to the status description, if available.
*/
@Override
- public OperationOutcome setOutcome(OperationOutcome outcome, PolicyResult result, PciMessage responseWrapper) {
+ public OperationOutcome setOutcome(OperationOutcome outcome, OperationResult result, PciMessage responseWrapper) {
outcome.setResponse(responseWrapper);
if (responseWrapper.getBody() == null || responseWrapper.getBody().getOutput() == null) {
import org.onap.policy.common.utils.coder.StandardCoderObject;
import org.onap.policy.controlloop.actor.test.BasicBidirectionalTopicOperation;
import org.onap.policy.controlloop.actorserviceprovider.OperationOutcome;
+import org.onap.policy.controlloop.actorserviceprovider.OperationResult;
import org.onap.policy.controlloop.actorserviceprovider.Util;
import org.onap.policy.controlloop.actorserviceprovider.impl.OperationMaker;
import org.onap.policy.controlloop.actorserviceprovider.parameters.BidirectionalTopicConfig;
-import org.onap.policy.controlloop.policy.PolicyResult;
import org.onap.policy.sdnr.PciBody;
import org.onap.policy.sdnr.PciMessage;
import org.onap.policy.sdnr.PciResponse;
super.tearDownBasic();
}
+ @Override
protected TopicServer<PciMessage> makeServer(TopicSink sink, TopicSource source) {
return new SdnrTopicServer(sink, source);
}
assertTrue(future2.isDone());
outcome = future2.get();
- assertEquals(PolicyResult.SUCCESS, outcome.getResult());
+ assertEquals(OperationResult.SUCCESS, outcome.getResult());
}
/**
import org.onap.policy.controlloop.actor.test.BasicBidirectionalTopicOperation;
import org.onap.policy.controlloop.actorserviceprovider.OperationOutcome;
import org.onap.policy.controlloop.actorserviceprovider.OperationProperties;
+import org.onap.policy.controlloop.actorserviceprovider.OperationResult;
import org.onap.policy.controlloop.actorserviceprovider.controlloop.ControlLoopEventContext;
import org.onap.policy.controlloop.actorserviceprovider.impl.BidirectionalTopicOperation.Status;
import org.onap.policy.controlloop.actorserviceprovider.parameters.BidirectionalTopicConfig;
import org.onap.policy.controlloop.actorserviceprovider.parameters.BidirectionalTopicParams;
-import org.onap.policy.controlloop.policy.PolicyResult;
import org.onap.policy.sdnr.PciCommonHeader;
import org.onap.policy.sdnr.PciMessage;
import org.onap.policy.sdnr.PciRequest;
};
outcome = operation.start().get();
- assertEquals(PolicyResult.SUCCESS, outcome.getResult());
+ assertEquals(OperationResult.SUCCESS, outcome.getResult());
assertTrue(outcome.getResponse() instanceof PciMessage);
}
future2.complete(params.makeOutcome(null));
assertTrue(executor.runAll(100));
assertTrue(future3.isDone());
- assertEquals(PolicyResult.SUCCESS, future3.get().getResult());
+ assertEquals(OperationResult.SUCCESS, future3.get().getResult());
}
@Test
}
protected void checkOutcome() {
- assertSame(outcome, operation.setOutcome(outcome, PolicyResult.SUCCESS, response));
- assertEquals(PolicyResult.SUCCESS, outcome.getResult());
+ assertSame(outcome, operation.setOutcome(outcome, OperationResult.SUCCESS, response));
+ assertEquals(OperationResult.SUCCESS, outcome.getResult());
assertNotNull(outcome.getMessage());
assertSame(response, outcome.getResponse());
}
import org.onap.policy.common.utils.coder.StandardCoderObject;
import org.onap.policy.controlloop.actorserviceprovider.OperationOutcome;
import org.onap.policy.controlloop.actorserviceprovider.OperationProperties;
+import org.onap.policy.controlloop.actorserviceprovider.OperationResult;
import org.onap.policy.controlloop.actorserviceprovider.impl.HttpOperation;
import org.onap.policy.controlloop.actorserviceprovider.parameters.ControlLoopOperationParams;
import org.onap.policy.controlloop.actorserviceprovider.parameters.HttpPollingConfig;
-import org.onap.policy.controlloop.policy.PolicyResult;
-import org.onap.policy.controlloop.policy.Target;
import org.onap.policy.so.SoCloudConfiguration;
import org.onap.policy.so.SoModelInfo;
import org.onap.policy.so.SoRequest;
private final String modelCustomizationId;
private final String modelInvariantId;
private final String modelVersionId;
+ private final String modelName;
+ private final String modelVersion;
private final String vfCountKey;
setUsePolling();
- verifyNotNull("Target information", params.getTarget());
+ verifyNotNull("Target information", params.getTargetType());
- this.modelCustomizationId = params.getTarget().getModelCustomizationId();
- this.modelInvariantId = params.getTarget().getModelInvariantId();
- this.modelVersionId = params.getTarget().getModelVersionId();
+ verifyNotNull("Target entity Ids information", params.getTargetEntityIds());
+
+ this.modelCustomizationId = params.getTargetEntityIds()
+ .get(ControlLoopOperationParams.PARAMS_ENTITY_MODEL_CUSTOMIZATION_ID);
+ this.modelInvariantId = params.getTargetEntityIds()
+ .get(ControlLoopOperationParams.PARAMS_ENTITY_MODEL_INVARIANT_ID);
+ this.modelVersionId = params.getTargetEntityIds()
+ .get(ControlLoopOperationParams.PARAMS_ENTITY_MODEL_VERSION_ID);
+ this.modelVersion = params.getTargetEntityIds()
+ .get(ControlLoopOperationParams.PARAMS_ENTITY_MODEL_VERSION);
+ this.modelName = params.getTargetEntityIds()
+ .get(ControlLoopOperationParams.PARAMS_ENTITY_MODEL_NAME);
vfCountKey = SoConstants.VF_COUNT_PREFIX + "[" + modelCustomizationId + "][" + modelInvariantId + "]["
+ modelVersionId + "]";
* the VF count from the custom query.
*/
protected void validateTarget() {
- verifyNotNull("modelCustomizationId", modelCustomizationId);
- verifyNotNull("modelInvariantId", modelInvariantId);
- verifyNotNull("modelVersionId", modelVersionId);
+ verifyNotNull(ControlLoopOperationParams.PARAMS_ENTITY_MODEL_CUSTOMIZATION_ID, modelCustomizationId);
+ verifyNotNull(ControlLoopOperationParams.PARAMS_ENTITY_MODEL_INVARIANT_ID, modelInvariantId);
+ verifyNotNull(ControlLoopOperationParams.PARAMS_ENTITY_MODEL_VERSION_ID, modelVersionId);
}
private void verifyNotNull(String type, Object value) {
* Prepends the message with the http status code.
*/
@Override
- public OperationOutcome setOutcome(OperationOutcome outcome, PolicyResult result, Response rawResponse,
+ public OperationOutcome setOutcome(OperationOutcome outcome, OperationResult result, Response rawResponse,
SoResponse response) {
// set default result and message
setOutcome(outcome, result);
- int code = (result == PolicyResult.FAILURE_TIMEOUT ? SO_RESPONSE_CODE : rawResponse.getStatus());
+ int code = (result == OperationResult.FAILURE_TIMEOUT ? SO_RESPONSE_CODE : rawResponse.getStatus());
outcome.setResponse(response);
outcome.setMessage(code + " " + outcome.getMessage());
}
protected SoModelInfo prepareSoModelInfo() {
- Target target = params.getTarget();
- if (target == null) {
- throw new IllegalArgumentException("missing Target");
- }
-
- if (target.getModelCustomizationId() == null || target.getModelInvariantId() == null
- || target.getModelName() == null || target.getModelVersion() == null
- || target.getModelVersionId() == null) {
- throw new IllegalArgumentException("missing VF Module model");
- }
-
SoModelInfo soModelInfo = new SoModelInfo();
- soModelInfo.setModelCustomizationId(target.getModelCustomizationId());
- soModelInfo.setModelInvariantId(target.getModelInvariantId());
- soModelInfo.setModelName(target.getModelName());
- soModelInfo.setModelVersion(target.getModelVersion());
- soModelInfo.setModelVersionId(target.getModelVersionId());
+ soModelInfo.setModelCustomizationId(modelCustomizationId);
+ soModelInfo.setModelInvariantId(modelInvariantId);
+ soModelInfo.setModelName(modelName);
+ soModelInfo.setModelVersion(modelVersion);
+ soModelInfo.setModelVersionId(modelVersionId);
soModelInfo.setModelType("vfModule");
return soModelInfo;
}
import org.onap.policy.common.endpoints.http.client.HttpClientFactoryInstance;
import org.onap.policy.common.endpoints.http.server.HttpServletServerFactoryInstance;
import org.onap.policy.controlloop.actor.test.BasicHttpOperation;
+import org.onap.policy.controlloop.actorserviceprovider.TargetType;
import org.onap.policy.controlloop.actorserviceprovider.Util;
+import org.onap.policy.controlloop.actorserviceprovider.parameters.ControlLoopOperationParams;
import org.onap.policy.controlloop.actorserviceprovider.parameters.HttpPollingConfig;
-import org.onap.policy.controlloop.policy.Target;
import org.onap.policy.simulators.SoSimulatorJaxRs;
import org.onap.policy.so.SoRequest;
import org.onap.policy.so.SoRequestParameters;
@Mock
protected HttpPollingConfig config;
- protected Target target;
+ protected TargetType targetType;
+ protected Map<String, String> targetEntities = new HashMap<>();
protected SoResponse response;
/**
protected void makeContext() {
super.makeContext();
- target = new Target();
- target.setModelCustomizationId(MODEL_CUSTOM_ID);
- target.setModelInvariantId(MODEL_INVAR_ID);
- target.setModelName(MODEL_NAME);
- target.setModelVersion(MODEL_VERSION);
- target.setModelVersionId(MODEL_VERS_ID);
+ targetType = TargetType.VNF;
- params = params.toBuilder().target(target).build();
+ targetEntities = new HashMap<>();
+ targetEntities.put(ControlLoopOperationParams.PARAMS_ENTITY_MODEL_CUSTOMIZATION_ID, MODEL_CUSTOM_ID);
+ targetEntities.put(ControlLoopOperationParams.PARAMS_ENTITY_MODEL_INVARIANT_ID, MODEL_INVAR_ID);
+ targetEntities.put(ControlLoopOperationParams.PARAMS_ENTITY_MODEL_NAME, MODEL_NAME);
+ targetEntities.put(ControlLoopOperationParams.PARAMS_ENTITY_MODEL_VERSION, MODEL_VERSION);
+ targetEntities.put(ControlLoopOperationParams.PARAMS_ENTITY_MODEL_VERSION_ID, MODEL_VERS_ID);
+
+ params = params.toBuilder().targetType(targetType).targetEntityIds(targetEntities).build();
}
@Override
import java.time.Month;
import java.util.Collections;
import java.util.List;
+import java.util.Map;
import java.util.concurrent.CompletableFuture;
import java.util.function.BiConsumer;
-import java.util.function.Consumer;
import java.util.function.Supplier;
import org.junit.Before;
import org.junit.Test;
import org.onap.policy.controlloop.ControlLoopOperation;
import org.onap.policy.controlloop.actorserviceprovider.OperationOutcome;
import org.onap.policy.controlloop.actorserviceprovider.OperationProperties;
-import org.onap.policy.controlloop.policy.PolicyResult;
+import org.onap.policy.controlloop.actorserviceprovider.OperationResult;
+import org.onap.policy.controlloop.actorserviceprovider.parameters.ControlLoopOperationParams;
import org.onap.policy.so.SoModelInfo;
import org.onap.policy.so.SoRequest;
import org.onap.policy.so.SoRequestInfo;
/**
* Sets up.
*/
+ @Override
@Before
public void setUp() throws Exception {
super.setUp();
assertTrue(oper.isUsePolling());
// check when Target is null
- params = params.toBuilder().target(null).build();
+ params = params.toBuilder().targetType(null).build();
assertThatIllegalArgumentException().isThrownBy(() -> new SoOperation(params, config, PROP_NAMES) {})
.withMessageContaining("Target information");
}
@Test
public void testValidateTarget() {
// check when various fields are null
- verifyNotNull("modelCustomizationId", target::getModelCustomizationId, target::setModelCustomizationId);
- verifyNotNull("modelInvariantId", target::getModelInvariantId, target::setModelInvariantId);
- verifyNotNull("modelVersionId", target::getModelVersionId, target::setModelVersionId);
+ verifyNotNull(ControlLoopOperationParams.PARAMS_ENTITY_MODEL_CUSTOMIZATION_ID, targetEntities);
+ verifyNotNull(ControlLoopOperationParams.PARAMS_ENTITY_MODEL_INVARIANT_ID, targetEntities);
+ verifyNotNull(ControlLoopOperationParams.PARAMS_ENTITY_MODEL_VERSION_ID, targetEntities);
// verify it's still valid
assertThatCode(() -> new VfModuleCreate(params, config)).doesNotThrowAnyException();
}
- private void verifyNotNull(String expectedText, Supplier<String> getter, Consumer<String> setter) {
- String originalValue = getter.get();
+ private void verifyNotNull(String expectedText, Map<String, String> targetEntities) {
+ String originalValue = targetEntities.get(expectedText);
// try with null
- setter.accept(null);
+ targetEntities.put(expectedText, null);
assertThatIllegalArgumentException().isThrownBy(() -> new VfModuleCreate(params, config))
.withMessageContaining(expectedText);
- setter.accept(originalValue);
+ targetEntities.put(expectedText, originalValue);
}
@Test
assertTrue(executor.runAll(100));
assertTrue(future2.isDone());
- assertEquals(PolicyResult.SUCCESS, future2.get().getResult());
+ assertEquals(OperationResult.SUCCESS, future2.get().getResult());
// verify that the count was stored
Integer vfcount = context.getProperty(VF_COUNT_KEY);
public void testSetOutcome() {
// success case
when(rawResponse.getStatus()).thenReturn(200);
- assertSame(outcome, oper.setOutcome(outcome, PolicyResult.SUCCESS, rawResponse, response));
+ assertSame(outcome, oper.setOutcome(outcome, OperationResult.SUCCESS, rawResponse, response));
- assertEquals(PolicyResult.SUCCESS, outcome.getResult());
+ assertEquals(OperationResult.SUCCESS, outcome.getResult());
assertEquals("200 " + ControlLoopOperation.SUCCESS_MSG, outcome.getMessage());
assertSame(response, outcome.getResponse());
// failure case
when(rawResponse.getStatus()).thenReturn(500);
- assertSame(outcome, oper.setOutcome(outcome, PolicyResult.FAILURE, rawResponse, response));
+ assertSame(outcome, oper.setOutcome(outcome, OperationResult.FAILURE, rawResponse, response));
- assertEquals(PolicyResult.FAILURE, outcome.getResult());
+ assertEquals(OperationResult.FAILURE, outcome.getResult());
assertEquals("500 " + ControlLoopOperation.FAILED_MSG, outcome.getMessage());
assertSame(response, outcome.getResponse());
}
@Test
public void testPrepareSoModelInfo() throws CoderException {
- verifyMissingModelInfo(target::getModelCustomizationId, target::setModelCustomizationId);
- verifyMissingModelInfo(target::getModelInvariantId, target::setModelInvariantId);
- verifyMissingModelInfo(target::getModelName, target::setModelName);
- verifyMissingModelInfo(target::getModelVersion, target::setModelVersion);
- verifyMissingModelInfo(target::getModelVersionId, target::setModelVersionId);
-
// valid data
SoModelInfo info = oper.prepareSoModelInfo();
verifyRequest("model.json", info);
// try with null target
- params = params.toBuilder().target(null).build();
+ params = params.toBuilder().targetType(null).build();
assertThatIllegalArgumentException().isThrownBy(() -> new SoOperation(params, config, PROP_NAMES) {})
.withMessageContaining("missing Target");
}
- private void verifyMissingModelInfo(Supplier<String> getter, Consumer<String> setter) {
- String original = getter.get();
-
- setter.accept(null);
- assertThatIllegalArgumentException().isThrownBy(() -> oper.prepareSoModelInfo())
- .withMessage("missing VF Module model");
-
- setter.accept(original);
- }
-
@Test
public void testConstructRequestInfo() throws CoderException {
SoRequestInfo info = oper.constructRequestInfo();
import org.onap.policy.common.utils.coder.CoderException;
import org.onap.policy.controlloop.actorserviceprovider.OperationOutcome;
import org.onap.policy.controlloop.actorserviceprovider.OperationProperties;
+import org.onap.policy.controlloop.actorserviceprovider.OperationResult;
import org.onap.policy.controlloop.actorserviceprovider.parameters.ControlLoopOperationParams;
import org.onap.policy.controlloop.actorserviceprovider.parameters.HttpPollingConfig;
import org.onap.policy.controlloop.actorserviceprovider.parameters.HttpPollingParams;
-import org.onap.policy.controlloop.policy.PolicyResult;
import org.onap.policy.so.SoRequest;
import org.onap.policy.so.SoResponse;
destroyAfterClass();
}
+ @Override
@Before
public void setUp() throws Exception {
super.setUp();
oper = new VfModuleCreate(params, config);
outcome = oper.start().get();
- assertEquals(PolicyResult.SUCCESS, outcome.getResult());
+ assertEquals(OperationResult.SUCCESS, outcome.getResult());
assertTrue(outcome.getResponse() instanceof SoResponse);
}
// run the operation
outcome = oper.start().get();
- assertEquals(PolicyResult.SUCCESS, outcome.getResult());
+ assertEquals(OperationResult.SUCCESS, outcome.getResult());
assertTrue(outcome.getResponse() instanceof SoResponse);
int count = oper.getProperty(OperationProperties.DATA_VF_COUNT);
assertEquals(VfModuleCreate.NAME, oper.getName());
// verify that target validation is done
- params = params.toBuilder().target(null).build();
+ params = params.toBuilder().targetType(null).build();
assertThatIllegalArgumentException().isThrownBy(() -> new VfModuleCreate(params, config))
.withMessageContaining("Target information");
}
provideCqResponse(makeCqResponse());
assertTrue(executor.runAll(100));
assertTrue(future2.isDone());
- assertEquals(PolicyResult.SUCCESS, future2.get().getResult());
+ assertEquals(OperationResult.SUCCESS, future2.get().getResult());
}
@Test
CompletableFuture<OperationOutcome> future2 = oper.start();
outcome = future2.get(5, TimeUnit.SECONDS);
- assertEquals(PolicyResult.SUCCESS, outcome.getResult());
+ assertEquals(OperationResult.SUCCESS, outcome.getResult());
SoResponse resp = outcome.getResponse();
assertNotNull(resp);
CompletableFuture<OperationOutcome> future2 = oper.start();
outcome = future2.get(5, TimeUnit.SECONDS);
- assertEquals(PolicyResult.SUCCESS, outcome.getResult());
+ assertEquals(OperationResult.SUCCESS, outcome.getResult());
}
@Test
import org.onap.policy.common.utils.coder.CoderException;
import org.onap.policy.controlloop.actorserviceprovider.OperationOutcome;
import org.onap.policy.controlloop.actorserviceprovider.OperationProperties;
+import org.onap.policy.controlloop.actorserviceprovider.OperationResult;
import org.onap.policy.controlloop.actorserviceprovider.parameters.ControlLoopOperationParams;
import org.onap.policy.controlloop.actorserviceprovider.parameters.HttpPollingConfig;
import org.onap.policy.controlloop.actorserviceprovider.parameters.HttpPollingParams;
-import org.onap.policy.controlloop.policy.PolicyResult;
import org.onap.policy.so.SoRequest;
import org.onap.policy.so.SoResponse;
/**
* Sets up.
*/
+ @Override
@Before
public void setUp() throws Exception {
super.setUp();
oper = new VfModuleDelete(params, config);
outcome = oper.start().get();
- assertEquals(PolicyResult.SUCCESS, outcome.getResult());
+ assertEquals(OperationResult.SUCCESS, outcome.getResult());
assertTrue(outcome.getResponse() instanceof SoResponse);
}
// run the operation
outcome = oper.start().get();
- assertEquals(PolicyResult.SUCCESS, outcome.getResult());
+ assertEquals(OperationResult.SUCCESS, outcome.getResult());
assertTrue(outcome.getResponse() instanceof SoResponse);
int count = oper.getProperty(OperationProperties.DATA_VF_COUNT);
assertEquals(VfModuleDelete.NAME, oper.getName());
// verify that target validation is done
- params = params.toBuilder().target(null).build();
+ params = params.toBuilder().targetType(null).build();
assertThatIllegalArgumentException().isThrownBy(() -> new MyOperation(params, config))
.withMessageContaining("Target information");
}
provideCqResponse(makeCqResponse());
assertTrue(executor.runAll(100));
assertTrue(future2.isDone());
- assertEquals(PolicyResult.SUCCESS, future2.get().getResult());
+ assertEquals(OperationResult.SUCCESS, future2.get().getResult());
}
@Test
CompletableFuture<OperationOutcome> future2 = oper.start();
outcome = future2.get(5, TimeUnit.SECONDS);
- assertEquals(PolicyResult.SUCCESS, outcome.getResult());
+ assertEquals(OperationResult.SUCCESS, outcome.getResult());
SoResponse resp = outcome.getResponse();
assertNotNull(resp);
CompletableFuture<OperationOutcome> future2 = oper.start();
outcome = future2.get(5, TimeUnit.SECONDS);
- assertEquals(PolicyResult.SUCCESS, outcome.getResult());
+ assertEquals(OperationResult.SUCCESS, outcome.getResult());
}
@Test
import org.onap.policy.controlloop.actorserviceprovider.ActorService;
import org.onap.policy.controlloop.actorserviceprovider.Operation;
import org.onap.policy.controlloop.actorserviceprovider.OperationOutcome;
+import org.onap.policy.controlloop.actorserviceprovider.OperationResult;
import org.onap.policy.controlloop.actorserviceprovider.Operator;
import org.onap.policy.controlloop.actorserviceprovider.controlloop.ControlLoopEventContext;
import org.onap.policy.controlloop.actorserviceprovider.impl.OperationPartial;
import org.onap.policy.controlloop.actorserviceprovider.parameters.ControlLoopOperationParams;
import org.onap.policy.controlloop.actorserviceprovider.spi.Actor;
-import org.onap.policy.controlloop.policy.PolicyResult;
/**
* Superclass for various Operation tests.
when(guardOperator.buildOperation(any())).thenReturn(guardOperation);
outcome = params.makeOutcome(TARGET_ENTITY);
- outcome.setResult(PolicyResult.SUCCESS);
+ outcome.setResult(OperationResult.SUCCESS);
when(guardOperation.start()).thenReturn(CompletableFuture.completedFuture(outcome));
when(service.getActor(AaiConstants.ACTOR_NAME)).thenReturn(cqActor);
protected void provideCqResponse(AaiCqResponse cq) {
context.setProperty(AaiCqResponse.CONTEXT_KEY, cq);
OperationOutcome outcome2 = params.makeOutcome(TARGET_ENTITY);
- outcome2.setResult(PolicyResult.SUCCESS);
+ outcome2.setResult(OperationResult.SUCCESS);
cqFuture.complete(outcome2);
}
}
import org.onap.policy.common.utils.coder.CoderException;
import org.onap.policy.common.utils.resources.ResourceUtils;
import org.onap.policy.controlloop.actorserviceprovider.OperationOutcome;
+import org.onap.policy.controlloop.actorserviceprovider.OperationResult;
import org.onap.policy.controlloop.actorserviceprovider.Util;
import org.onap.policy.controlloop.actorserviceprovider.impl.OperationPartial;
-import org.onap.policy.controlloop.policy.PolicyResult;
public class BasicOperationTest {
private static final String ACTOR = "my-actor";
CompletableFuture<OperationOutcome> future = oper.service.getActor(OperationPartial.GUARD_ACTOR_NAME)
.getOperator(OperationPartial.GUARD_OPERATION_NAME).buildOperation(null).start();
assertTrue(future.isDone());
- assertEquals(PolicyResult.SUCCESS, future.get().getResult());
+ assertEquals(OperationResult.SUCCESS, future.get().getResult());
}
@Test
assertSame(cq, oper.context.getProperty(AaiCqResponse.CONTEXT_KEY));
assertTrue(oper.cqFuture.isDone());
- assertEquals(PolicyResult.SUCCESS, oper.cqFuture.get().getResult());
+ assertEquals(OperationResult.SUCCESS, oper.cqFuture.get().getResult());
}
}
import org.apache.commons.lang3.StringUtils;
import org.onap.policy.controlloop.actorserviceprovider.OperationOutcome;
import org.onap.policy.controlloop.actorserviceprovider.OperationProperties;
+import org.onap.policy.controlloop.actorserviceprovider.OperationResult;
import org.onap.policy.controlloop.actorserviceprovider.impl.HttpOperation;
import org.onap.policy.controlloop.actorserviceprovider.parameters.ControlLoopOperationParams;
import org.onap.policy.controlloop.actorserviceprovider.parameters.HttpConfig;
-import org.onap.policy.controlloop.policy.PolicyResult;
import org.onap.policy.vfc.VfcHealActionVmInfo;
import org.onap.policy.vfc.VfcHealAdditionalParams;
import org.onap.policy.vfc.VfcHealRequest;
* Prepends the message with the http status code.
*/
@Override
- public OperationOutcome setOutcome(OperationOutcome outcome, PolicyResult result, Response rawResponse,
+ public OperationOutcome setOutcome(OperationOutcome outcome, OperationResult result, Response rawResponse,
VfcResponse response) {
// set default result and message
setOutcome(outcome, result);
- int code = (result == PolicyResult.FAILURE_TIMEOUT ? VFC_RESPONSE_CODE : rawResponse.getStatus());
+ int code = (result == OperationResult.FAILURE_TIMEOUT ? VFC_RESPONSE_CODE : rawResponse.getStatus());
outcome.setResponse(response);
outcome.setMessage(code + " " + outcome.getMessage());
import org.onap.policy.common.endpoints.http.client.HttpClientFactoryInstance;
import org.onap.policy.controlloop.actorserviceprovider.OperationOutcome;
import org.onap.policy.controlloop.actorserviceprovider.OperationProperties;
+import org.onap.policy.controlloop.actorserviceprovider.OperationResult;
import org.onap.policy.controlloop.actorserviceprovider.parameters.HttpPollingConfig;
import org.onap.policy.controlloop.actorserviceprovider.parameters.HttpPollingParams;
-import org.onap.policy.controlloop.policy.PolicyResult;
import org.onap.policy.vfc.VfcRequest;
import org.onap.policy.vfc.VfcResponse;
restartOper = new Restart(params, config);
outcome = restartOper.start().get();
- assertEquals(PolicyResult.SUCCESS, outcome.getResult());
+ assertEquals(OperationResult.SUCCESS, outcome.getResult());
assertTrue(outcome.getResponse() instanceof VfcResponse);
}
// run the operation
outcome = restartOper.start().get();
- assertEquals(PolicyResult.SUCCESS, outcome.getResult());
+ assertEquals(OperationResult.SUCCESS, outcome.getResult());
assertTrue(outcome.getResponse() instanceof VfcResponse);
}
--- /dev/null
+/*-
+ * ============LICENSE_START=======================================================
+ * models
+ * ================================================================================
+ * Copyright (C) 2020 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * Licensed 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.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.controlloop.actorserviceprovider;
+
+public enum OperationFinalResult {
+ /**
+ * The Control Loop Policy successfully completed its Operations.
+ */
+ FINAL_SUCCESS("Final_Success"),
+ /**
+ * The Control Loop Policy was an Open Loop and is finished.
+ */
+ FINAL_OPENLOOP("Final_OpenLoop"),
+ /**
+ * The Control Loop Policy failed in its last Operation Policy. NOTE: Previous Operation Policies may have been
+ * successful.
+ */
+ FINAL_FAILURE("Final_Failure"),
+ /**
+ * The Control Loop Policy failed because the overall timeout was met.
+ */
+ FINAL_FAILURE_TIMEOUT("Final_Failure_Timeout"),
+ /**
+ * The Control Loop Policy failed because an Operation Policy met its retry limit.
+ */
+ FINAL_FAILURE_RETRIES("Final_Failure_Retries"),
+ /**
+ * The Control Loop Policy failed due to an exception.
+ */
+ FINAL_FAILURE_EXCEPTION("Final_Failure_Exception"),
+ /**
+ * The Control Loop Policy failed due to guard denied.
+ */
+ FINAL_FAILURE_GUARD("Final_Failure_Guard");
+
+ String result;
+
+ private OperationFinalResult(String result) {
+ this.result = result;
+ }
+
+ /**
+ * Converts to a result object.
+ *
+ * @param result input string
+ * @return result object
+ */
+ public static OperationFinalResult toResult(String result) {
+ if (result.equalsIgnoreCase(FINAL_SUCCESS.toString())) {
+ return FINAL_SUCCESS;
+ }
+ if (result.equalsIgnoreCase(FINAL_OPENLOOP.toString())) {
+ return FINAL_OPENLOOP;
+ }
+ if (result.equalsIgnoreCase(FINAL_FAILURE.toString())) {
+ return FINAL_FAILURE;
+ }
+ if (result.equalsIgnoreCase(FINAL_FAILURE_TIMEOUT.toString())) {
+ return FINAL_FAILURE_TIMEOUT;
+ }
+ if (result.equalsIgnoreCase(FINAL_FAILURE_RETRIES.toString())) {
+ return FINAL_FAILURE_RETRIES;
+ }
+ if (result.equalsIgnoreCase(FINAL_FAILURE_EXCEPTION.toString())) {
+ return FINAL_FAILURE_EXCEPTION;
+ }
+ if (result.equalsIgnoreCase(FINAL_FAILURE_GUARD.toString())) {
+ return FINAL_FAILURE_GUARD;
+ }
+ return null;
+ }
+
+ /**
+ * Check if the result really is a result.
+ *
+ * @param result string
+ * @param finalResult result object
+ * @return true if a result
+ */
+ public static boolean isResult(String result, OperationFinalResult finalResult) {
+ OperationFinalResult toResult = OperationFinalResult.toResult(result);
+ if (toResult == null) {
+ return false;
+ }
+ return toResult.equals(finalResult);
+ }
+
+}
import lombok.NoArgsConstructor;
import lombok.NonNull;
import org.onap.policy.controlloop.ControlLoopOperation;
-import org.onap.policy.controlloop.policy.PolicyResult;
/**
* Outcome from an operation. Objects of this type are passed from one stage to the next.
private Instant start;
private Instant end;
private String subRequestId;
- private PolicyResult result = PolicyResult.SUCCESS;
+ private OperationResult result = OperationResult.SUCCESS;
private String message;
private boolean finalOutcome;
private Object response;
*
* @param result new result
*/
- public void setResult(@NonNull PolicyResult result) {
+ public void setResult(@NonNull OperationResult result) {
this.result = result;
}
}
--- /dev/null
+/*-
+ * ============LICENSE_START=======================================================
+ * ONAP
+ * ================================================================================
+ * Copyright (C) 2020 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * Licensed 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.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.controlloop.actorserviceprovider;
+
+public enum OperationResult {
+ /**
+ * Operation was successful.
+ */
+ SUCCESS("Success"),
+ /**
+ * Operation failed.
+ */
+ FAILURE("Failure"),
+ /**
+ * Operation failed due to maximum retries being met.
+ */
+ FAILURE_RETRIES("Failure_Retries"),
+ /**
+ * Operation failed due to timeout occurring.
+ */
+ FAILURE_TIMEOUT("Failure_Timeout"),
+ /**
+ * Operation failed due to an exception.
+ */
+ FAILURE_EXCEPTION("Failure_Exception"),
+ /**
+ * Operation failed since Guard did not permit.
+ */
+ FAILURE_GUARD("Failure_Guard")
+ ;
+
+
+ private String result;
+ private OperationResult(String result) {
+ this.result = result;
+ }
+
+ @Override
+ public String toString() {
+ return this.result;
+ }
+
+ /**
+ * Convert to a result.
+ *
+ * @param result result string
+ * @return Result object
+ */
+ public static OperationResult toResult(String result) {
+ if (result.equalsIgnoreCase(SUCCESS.toString())) {
+ return SUCCESS;
+ }
+ if (result.equalsIgnoreCase(FAILURE.toString())) {
+ return FAILURE;
+ }
+ if (result.equalsIgnoreCase(FAILURE_RETRIES.toString())) {
+ return FAILURE_RETRIES;
+ }
+ if (result.equalsIgnoreCase(FAILURE_TIMEOUT.toString())) {
+ return FAILURE_TIMEOUT;
+ }
+ if (result.equalsIgnoreCase(FAILURE_EXCEPTION.toString())) {
+ return FAILURE_EXCEPTION;
+ }
+ if (result.equalsIgnoreCase(FAILURE_GUARD.toString())) {
+ return FAILURE_GUARD;
+ }
+ return null;
+ }
+}
--- /dev/null
+/*-
+ * ============LICENSE_START=======================================================
+ * ONAP
+ * ================================================================================
+ * Copyright (C) 2020 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * Licensed 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.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.controlloop.actorserviceprovider;
+
+public enum TargetType {
+ VM("VM"), PNF("PNF"), VFC("VFC"), VNF("VNF"), VFMODULE("VFMODULE");
+
+ private String target;
+
+ private TargetType(String targetType) {
+ this.target = targetType;
+ }
+
+ @Override
+ public String toString() {
+ return this.target;
+ }
+
+ /**
+ * Converts a string to TargetType object if it matches.
+ *
+ * @param targetType String
+ * @return TargetType object
+ */
+ public static TargetType toTargetType(String targetType) {
+ if (targetType == null) {
+ return null;
+ }
+ if (targetType.equalsIgnoreCase(VM.toString())) {
+ return VM;
+ }
+ if (targetType.equalsIgnoreCase(PNF.toString())) {
+ return PNF;
+ }
+ if (targetType.equalsIgnoreCase(VFC.toString())) {
+ return VFC;
+ }
+ if (targetType.equalsIgnoreCase(VNF.toString())) {
+ return VNF;
+ }
+ if (targetType.equalsIgnoreCase(VFMODULE.toString())) {
+ return VFMODULE;
+ }
+
+ return null;
+ }
+}
import org.onap.policy.common.utils.coder.CoderException;
import org.onap.policy.common.utils.coder.StandardCoderObject;
import org.onap.policy.controlloop.actorserviceprovider.OperationOutcome;
+import org.onap.policy.controlloop.actorserviceprovider.OperationResult;
import org.onap.policy.controlloop.actorserviceprovider.parameters.BidirectionalTopicConfig;
import org.onap.policy.controlloop.actorserviceprovider.parameters.ControlLoopOperationParams;
import org.onap.policy.controlloop.actorserviceprovider.pipeline.PipelineControllerFuture;
import org.onap.policy.controlloop.actorserviceprovider.topic.BidirectionalTopicHandler;
import org.onap.policy.controlloop.actorserviceprovider.topic.Forwarder;
-import org.onap.policy.controlloop.policy.PolicyResult;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
case SUCCESS:
logger.info("{}.{} request succeeded for {}", params.getActor(), params.getOperation(),
params.getRequestId());
- setOutcome(outcome, PolicyResult.SUCCESS, response);
+ setOutcome(outcome, OperationResult.SUCCESS, response);
postProcessResponse(outcome, rawResponse, response);
return outcome;
case FAILURE:
logger.info("{}.{} request failed for {}", params.getActor(), params.getOperation(),
params.getRequestId());
- return setOutcome(outcome, PolicyResult.FAILURE, response);
+ return setOutcome(outcome, OperationResult.FAILURE, response);
case STILL_WAITING:
default:
* @param response response used to populate the outcome
* @return the updated operation
*/
- public OperationOutcome setOutcome(OperationOutcome outcome, PolicyResult result, S response) {
+ public OperationOutcome setOutcome(OperationOutcome outcome, OperationResult result, S response) {
outcome.setResponse(response);
return setOutcome(outcome, result);
}
import org.onap.policy.common.endpoints.utils.NetLoggerUtil.EventType;
import org.onap.policy.common.utils.coder.CoderException;
import org.onap.policy.controlloop.actorserviceprovider.OperationOutcome;
+import org.onap.policy.controlloop.actorserviceprovider.OperationResult;
import org.onap.policy.controlloop.actorserviceprovider.parameters.ControlLoopOperationParams;
import org.onap.policy.controlloop.actorserviceprovider.parameters.HttpConfig;
import org.onap.policy.controlloop.actorserviceprovider.parameters.HttpParams;
import org.onap.policy.controlloop.actorserviceprovider.parameters.HttpPollingConfig;
import org.onap.policy.controlloop.actorserviceprovider.pipeline.PipelineControllerFuture;
-import org.onap.policy.controlloop.policy.PolicyResult;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
if (!isSuccess(rawResponse, response)) {
logger.info("{}.{} request failed with http error code {} for {}", params.getActor(), params.getOperation(),
rawResponse.getStatus(), params.getRequestId());
- return CompletableFuture.completedFuture(setOutcome(outcome, PolicyResult.FAILURE, rawResponse, response));
+ return CompletableFuture.completedFuture(
+ setOutcome(outcome, OperationResult.FAILURE, rawResponse, response));
}
logger.info("{}.{} request succeeded for {}", params.getActor(), params.getOperation(), params.getRequestId());
- setOutcome(outcome, PolicyResult.SUCCESS, rawResponse, response);
+ setOutcome(outcome, OperationResult.SUCCESS, rawResponse, response);
return postProcessResponse(outcome, url, rawResponse, response);
}
* @param response decoded response
* @return the updated operation
*/
- public OperationOutcome setOutcome(OperationOutcome outcome, PolicyResult result, Response rawResponse,
+ public OperationOutcome setOutcome(OperationOutcome outcome, OperationResult result, Response rawResponse,
T response) {
outcome.setResponse(response);
logger.info("{}.{} request succeeded for {}", params.getActor(), params.getOperation(),
params.getRequestId());
return CompletableFuture
- .completedFuture(setOutcome(outcome, PolicyResult.SUCCESS, rawResponse, response));
+ .completedFuture(setOutcome(outcome, OperationResult.SUCCESS, rawResponse, response));
case FAILURE:
logger.info("{}.{} request failed for {}", params.getActor(), params.getOperation(),
params.getRequestId());
return CompletableFuture
- .completedFuture(setOutcome(outcome, PolicyResult.FAILURE, rawResponse, response));
+ .completedFuture(setOutcome(outcome, OperationResult.FAILURE, rawResponse, response));
case STILL_WAITING:
default:
if (pollCount++ >= cfg.getMaxPolls()) {
logger.warn("{}: execeeded 'poll' limit {} for {}", getFullName(), cfg.getMaxPolls(),
params.getRequestId());
- setOutcome(outcome, PolicyResult.FAILURE_TIMEOUT);
+ setOutcome(outcome, OperationResult.FAILURE_TIMEOUT);
return CompletableFuture.completedFuture(outcome);
}
import org.onap.policy.controlloop.actorserviceprovider.Operation;
import org.onap.policy.controlloop.actorserviceprovider.OperationOutcome;
import org.onap.policy.controlloop.actorserviceprovider.OperationProperties;
+import org.onap.policy.controlloop.actorserviceprovider.OperationResult;
import org.onap.policy.controlloop.actorserviceprovider.parameters.ControlLoopOperationParams;
import org.onap.policy.controlloop.actorserviceprovider.parameters.OperatorConfig;
import org.onap.policy.controlloop.actorserviceprovider.pipeline.PipelineControllerFuture;
-import org.onap.policy.controlloop.policy.PolicyResult;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
return config.getBlockingExecutor();
}
+ @Override
public String getActorName() {
return params.getActor();
}
+ @Override
public String getName() {
return params.getOperation();
}
// TODO need a FAILURE_MISSING_DATA (e.g., A&AI)
outcome2.setFinalOutcome(true);
- outcome2.setResult(PolicyResult.FAILURE_GUARD);
+ outcome2.setResult(OperationResult.FAILURE_GUARD);
outcome2.setMessage(outcome != null ? outcome.getMessage() : null);
// @formatter:off
* @return {@code true} if the outcome was successful
*/
protected boolean isSuccess(OperationOutcome outcome) {
- return (outcome != null && outcome.getResult() == PolicyResult.SUCCESS);
+ return (outcome != null && outcome.getResult() == OperationResult.SUCCESS);
}
/**
* <i>and</i> was associated with this operator, {@code false} otherwise
*/
protected boolean isActorFailed(OperationOutcome outcome) {
- return (isSameOperation(outcome) && outcome.getResult() == PolicyResult.FAILURE);
+ return (isSameOperation(outcome) && outcome.getResult() == OperationResult.FAILURE);
}
/**
outcome = origOutcome;
} else {
logger.warn("{}: null outcome; treating as a failure for {}", getFullName(), params.getRequestId());
- outcome = this.setOutcome(params.makeOutcome(getTargetEntity()), PolicyResult.FAILURE);
+ outcome = this.setOutcome(params.makeOutcome(getTargetEntity()), OperationResult.FAILURE);
}
// ensure correct actor/operation
outcome.setOperation(getName());
// determine if we should retry, based on the result
- if (outcome.getResult() != PolicyResult.FAILURE) {
+ if (outcome.getResult() != OperationResult.FAILURE) {
// do not retry success or other failure types (e.g., exception)
outcome.setFinalOutcome(true);
return outcome;
* FAILURE_RETRIES
*/
logger.info("operation {} retries exhausted for {}", getFullName(), params.getRequestId());
- outcome.setResult(PolicyResult.FAILURE_RETRIES);
+ outcome.setResult(OperationResult.FAILURE_RETRIES);
outcome.setFinalOutcome(true);
}
* @return the updated operation
*/
public OperationOutcome setOutcome(OperationOutcome operation, Throwable thrown) {
- PolicyResult result = (isTimeout(thrown) ? PolicyResult.FAILURE_TIMEOUT : PolicyResult.FAILURE_EXCEPTION);
+ OperationResult result = (isTimeout(thrown) ? OperationResult.FAILURE_TIMEOUT
+ : OperationResult.FAILURE_EXCEPTION);
return setOutcome(operation, result);
}
* @param result result of the operation
* @return the updated operation
*/
- public OperationOutcome setOutcome(OperationOutcome operation, PolicyResult result) {
+ public OperationOutcome setOutcome(OperationOutcome operation, OperationResult result) {
logger.trace("{}: set outcome {} for {}", getFullName(), result, params.getRequestId());
operation.setResult(result);
- operation.setMessage(result == PolicyResult.SUCCESS ? ControlLoopOperation.SUCCESS_MSG
+ operation.setMessage(result == OperationResult.SUCCESS ? ControlLoopOperation.SUCCESS_MSG
: ControlLoopOperation.FAILED_MSG);
return operation;
import org.onap.policy.controlloop.actorserviceprovider.ActorService;
import org.onap.policy.controlloop.actorserviceprovider.Operation;
import org.onap.policy.controlloop.actorserviceprovider.OperationOutcome;
+import org.onap.policy.controlloop.actorserviceprovider.TargetType;
import org.onap.policy.controlloop.actorserviceprovider.Util;
import org.onap.policy.controlloop.actorserviceprovider.controlloop.ControlLoopEventContext;
-import org.onap.policy.controlloop.policy.Target;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class ControlLoopOperationParams {
private static final Logger logger = LoggerFactory.getLogger(ControlLoopOperationParams.class);
+ public static final String PARAMS_ENTITY_RESOURCEID = "resourceID";
+ public static final String PARAMS_ENTITY_MODEL_INVARIANT_ID = "modelInvariantId";
+ public static final String PARAMS_ENTITY_MODEL_VERSION_ID = "modelVersionId";
+ public static final String PARAMS_ENTITY_MODEL_NAME = "modelName";
+ public static final String PARAMS_ENTITY_MODEL_VERSION = "modelVersion";
+ public static final String PARAMS_ENTITY_MODEL_CUSTOMIZATION_ID = "modelCustomizationId";
+
/**
* Actor name.
*/
private Integer retry;
/**
- * The Target information, extracted from the Policy. May be {@code null}, depending
+ * The Target Type information, extracted from the Policy. May be {@code null}, depending
* on the requirement of the operation to be invoked.
*/
- private Target target;
+ private TargetType targetType;
+
+ /**
+ * Target entitiy ids, extracted from the Policy. May be (@code null}, depending on
+ * the requirement of the operation to be invoked.
+ */
+ private Map<String, String> targetEntityIds;
/**
* Target entity.
import org.junit.Before;
import org.junit.Test;
import org.onap.policy.controlloop.ControlLoopOperation;
-import org.onap.policy.controlloop.policy.PolicyResult;
public class OperationOutcomeTest {
private static final String ACTOR = "my-actor";
private static final Instant START = Instant.ofEpochMilli(10);
private static final Instant END = Instant.ofEpochMilli(20);
private static final String SUB_REQ_ID = "my-sub-request-id";
- private static final PolicyResult RESULT = PolicyResult.FAILURE_GUARD;
+ private static final OperationResult RESULT = OperationResult.FAILURE_GUARD;
private static final String MESSAGE = "my-message";
private static final String RESPONSE = "my-response";
@Test
public void testSetResult() {
- outcome.setResult(PolicyResult.FAILURE_EXCEPTION);
- assertEquals(PolicyResult.FAILURE_EXCEPTION, outcome.getResult());
+ outcome.setResult(OperationResult.FAILURE_EXCEPTION);
+ assertEquals(OperationResult.FAILURE_EXCEPTION, outcome.getResult());
assertThatThrownBy(() -> outcome.setResult(null));
}
import org.onap.policy.common.utils.coder.StandardCoderObject;
import org.onap.policy.common.utils.time.PseudoExecutor;
import org.onap.policy.controlloop.actorserviceprovider.OperationOutcome;
+import org.onap.policy.controlloop.actorserviceprovider.OperationResult;
import org.onap.policy.controlloop.actorserviceprovider.parameters.BidirectionalTopicConfig;
import org.onap.policy.controlloop.actorserviceprovider.parameters.ControlLoopOperationParams;
import org.onap.policy.controlloop.actorserviceprovider.topic.BidirectionalTopicHandler;
import org.onap.policy.controlloop.actorserviceprovider.topic.Forwarder;
-import org.onap.policy.controlloop.policy.PolicyResult;
public class BidirectionalTopicOperationTest {
private static final CommInfrastructure SINK_INFRA = CommInfrastructure.NOOP;
assertTrue(future.isDone());
assertSame(outcome, future.get());
- assertEquals(PolicyResult.SUCCESS, outcome.getResult());
+ assertEquals(OperationResult.SUCCESS, outcome.getResult());
assertEquals(response, outcome.getResponse());
verify(forwarder).unregister(eq(Arrays.asList(REQ_ID)), eq(listenerCaptor.getValue()));
MyStringOperation oper2 = new MyStringOperation();
assertSame(outcome, oper2.processResponse(outcome, TEXT, null));
- assertEquals(PolicyResult.SUCCESS, outcome.getResult());
+ assertEquals(OperationResult.SUCCESS, outcome.getResult());
assertEquals(TEXT, outcome.getResponse());
}
MyScoOperation oper2 = new MyScoOperation();
assertSame(outcome, oper2.processResponse(outcome, responseText, stdResponse));
- assertEquals(PolicyResult.SUCCESS, outcome.getResult());
+ assertEquals(OperationResult.SUCCESS, outcome.getResult());
assertEquals(stdResponse, outcome.getResponse());
}
stdResponse = coder.decode(responseText, StandardCoderObject.class);
assertSame(outcome, oper.processResponse(outcome, responseText, stdResponse));
- assertEquals(PolicyResult.FAILURE, outcome.getResult());
+ assertEquals(OperationResult.FAILURE, outcome.getResult());
assertEquals(resp, outcome.getResponse());
}
@Test
public void testProcessResponseDecodeOk() throws CoderException {
assertSame(outcome, oper.processResponse(outcome, responseText, stdResponse));
- assertEquals(PolicyResult.SUCCESS, outcome.getResult());
+ assertEquals(OperationResult.SUCCESS, outcome.getResult());
assertEquals(response, outcome.getResponse());
}
import org.onap.policy.common.utils.network.NetworkUtil;
import org.onap.policy.controlloop.VirtualControlLoopEvent;
import org.onap.policy.controlloop.actorserviceprovider.OperationOutcome;
+import org.onap.policy.controlloop.actorserviceprovider.OperationResult;
import org.onap.policy.controlloop.actorserviceprovider.controlloop.ControlLoopEventContext;
import org.onap.policy.controlloop.actorserviceprovider.parameters.ControlLoopOperationParams;
import org.onap.policy.controlloop.actorserviceprovider.parameters.HttpConfig;
import org.onap.policy.controlloop.actorserviceprovider.parameters.HttpParams;
-import org.onap.policy.controlloop.policy.PolicyResult;
public class HttpOperationTest {
assertSame(outcome, future2.get(5, TimeUnit.SECONDS));
assertSame(TEXT, outcome.getResponse());
- assertEquals(PolicyResult.SUCCESS, outcome.getResult());
+ assertEquals(OperationResult.SUCCESS, outcome.getResult());
}
/**
CompletableFuture<OperationOutcome> result = oper.processResponse(outcome, PATH, response);
assertTrue(result.isDone());
assertSame(outcome, result.get());
- assertEquals(PolicyResult.SUCCESS, outcome.getResult());
+ assertEquals(OperationResult.SUCCESS, outcome.getResult());
assertSame(TEXT, outcome.getResponse());
}
CompletableFuture<OperationOutcome> result = oper.processResponse(outcome, PATH, response);
assertTrue(result.isDone());
assertSame(outcome, result.get());
- assertEquals(PolicyResult.FAILURE, outcome.getResult());
+ assertEquals(OperationResult.FAILURE, outcome.getResult());
assertSame(TEXT, outcome.getResponse());
}
CompletableFuture<OperationOutcome> result = oper2.processResponse(outcome, PATH, response);
assertTrue(result.isDone());
assertSame(outcome, result.get());
- assertEquals(PolicyResult.SUCCESS, outcome.getResult());
+ assertEquals(OperationResult.SUCCESS, outcome.getResult());
assertEquals(Integer.valueOf(10), outcome.getResponse());
}
OperationOutcome outcome = runOperation(oper2);
assertNotNull(outcome);
assertEquals(1, nget);
- assertEquals(PolicyResult.SUCCESS, outcome.getResult());
+ assertEquals(OperationResult.SUCCESS, outcome.getResult());
assertTrue(outcome.getResponse() instanceof MyResponse);
}
OperationOutcome outcome = runOperation(oper2);
assertNotNull(outcome);
assertEquals(1, ndelete);
- assertEquals(PolicyResult.SUCCESS, outcome.getResult());
+ assertEquals(OperationResult.SUCCESS, outcome.getResult());
assertTrue(outcome.getResponse() instanceof String);
}
OperationOutcome outcome = runOperation(oper2);
assertNotNull(outcome);
assertEquals(1, npost);
- assertEquals(PolicyResult.SUCCESS, outcome.getResult());
+ assertEquals(OperationResult.SUCCESS, outcome.getResult());
assertTrue(outcome.getResponse() instanceof MyResponse);
}
OperationOutcome outcome = runOperation(oper2);
assertNotNull(outcome);
assertEquals(1, nput);
- assertEquals(PolicyResult.SUCCESS, outcome.getResult());
+ assertEquals(OperationResult.SUCCESS, outcome.getResult());
assertTrue(outcome.getResponse() instanceof MyResponse);
}
import org.mockito.stubbing.Answer;
import org.onap.policy.common.endpoints.http.client.HttpClient;
import org.onap.policy.controlloop.actorserviceprovider.OperationOutcome;
+import org.onap.policy.controlloop.actorserviceprovider.OperationResult;
import org.onap.policy.controlloop.actorserviceprovider.parameters.ControlLoopOperationParams;
import org.onap.policy.controlloop.actorserviceprovider.parameters.HttpConfig;
import org.onap.policy.controlloop.actorserviceprovider.parameters.HttpPollingConfig;
-import org.onap.policy.controlloop.policy.PolicyResult;
/**
* Tests HttpOperation when polling is enabled.
oper.postProcessResponse(outcome, FULL_PATH, rawResponse, response);
assertTrue(future2.isDone());
assertSame(outcome, future2.get());
- assertEquals(PolicyResult.SUCCESS, outcome.getResult());
+ assertEquals(OperationResult.SUCCESS, outcome.getResult());
assertNotNull(oper.getSubRequestId());
assertSame(response, outcome.getResponse());
future2 = oper.postProcessResponse(outcome, FULL_PATH, rawResponse, response);
assertTrue(future2.isDone());
assertSame(outcome, future2.get());
- assertEquals(PolicyResult.FAILURE, outcome.getResult());
+ assertEquals(OperationResult.FAILURE, outcome.getResult());
assertNotNull(oper.getSubRequestId());
assertSame(response, outcome.getResponse());
}
oper.postProcessResponse(outcome, FULL_PATH, rawResponse, response);
assertSame(outcome, future2.get(5, TimeUnit.SECONDS));
- assertEquals(PolicyResult.SUCCESS, outcome.getResult());
+ assertEquals(OperationResult.SUCCESS, outcome.getResult());
assertEquals(2, oper.getPollCount());
/*
future2 = oper.postProcessResponse(outcome, FULL_PATH, rawResponse, response);
assertSame(outcome, future2.get(5, TimeUnit.SECONDS));
- assertEquals(PolicyResult.FAILURE_TIMEOUT, outcome.getResult());
+ assertEquals(OperationResult.FAILURE_TIMEOUT, outcome.getResult());
assertEquals(MAX_POLLS + 1, oper.getPollCount());
oper.resetPollCount();
import org.onap.policy.controlloop.actorserviceprovider.Operation;
import org.onap.policy.controlloop.actorserviceprovider.OperationOutcome;
import org.onap.policy.controlloop.actorserviceprovider.OperationProperties;
+import org.onap.policy.controlloop.actorserviceprovider.OperationResult;
import org.onap.policy.controlloop.actorserviceprovider.Operator;
import org.onap.policy.controlloop.actorserviceprovider.controlloop.ControlLoopEventContext;
import org.onap.policy.controlloop.actorserviceprovider.parameters.ControlLoopOperationParams;
import org.onap.policy.controlloop.actorserviceprovider.parameters.OperatorConfig;
import org.onap.policy.controlloop.actorserviceprovider.spi.Actor;
-import org.onap.policy.controlloop.policy.PolicyResult;
import org.slf4j.LoggerFactory;
public class OperationPartialTest {
private static final int TIMEOUT = 1000;
private static final UUID REQ_ID = UUID.randomUUID();
- private static final List<PolicyResult> FAILURE_RESULTS = Arrays.asList(PolicyResult.values()).stream()
- .filter(result -> result != PolicyResult.SUCCESS).collect(Collectors.toList());
+ private static final List<OperationResult> FAILURE_RESULTS = Arrays.asList(OperationResult.values()).stream()
+ .filter(result -> result != OperationResult.SUCCESS).collect(Collectors.toList());
/**
* Used to attach an appender to the class' logger.
@Test
public void testStart() {
- verifyRun("testStart", 1, 1, PolicyResult.SUCCESS);
+ verifyRun("testStart", 1, 1, OperationResult.SUCCESS);
}
/**
assertNotNull(opstart);
assertNotNull(opend);
- assertEquals(PolicyResult.SUCCESS, opend.getResult());
+ assertEquals(OperationResult.SUCCESS, opend.getResult());
assertEquals(MAX_PARALLEL, numStart);
assertEquals(MAX_PARALLEL, oper.getCount());
public void testStartPreprocessorFailure() {
oper.setPreProc(CompletableFuture.completedFuture(makeFailure()));
- verifyRun("testStartPreprocessorFailure", 1, 0, PolicyResult.FAILURE_GUARD);
+ verifyRun("testStartPreprocessorFailure", 1, 0, OperationResult.FAILURE_GUARD);
}
/**
// arrange for the preprocessor to throw an exception
oper.setPreProc(CompletableFuture.failedFuture(new IllegalStateException(EXPECTED_EXCEPTION)));
- verifyRun("testStartPreprocessorException", 1, 0, PolicyResult.FAILURE_GUARD);
+ verifyRun("testStartPreprocessorException", 1, 0, OperationResult.FAILURE_GUARD);
}
/**
public void testStartGuardAsync() throws Exception {
CompletableFuture<OperationOutcome> future = oper.startGuardAsync();
assertTrue(future.isDone());
- assertEquals(PolicyResult.SUCCESS, future.get().getResult());
+ assertEquals(OperationResult.SUCCESS, future.get().getResult());
// verify the parameters that were passed
ArgumentCaptor<ControlLoopOperationParams> paramsCaptor =
OperationOutcome outcome = new OperationOutcome();
- outcome.setResult(PolicyResult.SUCCESS);
+ outcome.setResult(OperationResult.SUCCESS);
assertTrue(oper.isSuccess(outcome));
- for (PolicyResult failure : FAILURE_RESULTS) {
+ for (OperationResult failure : FAILURE_RESULTS) {
outcome.setResult(failure);
assertFalse("testIsSuccess-" + failure, oper.isSuccess(outcome));
}
OperationOutcome outcome = params.makeOutcome(null);
// incorrect outcome
- outcome.setResult(PolicyResult.SUCCESS);
+ outcome.setResult(OperationResult.SUCCESS);
assertFalse(oper.isActorFailed(outcome));
- outcome.setResult(PolicyResult.FAILURE_RETRIES);
+ outcome.setResult(OperationResult.FAILURE_RETRIES);
assertFalse(oper.isActorFailed(outcome));
// correct outcome
- outcome.setResult(PolicyResult.FAILURE);
+ outcome.setResult(OperationResult.FAILURE);
// incorrect actor
outcome.setActor(MY_SINK);
assertTrue(executor.runAll(MAX_REQUESTS));
assertNotNull(opend);
- assertEquals(PolicyResult.FAILURE_EXCEPTION, opend.getResult());
+ assertEquals(OperationResult.FAILURE_EXCEPTION, opend.getResult());
}
@Test
protected CompletableFuture<OperationOutcome> startOperationAsync(int attempt, OperationOutcome outcome) {
OperationOutcome outcome2 = params.makeOutcome(null);
- outcome2.setResult(PolicyResult.SUCCESS);
+ outcome2.setResult(OperationResult.SUCCESS);
/*
* Create an incomplete future that will timeout after the operation's
}
};
- assertEquals(PolicyResult.FAILURE_TIMEOUT, oper.start().get().getResult());
+ assertEquals(OperationResult.FAILURE_TIMEOUT, oper.start().get().getResult());
}
/**
oper.setMaxFailures(10);
- verifyRun("testSetRetryFlag_testRetryOnFailure_ZeroRetries", 1, 1, PolicyResult.FAILURE);
+ verifyRun("testSetRetryFlag_testRetryOnFailure_ZeroRetries", 1, 1, OperationResult.FAILURE);
}
/**
oper.setMaxFailures(10);
- verifyRun("testSetRetryFlag_testRetryOnFailure_NullRetries", 1, 1, PolicyResult.FAILURE);
+ verifyRun("testSetRetryFlag_testRetryOnFailure_NullRetries", 1, 1, OperationResult.FAILURE);
}
/**
oper.setMaxFailures(10);
verifyRun("testSetRetryFlag_testRetryOnFailure_RetriesExhausted", maxRetries + 1, maxRetries + 1,
- PolicyResult.FAILURE_RETRIES);
+ OperationResult.FAILURE_RETRIES);
}
/**
oper.setMaxFailures(maxFailures);
verifyRun("testSetRetryFlag_testRetryOnFailure_SuccessAfterRetries", maxFailures + 1, maxFailures + 1,
- PolicyResult.SUCCESS);
+ OperationResult.SUCCESS);
}
/**
}
};
- verifyRun("testSetRetryFlag_testRetryOnFailure_NullOutcome", 1, 1, PolicyResult.FAILURE, noop());
+ verifyRun("testSetRetryFlag_testRetryOnFailure_NullOutcome", 1, 1, OperationResult.FAILURE, noop());
}
@Test
@Test
public void testHandlePreprocessorFailureSuccess() {
oper.setPreProc(CompletableFuture.completedFuture(makeSuccess()));
- verifyRun("testHandlePreprocessorFailureTrue", 1, 1, PolicyResult.SUCCESS);
+ verifyRun("testHandlePreprocessorFailureTrue", 1, 1, OperationResult.SUCCESS);
}
/**
@Test
public void testHandlePreprocessorFailureFailed() throws Exception {
oper.setPreProc(CompletableFuture.completedFuture(makeFailure()));
- verifyRun("testHandlePreprocessorFailureFalse", 1, 0, PolicyResult.FAILURE_GUARD);
+ verifyRun("testHandlePreprocessorFailureFalse", 1, 0, OperationResult.FAILURE_GUARD);
}
/**
public void testHandlePreprocessorFailureNull() throws Exception {
// arrange to return a null outcome from the preprocessor
oper.setPreProc(CompletableFuture.completedFuture(null));
- verifyRun("testHandlePreprocessorFailureNull", 1, 0, PolicyResult.FAILURE_GUARD);
+ verifyRun("testHandlePreprocessorFailureNull", 1, 0, OperationResult.FAILURE_GUARD);
}
@Test
// arrange to generate an exception when operation runs
oper.setGenException(true);
- verifyRun("testFromException", 1, 1, PolicyResult.FAILURE_EXCEPTION);
+ verifyRun("testFromException", 1, 1, OperationResult.FAILURE_EXCEPTION);
}
/**
*/
@Test
public void testFromExceptionNoExcept() {
- verifyRun("testFromExceptionNoExcept", 1, 1, PolicyResult.SUCCESS);
+ verifyRun("testFromExceptionNoExcept", 1, 1, OperationResult.SUCCESS);
}
/**
@Test
public void testCombineOutcomes() throws Exception {
// only one outcome
- verifyOutcomes(0, PolicyResult.SUCCESS);
- verifyOutcomes(0, PolicyResult.FAILURE_EXCEPTION);
+ verifyOutcomes(0, OperationResult.SUCCESS);
+ verifyOutcomes(0, OperationResult.FAILURE_EXCEPTION);
// maximum is in different positions
- verifyOutcomes(0, PolicyResult.FAILURE, PolicyResult.SUCCESS, PolicyResult.FAILURE_GUARD);
- verifyOutcomes(1, PolicyResult.SUCCESS, PolicyResult.FAILURE, PolicyResult.FAILURE_GUARD);
- verifyOutcomes(2, PolicyResult.SUCCESS, PolicyResult.FAILURE_GUARD, PolicyResult.FAILURE);
+ verifyOutcomes(0, OperationResult.FAILURE, OperationResult.SUCCESS, OperationResult.FAILURE_GUARD);
+ verifyOutcomes(1, OperationResult.SUCCESS, OperationResult.FAILURE, OperationResult.FAILURE_GUARD);
+ verifyOutcomes(2, OperationResult.SUCCESS, OperationResult.FAILURE_GUARD, OperationResult.FAILURE);
// null outcome - takes precedence over a success
List<Supplier<CompletableFuture<OperationOutcome>>> tasks = new LinkedList<>();
// second task fails, third should not run
OperationOutcome failure = params.makeOutcome(null);
- failure.setResult(PolicyResult.FAILURE);
+ failure.setResult(OperationResult.FAILURE);
tasks.clear();
tasks.add(() -> CompletableFuture.completedFuture(outcome));
tasks.add(() -> CompletableFuture.completedFuture(failure));
assertSame(future1, oper.sequence(() -> future1));
}
- private void verifyOutcomes(int expected, PolicyResult... results) throws Exception {
+ private void verifyOutcomes(int expected, OperationResult... results) throws Exception {
List<Supplier<CompletableFuture<OperationOutcome>>> tasks = new LinkedList<>();
OperationOutcome expectedOutcome = null;
OperationOutcome outcome = params.makeOutcome(null);
- Map<PolicyResult, Integer> map = Map.of(PolicyResult.SUCCESS, 0, PolicyResult.FAILURE_GUARD, 2,
- PolicyResult.FAILURE_RETRIES, 3, PolicyResult.FAILURE, 4, PolicyResult.FAILURE_TIMEOUT, 5,
- PolicyResult.FAILURE_EXCEPTION, 6);
+ Map<OperationResult, Integer> map = Map.of(OperationResult.SUCCESS, 0, OperationResult.FAILURE_GUARD, 2,
+ OperationResult.FAILURE_RETRIES, 3, OperationResult.FAILURE, 4, OperationResult.FAILURE_TIMEOUT, 5,
+ OperationResult.FAILURE_EXCEPTION, 6);
- for (Entry<PolicyResult, Integer> ent : map.entrySet()) {
+ for (Entry<OperationResult, Integer> ent : map.entrySet()) {
outcome.setResult(ent.getKey());
assertEquals(ent.getKey().toString(), ent.getValue().intValue(), oper.detmPriority(outcome));
}
outcome = new OperationOutcome();
oper.setOutcome(outcome, timex);
assertEquals(ControlLoopOperation.FAILED_MSG, outcome.getMessage());
- assertEquals(PolicyResult.FAILURE_TIMEOUT, outcome.getResult());
+ assertEquals(OperationResult.FAILURE_TIMEOUT, outcome.getResult());
outcome = new OperationOutcome();
oper.setOutcome(outcome, new IllegalStateException(EXPECTED_EXCEPTION));
assertEquals(ControlLoopOperation.FAILED_MSG, outcome.getMessage());
- assertEquals(PolicyResult.FAILURE_EXCEPTION, outcome.getResult());
+ assertEquals(OperationResult.FAILURE_EXCEPTION, outcome.getResult());
}
@Test
OperationOutcome outcome;
outcome = new OperationOutcome();
- oper.setOutcome(outcome, PolicyResult.SUCCESS);
+ oper.setOutcome(outcome, OperationResult.SUCCESS);
assertEquals(ControlLoopOperation.SUCCESS_MSG, outcome.getMessage());
- assertEquals(PolicyResult.SUCCESS, outcome.getResult());
+ assertEquals(OperationResult.SUCCESS, outcome.getResult());
- oper.setOutcome(outcome, PolicyResult.SUCCESS);
+ oper.setOutcome(outcome, OperationResult.SUCCESS);
assertEquals(ControlLoopOperation.SUCCESS_MSG, outcome.getMessage());
- assertEquals(PolicyResult.SUCCESS, outcome.getResult());
+ assertEquals(OperationResult.SUCCESS, outcome.getResult());
- for (PolicyResult result : FAILURE_RESULTS) {
+ for (OperationResult result : FAILURE_RESULTS) {
outcome = new OperationOutcome();
oper.setOutcome(outcome, result);
assertEquals(result.toString(), ControlLoopOperation.FAILED_MSG, outcome.getMessage());
private OperationOutcome makeSuccess() {
OperationOutcome outcome = params.makeOutcome(null);
- outcome.setResult(PolicyResult.SUCCESS);
+ outcome.setResult(OperationResult.SUCCESS);
return outcome;
}
private OperationOutcome makeFailure() {
OperationOutcome outcome = params.makeOutcome(null);
- outcome.setResult(PolicyResult.FAILURE);
+ outcome.setResult(OperationResult.FAILURE);
return outcome;
}
* @param expectedResult expected outcome
*/
private void verifyRun(String testName, int expectedCallbacks, int expectedOperations,
- PolicyResult expectedResult) {
+ OperationResult expectedResult) {
verifyRun(testName, expectedCallbacks, expectedOperations, expectedResult, noop());
}
* {@link OperationPartial#start(ControlLoopOperationParams)} before the tasks
* in the executor are run
*/
- private void verifyRun(String testName, int expectedCallbacks, int expectedOperations, PolicyResult expectedResult,
- Consumer<CompletableFuture<OperationOutcome>> manipulator) {
+ private void verifyRun(String testName, int expectedCallbacks, int expectedOperations,
+ OperationResult expectedResult, Consumer<CompletableFuture<OperationOutcome>> manipulator) {
tstart = null;
opstart = null;
operation.setSubRequestId(String.valueOf(attempt));
if (count > maxFailures) {
- operation.setResult(PolicyResult.SUCCESS);
+ operation.setResult(OperationResult.SUCCESS);
} else {
- operation.setResult(PolicyResult.FAILURE);
+ operation.setResult(OperationResult.FAILURE);
}
return operation;
import org.onap.policy.controlloop.actorserviceprovider.controlloop.ControlLoopEventContext;
import org.onap.policy.controlloop.actorserviceprovider.parameters.ControlLoopOperationParams.ControlLoopOperationParamsBuilder;
import org.onap.policy.controlloop.actorserviceprovider.spi.Actor;
-import org.onap.policy.controlloop.policy.Target;
public class ControlLoopOperationParamsTest {
private static final String NULL_MSG = "null";
private static final String EXPECTED_EXCEPTION = "expected exception";
private static final String ACTOR = "my-actor";
private static final String OPERATION = "my-operation";
- private static final Target TARGET = new Target();
private static final String TARGET_ENTITY = "my-target";
private static final Integer RETRY = 3;
private static final Integer TIMEOUT = 100;
params = ControlLoopOperationParams.builder().actorService(actorService).completeCallback(completer)
.context(context).executor(executor).actor(ACTOR).operation(OPERATION).payload(payload)
- .retry(RETRY).target(TARGET).targetEntity(TARGET_ENTITY).timeoutSec(TIMEOUT)
+ .retry(RETRY).targetEntity(TARGET_ENTITY).timeoutSec(TIMEOUT)
.startCallback(starter).preprocessed(true).build();
outcome = params.makeOutcome(TARGET_ENTITY);
assertTrue(params.toBuilder().build().validate().isValid());
// these can be null
- assertTrue(params.toBuilder().payload(null).retry(null).target(null).timeoutSec(null).startCallback(null)
+ assertTrue(params.toBuilder().payload(null).retry(null).timeoutSec(null).startCallback(null)
.completeCallback(null).build().validate().isValid());
// test with minimal fields
assertNull(ControlLoopOperationParams.builder().build().getRetry());
}
- @Test
- public void testTarget() {
- assertSame(TARGET, params.getTarget());
-
- // should be null when unspecified
- assertNull(ControlLoopOperationParams.builder().build().getTarget());
- }
-
@Test
public void testGetTimeoutSec() {
assertSame(TIMEOUT, params.getTimeoutSec());
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
</dependency>
- <dependency>
- <groupId>org.onap.policy.models.policy-models-interactions</groupId>
- <artifactId>model-yaml</artifactId>
- <version>${project.version}</version>
- </dependency>
</dependencies>
</project>
Code Review / policy / models.git / commitdiff