import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Map.Entry;
+
import org.onap.policy.common.parameters.GroupValidationResult;
import org.onap.policy.common.parameters.ParameterGroup;
import org.onap.policy.common.parameters.ValidationStatus;
import org.onap.policy.common.utils.validation.ParameterValidationUtils;
+import org.onap.policy.distribution.reception.parameters.PolicyDecoderConfigurationParameterGroup;
import org.onap.policy.distribution.reception.parameters.ReceptionHandlerConfigurationParameterGroup;
import org.onap.policy.distribution.reception.parameters.ReceptionHandlerParameters;
new LinkedHashMap<>();
private Map<String, PolicyForwarderConfigurationParameterGroup> policyForwarderConfigurationParameters =
new LinkedHashMap<>();
+ private Map<String, PolicyDecoderConfigurationParameterGroup> policyDecoderConfigurationParameters =
+ new LinkedHashMap<>();
+
/**
public DistributionParameterGroup(final String name, final RestServerParameters restServerParameters,
final Map<String, ReceptionHandlerParameters> receptionHandlerParameters,
final Map<String, ReceptionHandlerConfigurationParameterGroup> receptionHandlerConfigurationParameters,
- final Map<String, PolicyForwarderConfigurationParameterGroup> policyForwarderConfigurationParameters) {
+ final Map<String, PolicyForwarderConfigurationParameterGroup> policyForwarderConfigurationParameters,
+ final Map<String, PolicyDecoderConfigurationParameterGroup> policyDecoderConfigurationParameters) {
this.name = name;
this.restServerParameters = restServerParameters;
this.receptionHandlerParameters = receptionHandlerParameters;
this.receptionHandlerConfigurationParameters = receptionHandlerConfigurationParameters;
this.policyForwarderConfigurationParameters = policyForwarderConfigurationParameters;
+ this.policyDecoderConfigurationParameters = policyDecoderConfigurationParameters;
}
/**
/**
* Sets the policy forwarder configuration parameter map.
*
- * @param eventInputParameters the policy forwarder configuration parameters
+ * @param policyForwarderConfigurationParameters the policy forwarder configuration parameters
*/
public void setPolicyForwarderConfigurationParameters(
final Map<String, PolicyForwarderConfigurationParameterGroup> policyForwarderConfigurationParameters) {
this.policyForwarderConfigurationParameters = policyForwarderConfigurationParameters;
}
+ /**
+ * Returns the policy decoder configuration parameter map.
+ *
+ * @return the policyDecoderConfigurationParameters
+ */
+ public Map<String, PolicyDecoderConfigurationParameterGroup> getPolicyDecoderConfigurationParameters() {
+ return policyDecoderConfigurationParameters;
+ }
+
+ /**
+ * Set the policy decoder configuration parameter map.
+ *
+ * @param policyDecoderConfigurationParameters the policyDecoderConfigurationParameters to set
+ */
+ public void setPolicyDecoderConfigurationParameters(
+ final Map<String, PolicyDecoderConfigurationParameterGroup> policyDecoderConfigurationParameters) {
+ this.policyDecoderConfigurationParameters = policyDecoderConfigurationParameters;
+ }
+
/**
* Validate the parameter group.
*
}
validateReceptionHandlers(validationResult);
validateForwarderConfigurations(validationResult);
+ validateDecoderConfigurations(validationResult);
return validationResult;
}
- /**
- * Validate the reception handlers.
- *
- */
private void validateReceptionHandlers(final GroupValidationResult validationResult) {
if (receptionHandlerParameters == null || receptionHandlerParameters.size() == 0) {
validationResult.setResult("receptionHandlerParameters", ValidationStatus.INVALID,
configurationParameters.getValue().validate());
}
}
+
+ private void validateDecoderConfigurations(final GroupValidationResult validationResult) {
+ for (final Entry<String, PolicyDecoderConfigurationParameterGroup> configurationParameters : policyDecoderConfigurationParameters
+ .entrySet()) {
+ validationResult.setResult("policyDecoderConfigurationParameters", configurationParameters.getKey(),
+ configurationParameters.getValue().validate());
+ }
+ }
}
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
+
import java.io.FileReader;
+
import org.onap.policy.common.logging.flexlogger.FlexLogger;
import org.onap.policy.common.logging.flexlogger.Logger;
import org.onap.policy.common.parameters.GroupValidationResult;
import org.onap.policy.distribution.main.PolicyDistributionException;
import org.onap.policy.distribution.main.startstop.DistributionCommandLineArguments;
+import org.onap.policy.distribution.reception.parameters.PolicyDecoderConfigurationParameterGroup;
+import org.onap.policy.distribution.reception.parameters.PolicyDecoderConfigurationParametersJsonAdapter;
import org.onap.policy.distribution.reception.parameters.ReceptionHandlerConfigurationParameterGroup;
import org.onap.policy.distribution.reception.parameters.ReceptionHandlerConfigurationParametersJsonAdapter;
/**
- * This class handles reading, parsing and validating of policy distribution parameters from JSON
- * files.
+ * This class handles reading, parsing and validating of policy distribution parameters from JSON files.
*/
public class DistributionParameterHandler {
private static final Logger LOGGER = FlexLogger.getLogger(DistributionParameterHandler.class);
new PolicyForwarderConfigurationParametersJsonAdapter())
.registerTypeAdapter(ReceptionHandlerConfigurationParameterGroup.class,
new ReceptionHandlerConfigurationParametersJsonAdapter())
+ .registerTypeAdapter(PolicyDecoderConfigurationParameterGroup.class,
+ new PolicyDecoderConfigurationParametersJsonAdapter())
.create();
distributionParameterGroup = gson.fromJson(new FileReader(arguments.getFullConfigurationFilePath()),
DistributionParameterGroup.class);
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
+
import org.onap.policy.common.logging.flexlogger.FlexLogger;
import org.onap.policy.common.logging.flexlogger.Logger;
import org.onap.policy.common.parameters.ParameterService;
import org.onap.policy.distribution.main.rest.DistributionRestServer;
import org.onap.policy.distribution.reception.decoding.PluginInitializationException;
import org.onap.policy.distribution.reception.handling.AbstractReceptionHandler;
+import org.onap.policy.distribution.reception.parameters.PolicyDecoderConfigurationParameterGroup;
import org.onap.policy.distribution.reception.parameters.ReceptionHandlerConfigurationParameterGroup;
import org.onap.policy.distribution.reception.parameters.ReceptionHandlerParameters;
/**
- * This class wraps a distributor so that it can be activated as a complete service together with
- * all its distribution and forwarding handlers.
+ * This class wraps a distributor so that it can be activated as a complete service together with all its distribution
+ * and forwarding handlers.
*/
public class DistributionActivator {
// The logger for this class
ParameterService.register(params);
ParameterService.register(params.getPluginHandlerParameters());
}
- for (final Entry<String, PolicyForwarderConfigurationParameterGroup> forwarderConfiguration : distributionParameterGroup
- .getPolicyForwarderConfigurationParameters().entrySet()) {
+ //@formatter:off
+ for (final Entry<String, PolicyForwarderConfigurationParameterGroup> forwarderConfiguration
+ : distributionParameterGroup.getPolicyForwarderConfigurationParameters().entrySet()) {
forwarderConfiguration.getValue().setName(forwarderConfiguration.getKey());
ParameterService.register(forwarderConfiguration.getValue());
}
- for (final Entry<String, ReceptionHandlerConfigurationParameterGroup> receptionHandlerConfiguration : distributionParameterGroup
- .getReceptionHandlerConfigurationParameters().entrySet()) {
+ for (final Entry<String, ReceptionHandlerConfigurationParameterGroup> receptionHandlerConfiguration
+ : distributionParameterGroup.getReceptionHandlerConfigurationParameters().entrySet()) {
receptionHandlerConfiguration.getValue().setName(receptionHandlerConfiguration.getKey());
ParameterService.register(receptionHandlerConfiguration.getValue());
}
+ for (final Entry<String, PolicyDecoderConfigurationParameterGroup> decoderConfiguration
+ : distributionParameterGroup.getPolicyDecoderConfigurationParameters().entrySet()) {
+ decoderConfiguration.getValue().setName(decoderConfiguration.getKey());
+ ParameterService.register(decoderConfiguration.getValue());
+ }
+ //@formatter:on
}
/**
ParameterService.deregister((params.getName()));
ParameterService.deregister((params.getPluginHandlerParameters().getName()));
}
- for (final Entry<String, PolicyForwarderConfigurationParameterGroup> forwarderConfiguration : distributionParameterGroup
- .getPolicyForwarderConfigurationParameters().entrySet()) {
+ //@formatter:off
+ for (final Entry<String, PolicyForwarderConfigurationParameterGroup> forwarderConfiguration
+ : distributionParameterGroup.getPolicyForwarderConfigurationParameters().entrySet()) {
forwarderConfiguration.getValue().setName(forwarderConfiguration.getKey());
ParameterService.deregister(forwarderConfiguration.getKey());
}
- for (final Entry<String, ReceptionHandlerConfigurationParameterGroup> receptionHandlerConfiguration : distributionParameterGroup
- .getReceptionHandlerConfigurationParameters().entrySet()) {
+ for (final Entry<String, ReceptionHandlerConfigurationParameterGroup> receptionHandlerConfiguration
+ : distributionParameterGroup.getReceptionHandlerConfigurationParameters().entrySet()) {
receptionHandlerConfiguration.getValue().setName(receptionHandlerConfiguration.getKey());
ParameterService.deregister(receptionHandlerConfiguration.getKey());
}
+ for (final Entry<String, PolicyDecoderConfigurationParameterGroup> decoderConfiguration
+ : distributionParameterGroup.getPolicyDecoderConfigurationParameters().entrySet()) {
+ decoderConfiguration.getValue().setName(decoderConfiguration.getKey());
+ ParameterService.deregister(decoderConfiguration.getKey());
+ }
+ //@formatter:on
}
/**
import java.util.HashMap;
import java.util.List;
import java.util.Map;
+
import org.onap.policy.distribution.forwarding.parameters.PolicyForwarderParameters;
+import org.onap.policy.distribution.main.testclasses.DummyPolicyDecoderParameterGroup;
import org.onap.policy.distribution.main.testclasses.DummyPolicyForwarderParameterGroup;
import org.onap.policy.distribution.main.testclasses.DummyPolicyForwarderParameterGroup.DummyPolicyForwarderParameterGroupBuilder;
import org.onap.policy.distribution.main.testclasses.DummyReceptionHandlerParameterGroup;
import org.onap.policy.distribution.main.testclasses.DummyReceptionHandlerParameterGroup.DummyReceptionHandlerParameterGroupBuilder;
import org.onap.policy.distribution.reception.parameters.PluginHandlerParameters;
+import org.onap.policy.distribution.reception.parameters.PolicyDecoderConfigurationParameterGroup;
import org.onap.policy.distribution.reception.parameters.PolicyDecoderParameters;
import org.onap.policy.distribution.reception.parameters.ReceptionHandlerConfigurationParameterGroup;
import org.onap.policy.distribution.reception.parameters.ReceptionHandlerParameters;
public static final String DUMMY_ENGINE_FORWARDER_KEY = "DummyForwarder";
public static final String DUMMY_DECODER_KEY = "DummyDecoder";
+ public static final String POLICY_TYPE = "DUMMY";
+ public static final String POLICY_NAME = "SamplePolicy";
+ public static final String DECODER_CONFIGURATION_PARAMETERS = "dummyDecoderConfiguration";
+
/**
* Returns an instance of ReceptionHandlerParameters for test cases.
*
messageBusAddress.add("localhost");
final List<String> artifactTypes = new ArrayList<>();
artifactTypes.add("TOSCA_CSAR");
- DummyReceptionHandlerParameterGroup dummyReceptionHandlerParameterGroup =
+ final DummyReceptionHandlerParameterGroup dummyReceptionHandlerParameterGroup =
new DummyReceptionHandlerParameterGroupBuilder().setMyStringParameter(MY_STRING_PARAMETER_VALUE)
.setMyIntegerParameter(MY_INTEGER_PARAMETER_VALUE)
.setMyBooleanParameter(MY_BOOLEAN_PARAMETER_VALUE).build();
public Map<String, PolicyDecoderParameters> getPolicyDecoders(final boolean isEmpty) {
final Map<String, PolicyDecoderParameters> policyDecoders = new HashMap<String, PolicyDecoderParameters>();
if (!isEmpty) {
- final PolicyDecoderParameters pDParameters = new PolicyDecoderParameters(DECODER_TYPE, DECODER_CLASS_NAME);
+ final PolicyDecoderParameters pDParameters =
+ new PolicyDecoderParameters(DECODER_TYPE, DECODER_CLASS_NAME, DECODER_CONFIGURATION_PARAMETERS);
policyDecoders.put(DUMMY_DECODER_KEY, pDParameters);
}
return policyDecoders;
final Map<String, PolicyForwarderConfigurationParameterGroup> policyForwarderConfigurationParameters =
new HashMap<String, PolicyForwarderConfigurationParameterGroup>();
if (!isEmpty) {
- DummyPolicyForwarderParameterGroup dummyPolicyForwarderParameterGroup =
+ final DummyPolicyForwarderParameterGroup dummyPolicyForwarderParameterGroup =
new DummyPolicyForwarderParameterGroupBuilder().setUseHttps(true).setHostname(FORWARDER_HOST)
.setPort(1234).setUserName("myUser").setPassword("myPassword").setIsManaged(true).build();
policyForwarderConfigurationParameters.put(FORWARDER_CONFIGURATION_PARAMETERS,
}
return policyForwarderConfigurationParameters;
}
+
+ /**
+ * Returns PolicyDecoderConfigurationParameterGroups for test cases.
+ *
+ * @param isEmpty boolean value to represent that object created should be empty or not
+ * @return the PolicyDecoderConfigurationParameterGroups
+ */
+ public Map<String, PolicyDecoderConfigurationParameterGroup> getPolicyDecoderConfigurationParameters(
+ final boolean isEmpty) {
+ final Map<String, PolicyDecoderConfigurationParameterGroup> policyDecoderConfigurationParameters =
+ new HashMap<String, PolicyDecoderConfigurationParameterGroup>();
+ if (!isEmpty) {
+ final DummyPolicyDecoderParameterGroup dummyPolicyForwarderParameterGroup =
+ new DummyPolicyDecoderParameterGroup(POLICY_NAME, POLICY_TYPE);
+ policyDecoderConfigurationParameters.put(DECODER_CONFIGURATION_PARAMETERS,
+ dummyPolicyForwarderParameterGroup);
+ }
+ return policyDecoderConfigurationParameters;
+ }
}
import static org.junit.Assert.fail;
import java.util.Map;
+
import org.junit.Test;
import org.onap.policy.common.parameters.GroupValidationResult;
import org.onap.policy.distribution.main.testclasses.DummyPolicyForwarderParameterGroup;
import org.onap.policy.distribution.main.testclasses.DummyReceptionHandlerParameterGroup;
+import org.onap.policy.distribution.reception.parameters.PolicyDecoderConfigurationParameterGroup;
import org.onap.policy.distribution.reception.parameters.ReceptionHandlerConfigurationParameterGroup;
import org.onap.policy.distribution.reception.parameters.ReceptionHandlerParameters;
commonTestData.getReceptionHandlerConfigurationParameters(false);
final Map<String, PolicyForwarderConfigurationParameterGroup> forwarderConfigurations =
commonTestData.getPolicyForwarderConfigurationParameters(false);
+ final Map<String, PolicyDecoderConfigurationParameterGroup> decoderConfigurations =
+ commonTestData.getPolicyDecoderConfigurationParameters(false);
- final DistributionParameterGroup distributionParameters =
- new DistributionParameterGroup(CommonTestData.DISTRIBUTION_GROUP_NAME, restServerParameters,
- receptionHandlerParameters, receptionHandlerConfigurations, forwarderConfigurations);
+ final DistributionParameterGroup distributionParameters = new DistributionParameterGroup(
+ CommonTestData.DISTRIBUTION_GROUP_NAME, restServerParameters, receptionHandlerParameters,
+ receptionHandlerConfigurations, forwarderConfigurations, decoderConfigurations);
final GroupValidationResult validationResult = distributionParameters.validate();
assertTrue(validationResult.isValid());
assertEquals(restServerParameters.getHost(), distributionParameters.getRestServerParameters().getHost());
commonTestData.getReceptionHandlerConfigurationParameters(false);
final Map<String, PolicyForwarderConfigurationParameterGroup> forwarderConfigurations =
commonTestData.getPolicyForwarderConfigurationParameters(false);
+ final Map<String, PolicyDecoderConfigurationParameterGroup> decoderConfigurations =
+ commonTestData.getPolicyDecoderConfigurationParameters(false);
final DistributionParameterGroup distributionParameters =
new DistributionParameterGroup(null, restServerParameters, receptionHandlerParameters,
- receptionHandlerConfigurations, forwarderConfigurations);
+ receptionHandlerConfigurations, forwarderConfigurations, decoderConfigurations);
final GroupValidationResult validationResult = distributionParameters.validate();
assertFalse(validationResult.isValid());
assertEquals(null, distributionParameters.getName());
commonTestData.getReceptionHandlerConfigurationParameters(false);
final Map<String, PolicyForwarderConfigurationParameterGroup> forwarderConfigurations =
commonTestData.getPolicyForwarderConfigurationParameters(false);
+ final Map<String, PolicyDecoderConfigurationParameterGroup> decoderConfigurations =
+ commonTestData.getPolicyDecoderConfigurationParameters(false);
final DistributionParameterGroup distributionParameters =
new DistributionParameterGroup("", restServerParameters, receptionHandlerParameters,
- receptionHandlerConfigurations, forwarderConfigurations);
+ receptionHandlerConfigurations, forwarderConfigurations, decoderConfigurations);
final GroupValidationResult validationResult = distributionParameters.validate();
assertFalse(validationResult.isValid());
assertEquals("", distributionParameters.getName());
commonTestData.getReceptionHandlerConfigurationParameters(false);
final Map<String, PolicyForwarderConfigurationParameterGroup> forwarderConfigurations =
commonTestData.getPolicyForwarderConfigurationParameters(false);
+ final Map<String, PolicyDecoderConfigurationParameterGroup> decoderConfigurations =
+ commonTestData.getPolicyDecoderConfigurationParameters(false);
try {
final DistributionParameterGroup distributionParameters =
new DistributionParameterGroup(CommonTestData.DISTRIBUTION_GROUP_NAME, restServerParameters, null,
- receptionHandlerConfigurations, forwarderConfigurations);
+ receptionHandlerConfigurations, forwarderConfigurations, decoderConfigurations);
distributionParameters.validate();
fail("test should throw an exception here");
} catch (final Exception e) {
commonTestData.getReceptionHandlerConfigurationParameters(false);
final Map<String, PolicyForwarderConfigurationParameterGroup> forwarderConfigurations =
commonTestData.getPolicyForwarderConfigurationParameters(false);
- final DistributionParameterGroup distributionParameters =
- new DistributionParameterGroup(CommonTestData.DISTRIBUTION_GROUP_NAME, restServerParameters,
- receptionHandlerParameters, receptionHandlerConfigurations, forwarderConfigurations);
+ final Map<String, PolicyDecoderConfigurationParameterGroup> decoderConfigurations =
+ commonTestData.getPolicyDecoderConfigurationParameters(false);
+ final DistributionParameterGroup distributionParameters = new DistributionParameterGroup(
+ CommonTestData.DISTRIBUTION_GROUP_NAME, restServerParameters, receptionHandlerParameters,
+ receptionHandlerConfigurations, forwarderConfigurations, decoderConfigurations);
distributionParameters.validate();
- GroupValidationResult result = distributionParameters.validate();
+ final GroupValidationResult result = distributionParameters.validate();
assertFalse(result.isValid());
assertTrue(result.getResult().endsWith("must have at least one reception handler\n"));
}
commonTestData.getReceptionHandlerConfigurationParameters(false);
final Map<String, PolicyForwarderConfigurationParameterGroup> forwarderConfigurations =
commonTestData.getPolicyForwarderConfigurationParameters(false);
+ final Map<String, PolicyDecoderConfigurationParameterGroup> decoderConfigurations =
+ commonTestData.getPolicyDecoderConfigurationParameters(false);
- final DistributionParameterGroup distributionParameters =
- new DistributionParameterGroup(CommonTestData.DISTRIBUTION_GROUP_NAME, restServerParameters,
- receptionHandlerParameters, receptionHandlerConfigurations, forwarderConfigurations);
+ final DistributionParameterGroup distributionParameters = new DistributionParameterGroup(
+ CommonTestData.DISTRIBUTION_GROUP_NAME, restServerParameters, receptionHandlerParameters,
+ receptionHandlerConfigurations, forwarderConfigurations, decoderConfigurations);
final GroupValidationResult validationResult = distributionParameters.validate();
assertFalse(validationResult.isValid());
assertTrue(validationResult.getResult()
import org.junit.Test;
import org.onap.policy.distribution.main.PolicyDistributionException;
import org.onap.policy.distribution.main.startstop.DistributionCommandLineArguments;
+import org.onap.policy.distribution.main.testclasses.DummyPolicyDecoderParameterGroup;
import org.onap.policy.distribution.main.testclasses.DummyPolicyForwarderParameterGroup;
/**
@Test
public void testParameterHandlerNoParameterFile() throws PolicyDistributionException {
final String[] noArgumentString =
- { "-c", "parameters/NoParameterFile.json" };
+ { "-c", "parameters/NoParameterFile.json" };
final DistributionCommandLineArguments noArguments = new DistributionCommandLineArguments();
noArguments.parse(noArgumentString);
@Test
public void testParameterHandlerEmptyParameters() throws PolicyDistributionException {
final String[] emptyArgumentString =
- { "-c", "parameters/EmptyParameters.json" };
+ { "-c", "parameters/EmptyParameters.json" };
final DistributionCommandLineArguments emptyArguments = new DistributionCommandLineArguments();
emptyArguments.parse(emptyArgumentString);
@Test
public void testParameterHandlerBadParameters() throws PolicyDistributionException {
final String[] badArgumentString =
- { "-c", "parameters/BadParameters.json" };
+ { "-c", "parameters/BadParameters.json" };
final DistributionCommandLineArguments badArguments = new DistributionCommandLineArguments();
badArguments.parse(badArgumentString);
@Test
public void testParameterHandlerInvalidParameters() throws PolicyDistributionException {
final String[] invalidArgumentString =
- { "-c", "parameters/InvalidParameters.json" };
+ { "-c", "parameters/InvalidParameters.json" };
final DistributionCommandLineArguments invalidArguments = new DistributionCommandLineArguments();
invalidArguments.parse(invalidArgumentString);
@Test
public void testParameterHandlerNoParameters() throws PolicyDistributionException {
final String[] noArgumentString =
- { "-c", "parameters/NoParameters.json" };
+ { "-c", "parameters/NoParameters.json" };
final DistributionCommandLineArguments noArguments = new DistributionCommandLineArguments();
noArguments.parse(noArgumentString);
@Test
public void testParameterHandlerMinumumParameters() throws PolicyDistributionException {
final String[] minArgumentString =
- { "-c", "parameters/MinimumParameters.json" };
+ { "-c", "parameters/MinimumParameters.json" };
final DistributionCommandLineArguments minArguments = new DistributionCommandLineArguments();
minArguments.parse(minArgumentString);
@Test
public void testDistributionParameterGroup() throws PolicyDistributionException {
final String[] distributionConfigParameters =
- { "-c", "parameters/DistributionConfigParameters.json" };
+ { "-c", "parameters/DistributionConfigParameters.json" };
final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
arguments.parse(distributionConfigParameters);
assertEquals(CommonTestData.FORWARDER_HOST,
((DummyPolicyForwarderParameterGroup) parGroup.getPolicyForwarderConfigurationParameters()
.get(CommonTestData.FORWARDER_CONFIGURATION_PARAMETERS)).getHostname());
+ assertEquals(CommonTestData.POLICY_TYPE,
+ ((DummyPolicyDecoderParameterGroup) parGroup.getPolicyDecoderConfigurationParameters()
+ .get(CommonTestData.DECODER_CONFIGURATION_PARAMETERS)).getPolicyType());
+ assertEquals(CommonTestData.POLICY_NAME,
+ ((DummyPolicyDecoderParameterGroup) parGroup.getPolicyDecoderConfigurationParameters()
+ .get(CommonTestData.DECODER_CONFIGURATION_PARAMETERS)).getPolicyName());
}
@Test
public void testDistributionParameterGroup_InvalidForwarderConfigurationClassName()
throws PolicyDistributionException {
final String[] distributionConfigParameters =
- { "-c", "parameters/DistributionConfigParameters_InvalidForwarderConfigurationClassName.json" };
+ { "-c", "parameters/DistributionConfigParameters_InvalidForwarderConfigurationClassName.json" };
final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
arguments.parse(distributionConfigParameters);
public void testDistributionParameterGroup_UnknownForwarderConfigurationClassName()
throws PolicyDistributionException {
final String[] distributionConfigParameters =
- { "-c", "parameters/DistributionConfigParameters_UnknownForwarderConfigurationClassName.json" };
+ { "-c", "parameters/DistributionConfigParameters_UnknownForwarderConfigurationClassName.json" };
final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
arguments.parse(distributionConfigParameters);
@Test
public void testDistributionParameterGroup_InvalidName() throws PolicyDistributionException {
final String[] distributionConfigParameters =
- { "-c", "parameters/DistributionConfigParameters_InvalidName.json" };
+ { "-c", "parameters/DistributionConfigParameters_InvalidName.json" };
final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
arguments.parse(distributionConfigParameters);
@Test
public void testDistributionParameterGroup_NoReceptionHandler() throws PolicyDistributionException {
final String[] distributionConfigParameters =
- { "-c", "parameters/DistributionConfigParameters_NoReceptionHandler.json" };
+ { "-c", "parameters/DistributionConfigParameters_NoReceptionHandler.json" };
final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
arguments.parse(distributionConfigParameters);
@Test
public void testDistributionParameterGroup_EmptyReceptionHandler() throws PolicyDistributionException {
final String[] distributionConfigParameters =
- { "-c", "parameters/DistributionConfigParameters_EmptyReceptionHandler.json" };
+ { "-c", "parameters/DistributionConfigParameters_EmptyReceptionHandler.json" };
final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
arguments.parse(distributionConfigParameters);
@Test
public void testDistributionParameterGroup_NoPolicyDecoder() throws PolicyDistributionException {
final String[] distributionConfigParameters =
- { "-c", "parameters/DistributionConfigParameters_NoPolicyDecoder.json" };
+ { "-c", "parameters/DistributionConfigParameters_NoPolicyDecoder.json" };
final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
arguments.parse(distributionConfigParameters);
@Test
public void testDistributionParameterGroup_NoPolicyForwarder() throws PolicyDistributionException {
final String[] distributionConfigParameters =
- { "-c", "parameters/DistributionConfigParameters_NoPolicyForwarder.json" };
+ { "-c", "parameters/DistributionConfigParameters_NoPolicyForwarder.json" };
final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
arguments.parse(distributionConfigParameters);
@Test
public void testDistributionParameterGroup_EmptyPolicyDecoder() throws PolicyDistributionException {
final String[] distributionConfigParameters =
- { "-c", "parameters/DistributionConfigParameters_EmptyPolicyDecoder.json" };
+ { "-c", "parameters/DistributionConfigParameters_EmptyPolicyDecoder.json" };
final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
arguments.parse(distributionConfigParameters);
@Test
public void testDistributionParameterGroup_EmptyPolicyForwarder() throws PolicyDistributionException {
final String[] distributionConfigParameters =
- { "-c", "parameters/DistributionConfigParameters_EmptyPolicyForwarder.json" };
+ { "-c", "parameters/DistributionConfigParameters_EmptyPolicyForwarder.json" };
final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
arguments.parse(distributionConfigParameters);
public void testDistributionParameterGroup_InvalidReceptionHandlerParameters()
throws PolicyDistributionException, IOException {
final String[] distributionConfigParameters =
- { "-c", "parameters/DistributionConfigParameters_InvalidReceptionHandlerParameters.json" };
+ { "-c", "parameters/DistributionConfigParameters_InvalidReceptionHandlerParameters.json" };
final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
arguments.parse(distributionConfigParameters);
public void testDistributionParameterGroup_InvalidDecoderAndForwarderParameters()
throws PolicyDistributionException, IOException {
final String[] distributionConfigParameters =
- { "-c", "parameters/DistributionConfigParameters_InvalidDecoderAndForwarderParameters.json" };
+ { "-c", "parameters/DistributionConfigParameters_InvalidDecoderAndForwarderParameters.json" };
final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
arguments.parse(distributionConfigParameters);
public void testDistributionParameterGroup_InvalidRestServerParameters()
throws PolicyDistributionException, IOException {
final String[] distributionConfigParameters =
- { "-c", "parameters/DistributionConfigParameters_InvalidRestServerParameters.json" };
+ { "-c", "parameters/DistributionConfigParameters_InvalidRestServerParameters.json" };
final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
arguments.parse(distributionConfigParameters);
@Test
public void testDistributionVersion() throws PolicyDistributionException {
final String[] distributionConfigParameters =
- { "-v" };
+ { "-v" };
final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
final String version = arguments.parse(distributionConfigParameters);
assertTrue(version.startsWith("ONAP Policy Framework Distribution Service"));
@Test
public void testDistributionHelp() throws PolicyDistributionException {
final String[] distributionConfigParameters =
- { "-h" };
+ { "-h" };
final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
final String help = arguments.parse(distributionConfigParameters);
assertTrue(help.startsWith("usage:"));
@Test
public void testDistributionInvalidOption() throws PolicyDistributionException {
final String[] distributionConfigParameters =
- { "-d" };
+ { "-d" };
final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
try {
arguments.parse(distributionConfigParameters);
@Test
public void testDistributionParameterGroup_InvalidReceptionHandlerClass() throws PolicyDistributionException {
final String[] distributionConfigParameters =
- { "-c", "parameters/DistributionConfigParameters_InvalidReceptionHandlerClass.json" };
+ { "-c", "parameters/DistributionConfigParameters_InvalidReceptionHandlerClass.json" };
final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
arguments.parse(distributionConfigParameters);
@Test
public void testDistributionParameterGroup_EmptyReceptionHandlerClass() throws PolicyDistributionException {
final String[] distributionConfigParameters =
- { "-c", "parameters/DistributionConfigParameters_EmptyReceptionHandlerClass.json" };
+ { "-c", "parameters/DistributionConfigParameters_EmptyReceptionHandlerClass.json" };
final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
arguments.parse(distributionConfigParameters);
assertTrue(e.getMessage().contains("invalid in JSON file"));
}
}
+
+ @Test
+ public void testDistributionParameterGroup_InvalidDecoderConfigurationClassName()
+ throws PolicyDistributionException {
+ final String[] distributionConfigParameters =
+ { "-c", "parameters/DistributionConfigParameters_InvalidDecoderConfigurationClassName.json" };
+
+ final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
+ arguments.parse(distributionConfigParameters);
+
+ try {
+ new DistributionParameterHandler().getParameters(arguments);
+ fail("test should throw an exception here");
+ } catch (final Exception e) {
+ assertTrue(e.getMessage().contains("parameter \"parameterClassName\" value \"\" invalid in JSON file"));
+ }
+ }
+
+ @Test
+ public void testDistributionParameterGroup_UnknownDecoderConfigurationClassName()
+ throws PolicyDistributionException {
+ final String[] distributionConfigParameters =
+ { "-c", "parameters/DistributionConfigParameters_UnknownDecoderConfigurationClassName.json" };
+
+ final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
+ arguments.parse(distributionConfigParameters);
+
+ try {
+ new DistributionParameterHandler().getParameters(arguments);
+ fail("test should throw an exception here");
+ } catch (final Exception e) {
+ assertTrue(e.getMessage().contains(
+ "parameter \"parameterClassName\" value \"org.onap.policy.Unknown\", could not find class"));
+ }
+ }
}
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
+import static org.onap.policy.distribution.main.parameters.CommonTestData.DECODER_CLASS_NAME;
+import static org.onap.policy.distribution.main.parameters.CommonTestData.DECODER_CONFIGURATION_PARAMETERS;
+import static org.onap.policy.distribution.main.parameters.CommonTestData.DECODER_TYPE;
import org.junit.Test;
import org.onap.policy.common.parameters.GroupValidationResult;
@Test
public void testPolicyDecoderParameters() {
final PolicyDecoderParameters pDParameters =
- new PolicyDecoderParameters(CommonTestData.DECODER_TYPE, CommonTestData.DECODER_CLASS_NAME);
+ new PolicyDecoderParameters(DECODER_TYPE, DECODER_CLASS_NAME, DECODER_CONFIGURATION_PARAMETERS);
final GroupValidationResult validationResult = pDParameters.validate();
- assertEquals(CommonTestData.DECODER_TYPE, pDParameters.getDecoderType());
- assertEquals(CommonTestData.DECODER_CLASS_NAME, pDParameters.getDecoderClassName());
+ assertEquals(DECODER_TYPE, pDParameters.getDecoderType());
+ assertEquals(DECODER_CLASS_NAME, pDParameters.getDecoderClassName());
+ assertEquals(DECODER_CONFIGURATION_PARAMETERS, pDParameters.getDecoderConfigurationName());
assertTrue(validationResult.isValid());
}
@Test
public void testPolicyDecoderParameters_InvalidDecoderType() {
- final PolicyDecoderParameters pDParameters = new PolicyDecoderParameters("", CommonTestData.DECODER_CLASS_NAME);
+ final PolicyDecoderParameters pDParameters =
+ new PolicyDecoderParameters("", DECODER_CLASS_NAME, DECODER_CONFIGURATION_PARAMETERS);
final GroupValidationResult validationResult = pDParameters.validate();
assertEquals("", pDParameters.getDecoderType());
- assertEquals(CommonTestData.DECODER_CLASS_NAME, pDParameters.getDecoderClassName());
+ assertEquals(DECODER_CLASS_NAME, pDParameters.getDecoderClassName());
assertFalse(validationResult.isValid());
assertTrue(validationResult.getResult().contains(
"field \"decoderType\" type \"java.lang.String\" value \"\" INVALID, must be a non-blank string"));
@Test
public void testPolicyDecoderParameters_InvalidDecoderClassName() {
- final PolicyDecoderParameters pDParameters = new PolicyDecoderParameters(CommonTestData.DECODER_TYPE, "");
+ final PolicyDecoderParameters pDParameters =
+ new PolicyDecoderParameters(DECODER_TYPE, "", DECODER_CONFIGURATION_PARAMETERS);
final GroupValidationResult validationResult = pDParameters.validate();
- assertEquals(CommonTestData.DECODER_TYPE, pDParameters.getDecoderType());
+ assertEquals(DECODER_TYPE, pDParameters.getDecoderType());
assertEquals("", pDParameters.getDecoderClassName());
assertFalse(validationResult.isValid());
assertTrue(validationResult.getResult()
@Test
public void testPolicyDecoderParameters_InvalidDecoderTypeAndClassName() {
- final PolicyDecoderParameters pDParameters = new PolicyDecoderParameters("", "");
+ final PolicyDecoderParameters pDParameters =
+ new PolicyDecoderParameters("", "", DECODER_CONFIGURATION_PARAMETERS);
final GroupValidationResult validationResult = pDParameters.validate();
assertEquals("", pDParameters.getDecoderType());
assertEquals("", pDParameters.getDecoderClassName());
@Test
public void testPolicyDecoderParameters_NullDecoderType() {
- final PolicyDecoderParameters pDParameters =
- new PolicyDecoderParameters(null, CommonTestData.DECODER_CLASS_NAME);
+ final PolicyDecoderParameters pDParameters =
+ new PolicyDecoderParameters(null, DECODER_CLASS_NAME, DECODER_CONFIGURATION_PARAMETERS);
final GroupValidationResult validationResult = pDParameters.validate();
assertEquals(null, pDParameters.getDecoderType());
- assertEquals(CommonTestData.DECODER_CLASS_NAME, pDParameters.getDecoderClassName());
+ assertEquals(DECODER_CLASS_NAME, pDParameters.getDecoderClassName());
assertFalse(validationResult.isValid());
assertTrue(validationResult.getResult().contains(
"field \"decoderType\" type \"java.lang.String\" value \"null\" INVALID, must be a non-blank string"));
@Test
public void testPolicyDecoderParameters_NullDecoderClassName() {
- final PolicyDecoderParameters pDParameters = new PolicyDecoderParameters(CommonTestData.DECODER_TYPE, null);
+ final PolicyDecoderParameters pDParameters =
+ new PolicyDecoderParameters(DECODER_TYPE, null, DECODER_CONFIGURATION_PARAMETERS);
final GroupValidationResult validationResult = pDParameters.validate();
- assertEquals(CommonTestData.DECODER_TYPE, pDParameters.getDecoderType());
+ assertEquals(DECODER_TYPE, pDParameters.getDecoderType());
assertEquals(null, pDParameters.getDecoderClassName());
assertFalse(validationResult.isValid());
assertTrue(validationResult.getResult()
@Test
public void testPolicyDecoderParameters_InvalidDecoderClass() {
- final PolicyDecoderParameters pDParameters =
- new PolicyDecoderParameters(CommonTestData.DECODER_TYPE, CommonTestData.DECODER_CLASS_NAME + "Invalid");
+ final PolicyDecoderParameters pDParameters = new PolicyDecoderParameters(DECODER_TYPE,
+ DECODER_CLASS_NAME + "Invalid", DECODER_CONFIGURATION_PARAMETERS);
final GroupValidationResult validationResult = pDParameters.validate();
- assertEquals(CommonTestData.DECODER_TYPE, pDParameters.getDecoderType());
- assertEquals(CommonTestData.DECODER_CLASS_NAME + "Invalid", pDParameters.getDecoderClassName());
+ assertEquals(DECODER_TYPE, pDParameters.getDecoderType());
+ assertEquals(DECODER_CLASS_NAME + "Invalid", pDParameters.getDecoderClassName());
assertFalse(validationResult.isValid());
assertTrue(validationResult.getResult().contains("policy decoder class not found in classpath"));
}
public Collection<Policy> decode(final PolicyInput input) throws PolicyDecodingException {
return policesToReturn;
}
+
+ @Override
+ public void configure(final String parameterGroupName) {}
}
--- /dev/null
+/*-
+ * ============LICENSE_START=======================================================
+ * Copyright (C) 2018 Ericsson. 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.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.distribution.main.testclasses;
+
+import org.onap.policy.common.parameters.GroupValidationResult;
+import org.onap.policy.distribution.reception.parameters.PolicyDecoderConfigurationParameterGroup;
+
+/**
+ * Dummy policy decoder parameter group.
+ *
+ * @author Ram Krishna Verma (ram.krishna.verma@ericsson.com)
+ */
+public class DummyPolicyDecoderParameterGroup extends PolicyDecoderConfigurationParameterGroup {
+
+ private String policyName;
+ private String policyType;
+
+ /**
+ * Constructor for instantiating the {@link DummyPolicyDecoderParameterGroup} class.
+ *
+ * @param policyName the policy name
+ * @param policyType the policy type
+ */
+ public DummyPolicyDecoderParameterGroup(final String policyName, final String policyType) {
+ super();
+ this.policyName = policyName;
+ this.policyType = policyType;
+ }
+
+
+ public String getPolicyName() {
+ return policyName;
+ }
+
+
+ public String getPolicyType() {
+ return policyType;
+ }
+
+ @Override
+ public GroupValidationResult validate() {
+ final GroupValidationResult validationResult = new GroupValidationResult(this);
+ return validationResult;
+ }
+
+}
"policyDecoders":{
"DummyDecoder":{
"decoderType":"DummyDecoder",
- "decoderClassName":"org.onap.policy.distribution.main.testclasses.DummyDecoder"
+ "decoderClassName":"org.onap.policy.distribution.main.testclasses.DummyDecoder",
+ "decoderConfigurationParameters": "dummyDecoderConfiguration"
}
},
"policyForwarders":{
"isManaged": true
}
}
+ },
+ "policyDecoderConfigurationParameters":{
+ "dummyDecoderConfiguration":{
+ "parameterClassName":"org.onap.policy.distribution.main.testclasses.DummyPolicyDecoderParameterGroup",
+ "parameters":{
+ "policyName": "SamplePolicy",
+ "policyType": "DUMMY"
+ }
+ }
}
}
"isManaged": true
}
}
+ },
+ "policyDecoderConfigurationParameters":{
+ "dummyDecoderConfiguration":{
+ "parameterClassName":"org.onap.policy.distribution.main.testclasses.DummyPolicyDecoderParameterGroup",
+ "parameters":{
+ "policyName": "SamplePolicy",
+ "policyType": "DUMMY"
+ }
+ }
}
}
"policyDecoders":{
"DummyDecoder":{
"decoderType":"DummyDecoder",
- "decoderClassName":"org.onap.policy.distribution.main.testclasses.DummyDecoder"
+ "decoderClassName":"org.onap.policy.distribution.main.testclasses.DummyDecoder",
+ "decoderConfigurationParameters": "dummyDecoderConfiguration"
}
},
"policyForwarders":{
"isManaged": true
}
}
+ },
+ "policyDecoderConfigurationParameters":{
+ "dummyDecoderConfiguration":{
+ "parameterClassName":"org.onap.policy.distribution.main.testclasses.DummyPolicyDecoderParameterGroup",
+ "parameters":{
+ "policyName": "SamplePolicy",
+ "policyType": "DUMMY"
+ }
+ }
}
}
"isManaged": true
}
}
+ },
+ "policyDecoderConfigurationParameters":{
+ "dummyDecoderConfiguration":{
+ "parameterClassName":"org.onap.policy.distribution.main.testclasses.DummyPolicyDecoderParameterGroup",
+ "parameters":{
+ "policyName": "SamplePolicy",
+ "policyType": "DUMMY"
+ }
+ }
}
}
\ No newline at end of file
"policyDecoders":{
"DummyDecoder":{
"decoderType":"DummyDecoder",
- "decoderClassName":"org.onap.policy.distribution.main.testclasses.DummyDecoder"
+ "decoderClassName":"org.onap.policy.distribution.main.testclasses.DummyDecoder",
+ "decoderConfigurationParameters": "dummyDecoderConfiguration"
}
},
"policyForwarders":{
"isManaged": true
}
}
+ },
+ "policyDecoderConfigurationParameters":{
+ "dummyDecoderConfiguration":{
+ "parameterClassName":"org.onap.policy.distribution.main.testclasses.DummyPolicyDecoderParameterGroup",
+ "parameters":{
+ "policyName": "SamplePolicy",
+ "policyType": "DUMMY"
+ }
+ }
}
}
"policyDecoders":{
"DummyDecoder":{
"decoderType":"DummyDecoder",
- "decoderClassName":"org.onap.policy.distribution.main.testclasses.DummyDecoder"
+ "decoderClassName":"org.onap.policy.distribution.main.testclasses.DummyDecoder",
+ "decoderConfigurationParameters": "dummyDecoderConfiguration"
},
"APEXDecoder":{
"decoderType":"",
- "decoderClassName":"org.onap.policy.distribution.main.testclasses.PolicyDecoderApexPdpa"
+ "decoderClassName":"org.onap.policy.distribution.main.testclasses.PolicyDecoderApexPdpa",
+ "decoderConfigurationParameters": "dummyDecoderConfiguration"
},
"DROOLSDecoder":{
"decoderType":"DROOLS",
- "decoderClassName":""
+ "decoderClassName":"",
+ "decoderConfigurationParameters": "dummyDecoderConfiguration"
}
},
"policyForwarders":{
"isManaged": true
}
}
+ },
+ "policyDecoderConfigurationParameters":{
+ "dummyDecoderConfiguration":{
+ "parameterClassName":"org.onap.policy.distribution.main.testclasses.DummyPolicyDecoderParameterGroup",
+ "parameters":{
+ "policyName": "SamplePolicy",
+ "policyType": "DUMMY"
+ }
+ }
}
}
--- /dev/null
+{
+ "name":"SDCDistributionGroup",
+ "restServerParameters":{
+ "host":"0.0.0.0",
+ "port":6969,
+ "userName":"healthcheck",
+ "password":"zb!XztG34"
+ },
+ "receptionHandlerParameters":{
+ "DummyReceptionHandler":{
+ "receptionHandlerType":"DummyReceptionHandler",
+ "receptionHandlerClassName":"org.onap.policy.distribution.main.testclasses.DummyReceptionHandler",
+ "receptionHandlerConfigurationName":"dummyReceptionHandlerConfiguration",
+ "pluginHandlerParameters":{
+ "policyDecoders":{
+ "DummyDecoder":{
+ "decoderType":"DummyDecoder",
+ "decoderClassName":"org.onap.policy.distribution.main.testclasses.DummyDecoder",
+ "decoderConfigurationParameters": "dummyDecoderConfiguration"
+ }
+ },
+ "policyForwarders":{
+ "DummyForwarder":{
+ "forwarderType":"DummyForwarder",
+ "forwarderClassName":"org.onap.policy.distribution.main.testclasses.DummyPolicyForwarder",
+ "forwarderConfigurationParameters": "dummyConfiguration"
+ }
+ }
+ }
+ }
+ },
+ "receptionHandlerConfigurationParameters":{
+ "dummyReceptionHandlerConfiguration":{
+ "parameterClassName":"org.onap.policy.distribution.main.testclasses.DummyReceptionHandlerParameterGroup",
+ "parameters":{
+ "myStringParameter": "stringValue",
+ "myIntegerParameter":20,
+ "myBooleanParameter": true
+ }
+ }
+ },
+ "policyForwarderConfigurationParameters":{
+ "dummyConfiguration":{
+ "parameterClassName":"org.onap.policy.distribution.main.testclasses.DummyPolicyForwarderParameterGroup",
+ "parameters":{
+ "useHttps": false,
+ "hostname": "192.168.99.100",
+ "port": 8081,
+ "userName": "user",
+ "password": "pw123",
+ "isManaged": true
+ }
+ }
+ },
+ "policyDecoderConfigurationParameters":{
+ "dummyDecoderConfiguration":{
+ "parameterClassName":"",
+ "parameters":{
+ "policyName": "SamplePolicy",
+ "policyType": "DUMMY"
+ }
+ }
+ }
+}
"policyDecoders":{
"DummyDecoder":{
"decoderType":"DummyDecoder",
- "decoderClassName":"org.onap.policy.distribution.main.testclasses.DummyDecoder"
+ "decoderClassName":"org.onap.policy.distribution.main.testclasses.DummyDecoder",
+ "decoderConfigurationParameters": "dummyDecoderConfiguration"
}
},
"policyForwarders":{
"isManaged": true
}
}
+ },
+ "policyDecoderConfigurationParameters":{
+ "dummyDecoderConfiguration":{
+ "parameterClassName":"org.onap.policy.distribution.main.testclasses.DummyPolicyDecoderParameterGroup",
+ "parameters":{
+ "policyName": "SamplePolicy",
+ "policyType": "DUMMY"
+ }
+ }
}
}
"policyDecoders":{
"DummyDecoder":{
"decoderType":"DummyDecoder",
- "decoderClassName":"org.onap.policy.distribution.main.testclasses.DummyDecoder"
+ "decoderClassName":"org.onap.policy.distribution.main.testclasses.DummyDecoder",
+ "decoderConfigurationParameters": "dummyDecoderConfiguration"
}
},
"policyForwarders":{
"isManaged": true
}
}
+ },
+ "policyDecoderConfigurationParameters":{
+ "dummyDecoderConfiguration":{
+ "parameterClassName":"org.onap.policy.distribution.main.testclasses.DummyPolicyDecoderParameterGroup",
+ "parameters":{
+ "policyName": "SamplePolicy",
+ "policyType": "DUMMY"
+ }
+ }
}
}
"policyDecoders":{
"DummyDecoder":{
"decoderType":"DummyDecoder",
- "decoderClassName":"org.onap.policy.distribution.main.testclasses.DummyDecoder"
+ "decoderClassName":"org.onap.policy.distribution.main.testclasses.DummyDecoder",
+ "decoderConfigurationParameters": "dummyDecoderConfiguration"
}
},
"policyForwarders":{
"isManaged": true
}
}
+ },
+ "policyDecoderConfigurationParameters":{
+ "dummyDecoderConfiguration":{
+ "parameterClassName":"org.onap.policy.distribution.main.testclasses.DummyPolicyDecoderParameterGroup",
+ "parameters":{
+ "policyName": "SamplePolicy",
+ "policyType": "DUMMY"
+ }
+ }
}
}
"policyDecoders":{
"DummyDecoder":{
"decoderType":"DummyDecoder",
- "decoderClassName":"org.onap.policy.distribution.main.testclasses.DummyDecoder"
+ "decoderClassName":"org.onap.policy.distribution.main.testclasses.DummyDecoder",
+ "decoderConfigurationParameters": "dummyDecoderConfiguration"
}
},
"policyForwarders":{
"isManaged": true
}
}
+ },
+ "policyDecoderConfigurationParameters":{
+ "dummyDecoderConfiguration":{
+ "parameterClassName":"org.onap.policy.distribution.main.testclasses.DummyPolicyDecoderParameterGroup",
+ "parameters":{
+ "policyName": "SamplePolicy",
+ "policyType": "DUMMY"
+ }
+ }
}
}
"policyDecoders":{
"DummyDecoder":{
"decoderType":"DummyDecoder",
- "decoderClassName":"org.onap.policy.distribution.main.testclasses.DummyDecoder"
+ "decoderClassName":"org.onap.policy.distribution.main.testclasses.DummyDecoder",
+ "decoderConfigurationParameters": "dummyDecoderConfiguration"
}
},
"policyForwarders":{
"isManaged": true
}
}
+ },
+ "policyDecoderConfigurationParameters":{
+ "dummyDecoderConfiguration":{
+ "parameterClassName":"org.onap.policy.distribution.main.testclasses.DummyPolicyDecoderParameterGroup",
+ "parameters":{
+ "policyName": "SamplePolicy",
+ "policyType": "DUMMY"
+ }
+ }
}
}
"isManaged": true
}
}
+ },
+ "policyDecoderConfigurationParameters":{
+ "dummyDecoderConfiguration":{
+ "parameterClassName":"org.onap.policy.distribution.main.testclasses.DummyPolicyDecoderParameterGroup",
+ "parameters":{
+ "policyName": "SamplePolicy",
+ "policyType": "DUMMY"
+ }
+ }
}
}
"policyDecoders":{
"DummyDecoder":{
"decoderType":"DummyDecoder",
- "decoderClassName":"org.onap.policy.distribution.main.testclasses.DummyDecoder"
+ "decoderClassName":"org.onap.policy.distribution.main.testclasses.DummyDecoder",
+ "decoderConfigurationParameters": "dummyDecoderConfiguration"
}
}
}
"myBooleanParameter": true
}
}
+ },
+ "policyDecoderConfigurationParameters":{
+ "dummyDecoderConfiguration":{
+ "parameterClassName":"org.onap.policy.distribution.main.testclasses.DummyPolicyDecoderParameterGroup",
+ "parameters":{
+ "policyName": "SamplePolicy",
+ "policyType": "DUMMY"
+ }
+ }
}
}
--- /dev/null
+{
+ "name":"SDCDistributionGroup",
+ "restServerParameters":{
+ "host":"0.0.0.0",
+ "port":6969,
+ "userName":"healthcheck",
+ "password":"zb!XztG34"
+ },
+ "receptionHandlerParameters":{
+ "DummyReceptionHandler":{
+ "receptionHandlerType":"DummyReceptionHandler",
+ "receptionHandlerClassName":"org.onap.policy.distribution.main.testclasses.DummyReceptionHandler",
+ "receptionHandlerConfigurationName":"dummyReceptionHandlerConfiguration",
+ "pluginHandlerParameters":{
+ "policyDecoders":{
+ "DummyDecoder":{
+ "decoderType":"DummyDecoder",
+ "decoderClassName":"org.onap.policy.distribution.main.testclasses.DummyDecoder",
+ "decoderConfigurationParameters": "dummyDecoderConfiguration"
+ }
+ },
+ "policyForwarders":{
+ "DummyForwarder":{
+ "forwarderType":"DummyForwarder",
+ "forwarderClassName":"org.onap.policy.distribution.main.testclasses.DummyPolicyForwarder",
+ "forwarderConfigurationParameters": "dummyConfiguration"
+ }
+ }
+ }
+ }
+ },
+ "receptionHandlerConfigurationParameters":{
+ "dummyReceptionHandlerConfiguration":{
+ "parameterClassName":"org.onap.policy.distribution.main.testclasses.DummyReceptionHandlerParameterGroup",
+ "parameters":{
+ "myStringParameter": "stringValue",
+ "myIntegerParameter":20,
+ "myBooleanParameter": true
+ }
+ }
+ },
+ "policyForwarderConfigurationParameters":{
+ "dummyConfiguration":{
+ "parameterClassName":"org.onap.policy.distribution.main.testclasses.DummyPolicyForwarderParameterGroup",
+ "parameters":{
+ "useHttps": false,
+ "hostname": "192.168.99.100",
+ "port": 8081,
+ "userName": "user",
+ "password": "pw123",
+ "isManaged": true
+ }
+ }
+ },
+ "policyDecoderConfigurationParameters":{
+ "dummyDecoderConfiguration":{
+ "parameterClassName":"org.onap.policy.Unknown",
+ "parameters":{
+ "policyName": "SamplePolicy",
+ "policyType": "DUMMY"
+ }
+ }
+ }
+}
"DummyReceptionHandler":{
"receptionHandlerType":"DummyReceptionHandler",
"receptionHandlerClassName":"org.onap.policy.distribution.main.testclasses.DummyReceptionHandler",
- "pssdConfiguration":{
- "asdcAddress": "localhost",
- "messageBusAddress": [
- "a.com",
- "b.com",
- "c.com"
- ],
- "user": "tbdsdc-1480",
- "password": "tbdsdc-1480",
- "pollingInterval":20,
- "pollingTimeout":30,
- "consumerId": "policy-id",
- "artifactTypes": [
- "TOSCA_CSAR",
- "HEAT"
- ],
- "consumerGroup": "policy-group",
- "environmentName": "environmentName",
- "keystorePath": "null",
- "keystorePassword": "null",
- "activeserverTlsAuth": false,
- "isFilterinEmptyResources": true,
- "isUseHttpsWithDmaap": false
- },
+ "receptionHandlerConfigurationName":"dummyReceptionHandlerConfiguration",
"pluginHandlerParameters":{
"policyDecoders":{
"DummyDecoder":{
"decoderType":"DummyDecoder",
- "decoderClassName":"org.onap.policy.distribution.main.testclasses.DummyDecoder"
+ "decoderClassName":"org.onap.policy.distribution.main.testclasses.DummyDecoder",
+ "decoderConfigurationParameters": "dummyDecoderConfiguration"
}
},
"policyForwarders":{
"isManaged": true
}
}
+ },
+ "policyDecoderConfigurationParameters":{
+ "dummyDecoderConfiguration":{
+ "parameterClassName":"org.onap.policy.distribution.main.testclasses.DummyPolicyDecoderParameterGroup",
+ "parameters":{
+ "policyName": "SamplePolicy",
+ "policyType": "DUMMY"
+ }
+ }
}
}
"policyDecoders":{
"DummyDecoder":{
"decoderType":"DummyDecoder",
- "decoderClassName":"org.onap.policy.distribution.main.testclasses.DummyDecoder"
+ "decoderClassName":"org.onap.policy.distribution.main.testclasses.DummyDecoder",
+ "decoderConfigurationName": "dummyDecoderConfiguration"
}
},
"policyForwarders":{
"isManaged": true
}
}
+ },
+ "policyDecoderConfigurationParameters":{
+ "dummyDecoderConfiguration":{
+ "parameterClassName":"org.onap.policy.distribution.main.testclasses.DummyPolicyDecoderParameterGroup",
+ "parameters":{
+ "policyName": "SamplePolicy",
+ "policyType": "DUMMY"
+ }
+ }
}
}
package org.onap.policy.distribution.model;
-import java.io.InputStream;
-
/**
- * This class represents an apex-pdp policy which can be decoded by a relevant {@link PolicyDecoder}.
+ * This class represents a policy which can be decoded by a relevant {@link PolicyDecoder}.
*
* @author Ram Krishna Verma (ram.krishna.verma@ericsson.com)
*/
-public class ApexPdpPolicy implements Policy {
+public class PolicyAsString implements Policy {
private String policyName;
- private InputStream policyInputStream;
+ private String policyType;
+ private String policy;
/**
- * Constructor for creating instance of {@link ApexPdpPolicy}.
+ * Constructor for creating instance of {@link PolicyAsString}.
*
* @param policyName the policy file name
- * @param policyInputStream the input stream
+ * @param policyType the policy type
+ * @param policy the policy
*/
- public ApexPdpPolicy(final String policyName, final InputStream policyInputStream) {
+ public PolicyAsString(final String policyName, final String policyType, final String policy) {
this.policyName = policyName;
- this.policyInputStream = policyInputStream;
+ this.policyType = policyType;
+ this.policy = policy;
}
/**
- * Returns the policyInputStream of this ApexPdpPolicy instance.
+ * Returns the policy of this {@link PolicyAsString} instance.
*
- * @return the policyInputStream
+ * @return the policy
*/
- public InputStream getPolicyInputStream() {
- return policyInputStream;
+ public String getPolicy() {
+ return policy;
}
/**
*/
@Override
public String getPolicyType() {
- return "Method not supported";
+ return policyType;
}
}
package org.onap.policy.distribution.forwarding.apex.pdp;
+import java.io.IOException;
+import java.io.InputStream;
import java.util.Collection;
+import org.apache.commons.io.IOUtils;
import org.onap.policy.apex.core.deployment.EngineServiceFacade;
import org.onap.policy.apex.model.basicmodel.concepts.ApexException;
import org.onap.policy.common.logging.flexlogger.FlexLogger;
import org.onap.policy.distribution.forwarding.PolicyForwarder;
import org.onap.policy.distribution.forwarding.PolicyForwardingException;
import org.onap.policy.distribution.forwarding.xacml.pdp.XacmlPdpPolicyForwarder;
-import org.onap.policy.distribution.model.ApexPdpPolicy;
import org.onap.policy.distribution.model.Policy;
+import org.onap.policy.distribution.model.PolicyAsString;
/**
* This class provides an implementation of {@link PolicyForwarder} interface for forwarding the given policies to
public class ApexPdpPolicyForwarder implements PolicyForwarder {
private static final Logger LOGGER = FlexLogger.getLogger(XacmlPdpPolicyForwarder.class);
+ private static final String POLICY_TYPE = "APEX";
private ApexPdpPolicyForwarderParameterGroup apexForwarderParameters;
private EngineServiceFacade engineServiceFacade;
} else {
final Policy policy = (Policy) policies.toArray()[0];
- if (policy.getClass().isAssignableFrom(ApexPdpPolicy.class)) {
- forwardPolicy((ApexPdpPolicy) policy);
+ if (policy.getClass().isAssignableFrom(PolicyAsString.class)
+ && policy.getPolicyType().equalsIgnoreCase(POLICY_TYPE)) {
+ forwardPolicy((PolicyAsString) policy);
} else {
final String message = "Ignoring the policy as it is not an apex-pdp policy";
LOGGER.debug(message);
* @param apexPolicy the apex policy
* @throws PolicyForwardingException if any exception occurs while forwarding policy
*/
- private void forwardPolicy(final ApexPdpPolicy apexPolicy) throws PolicyForwardingException {
+ private void forwardPolicy(final PolicyAsString apexPolicy) throws PolicyForwardingException {
try {
engineServiceFacade.init();
- engineServiceFacade.deployModel(apexPolicy.getPolicyName(), apexPolicy.getPolicyInputStream(),
+ final InputStream policyInputStream = IOUtils.toInputStream(apexPolicy.getPolicy(), "UTF-8");
+ engineServiceFacade.deployModel(apexPolicy.getPolicyName(), policyInputStream,
apexForwarderParameters.isIgnoreConflicts(), apexForwarderParameters.isForceUpdate());
LOGGER.debug("Sucessfully forwarded the policy to apex-pdp egine at "
+ apexForwarderParameters.getHostname() + ":" + apexForwarderParameters.getPort());
- } catch (final ApexException exp) {
+ } catch (final ApexException | IOException exp) {
final String message = "Error sending policy to apex-pdp engine at" + apexForwarderParameters.getHostname()
+ ":" + apexForwarderParameters.getPort();
LOGGER.error(message, exp);
import org.junit.Test;
import org.onap.policy.common.parameters.ValidationStatus;
+/**
+ * Class to perform unit test of {@link ApexPdpPolicyForwarderParameterGroup}.
+ *
+ * @author Ram Krishna Verma (ram.krishna.verma@ericsson.com)
+ */
public class ApexPdpPolicyForwarderParameterGroupTest {
@Test
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
+import static org.mockito.Matchers.anyObject;
+import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
-import java.io.File;
-import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.lang.reflect.Field;
import org.onap.policy.common.parameters.ParameterGroup;
import org.onap.policy.common.parameters.ParameterService;
import org.onap.policy.distribution.forwarding.PolicyForwardingException;
-import org.onap.policy.distribution.model.ApexPdpPolicy;
import org.onap.policy.distribution.model.Policy;
+import org.onap.policy.distribution.model.PolicyAsString;
+/**
+ * Class to perform unit test of {@link ApexPdpPolicyForwarder}.
+ *
+ * @author Ram Krishna Verma (ram.krishna.verma@ericsson.com)
+ */
@RunWith(MockitoJUnitRunner.class)
public class ApexPdpPolicyForwarderTest {
public void testForwardPolicy() throws ApexException, FileNotFoundException, IOException, PolicyForwardingException,
NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
- final FileInputStream fis = new FileInputStream(File.createTempFile("policy1", null));
final Collection<Policy> policies = new ArrayList<>();
final ApexPdpPolicyForwarder forwarder = new ApexPdpPolicyForwarder();
forwarder.configure(GROUP_NAME);
forwarderField.setAccessible(true);
forwarderField.set(forwarder, engineServiceFacade);
- final ApexPdpPolicy policy = new ApexPdpPolicy("policy", fis);
+ final PolicyAsString policy = new PolicyAsString("policy", "APEX", "Sample Policy of apex");
policies.add(policy);
try {
forwarder.forward(policies);
verify(engineServiceFacade, times(1)).init();
- verify(engineServiceFacade, times(1)).deployModel("policy", fis, IGNORE_CONFLICTS, FORCE_UPDATE);
+ verify(engineServiceFacade, times(1)).deployModel(eq("policy"), anyObject(), eq(IGNORE_CONFLICTS),
+ eq(FORCE_UPDATE));
} catch (final Exception exp) {
fail("Test must not throw an exception");
}
throws ApexException, FileNotFoundException, IOException, PolicyForwardingException, NoSuchFieldException,
SecurityException, IllegalArgumentException, IllegalAccessException {
- final FileInputStream fis = new FileInputStream(File.createTempFile("policy1", null));
final Collection<Policy> policies = new ArrayList<>();
final ApexPdpPolicyForwarder forwarder = new ApexPdpPolicyForwarder();
forwarder.configure(GROUP_NAME);
- Mockito.doThrow(new ApexException("Failed")).when(engineServiceFacade).deployModel("policy1", fis,
- IGNORE_CONFLICTS, FORCE_UPDATE);
+ Mockito.doThrow(new ApexException("Failed")).when(engineServiceFacade).deployModel(eq("policy1"), anyObject(),
+ eq(IGNORE_CONFLICTS), eq(FORCE_UPDATE));
final Field decodersField = forwarder.getClass().getDeclaredField("engineServiceFacade");
decodersField.setAccessible(true);
decodersField.set(forwarder, engineServiceFacade);
- final ApexPdpPolicy policy1 = new ApexPdpPolicy("policy1", fis);
+ final PolicyAsString policy1 = new PolicyAsString("policy1", "APEX", "Sample Policy of apex");
policies.add(policy1);
try {
forwarderField.setAccessible(true);
forwarderField.set(forwarder, engineServiceFacade);
- final ApexPdpPolicy policy1 =
- new ApexPdpPolicy("policy1", new FileInputStream(File.createTempFile("policy1", null)));
+ final PolicyAsString policy1 = new PolicyAsString("policy1", "APEX", "Sample Policy of apex");
policies.add(policy1);
- final ApexPdpPolicy policy2 =
- new ApexPdpPolicy("policy2", new FileInputStream(File.createTempFile("policy2", null)));
+ final PolicyAsString policy2 = new PolicyAsString("policy2", "APEX", "Sample Policy of apex");
policies.add(policy2);
try {
public Collection<Policy> decode(final PolicyInput input) throws PolicyDecodingException {
return policesToReturn;
}
+
+ @Override
+ public void configure(final String parameterGroupName) {}
}
* 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.
- *
+ *
* SPDX-License-Identifier: Apache-2.0
* ============LICENSE_END=========================================================
*/
import java.io.File;
import java.util.ArrayList;
-import java.util.List;
-
import java.util.Collection;
-import java.util.Collections;
-
+import java.util.List;
import org.onap.policy.common.logging.flexlogger.FlexLogger;
import org.onap.policy.common.logging.flexlogger.Logger;
-
-import org.onap.policy.distribution.model.PolicyInput;
import org.onap.policy.distribution.model.Csar;
+import org.onap.policy.distribution.model.PolicyInput;
import org.onap.policy.distribution.reception.decoding.PolicyDecoder;
import org.onap.policy.distribution.reception.decoding.PolicyDecodingException;
-
import org.onap.sdc.tosca.parser.api.ISdcCsarHelper;
-import org.onap.sdc.tosca.parser.impl.SdcCsarHelperImpl;
import org.onap.sdc.tosca.parser.impl.SdcToscaParserFactory;
-
import org.onap.sdc.toscaparser.api.NodeTemplate;
-import org.onap.sdc.toscaparser.api.elements.Metadata;
/**
* Decodes PDP-X policies from a TOSCA file.
private static final Logger LOGGER = FlexLogger.getLogger(PolicyDecoderCsarPdpx.class);
@Override
- public Collection<PdpxPolicy> decode(Csar csar) throws PolicyDecodingException {
- // logic for generating the policies from the CSAR.
- List<PdpxPolicy> lPdpxPolicy = new ArrayList<>();
- ISdcCsarHelper sdcCsarHelper = parseCsar(csar);
- List<NodeTemplate> lnodeVf = sdcCsarHelper.getServiceVfList();
+ public Collection<PdpxPolicy> decode(final Csar csar) throws PolicyDecodingException {
+ // logic for generating the policies from the CSAR.
+
final List<PdpxPolicy> lPdpxPolicy = new ArrayList<>();
+ final ISdcCsarHelper sdcCsarHelper = parseCsar(csar);
+ final List<NodeTemplate> lnodeVf = sdcCsarHelper.getServiceVfList();
LOGGER.debug("the size of Vf = " + lnodeVf.size());
- ExtractFromNode extractFromNode = new ExtractFromNode();
+ final ExtractFromNode extractFromNode = new ExtractFromNode();
extractFromNode.setSdcCsarHelper(sdcCsarHelper);
- for ( NodeTemplate node : lnodeVf) {
- PdpxPolicy ret = extractFromNode.extractInfo(node);
+ for (final NodeTemplate node : lnodeVf) {
+ final PdpxPolicy ret = extractFromNode.extractInfo(node);
if (ret != null) {
lPdpxPolicy.add(ret);
}
}
@Override
- public boolean canHandle(PolicyInput policyInput) {
+ public boolean canHandle(final PolicyInput policyInput) {
return policyInput.getClass().isAssignableFrom(Csar.class);
}
- /**
+ /**
* Parse the input Csar by SDC tosca tool.
*
* @param csar represents the service TOSCA Csar
* @return the object to represents the content of input csar
* @throws PolicyDecodingException if parse fails
*/
- public ISdcCsarHelper parseCsar(Csar csar) throws PolicyDecodingException {
- ISdcCsarHelper sdcCsarHelper ;
+ public ISdcCsarHelper parseCsar(final Csar csar) throws PolicyDecodingException {
+ ISdcCsarHelper sdcCsarHelper;
try {
- SdcToscaParserFactory factory = SdcToscaParserFactory.getInstance();//Autoclosable
+ final SdcToscaParserFactory factory = SdcToscaParserFactory.getInstance();// Autoclosable
LOGGER.debug("tosca File Path = " + csar.getCsarPath());
- File spoolFile = new File(csar.getCsarPath());
+ final File spoolFile = new File(csar.getCsarPath());
sdcCsarHelper = factory.getSdcCsarHelper(spoolFile.getAbsolutePath());
- } catch (Exception e) {
- LOGGER.error("Exception got in parseTosca",e);
- throw new PolicyDecodingException ("Exception caught when passing the csar file to the parser ", e);
+ } catch (final Exception e) {
+ LOGGER.error("Exception got in parseTosca", e);
+ throw new PolicyDecodingException("Exception caught when passing the csar file to the parser ", e);
}
return sdcCsarHelper;
}
+ @Override
+ public void configure(final String parameterGroupName) {}
+
}
* 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.
- *
+ *
* SPDX-License-Identifier: Apache-2.0
* ============LICENSE_END=========================================================
*/
import java.util.Collection;
import java.util.Collections;
+
import org.onap.policy.distribution.model.PolicyInput;
import org.onap.policy.distribution.model.Tosca;
import org.onap.policy.distribution.reception.decoding.PolicyDecoder;
public class PolicyDecoderToscaPdpx implements PolicyDecoder<Tosca, PdpxPolicy> {
@Override
- public Collection<PdpxPolicy> decode(Tosca tosca) {
+ public Collection<PdpxPolicy> decode(final Tosca tosca) {
// Add logic for generating the policies from the TOSCA
return Collections.emptySet();
}
@Override
- public boolean canHandle(PolicyInput policyInput) {
+ public boolean canHandle(final PolicyInput policyInput) {
return policyInput.getClass().isAssignableFrom(Tosca.class);
}
+ @Override
+ public void configure(final String parameterGroupName) {}
+
}
--- /dev/null
+/*-
+ * ============LICENSE_START=======================================================
+ * Copyright (C) 2018 Ericsson. 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.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.distribution.reception.decoding.policy.file;
+
+import java.io.IOException;
+import java.io.StringWriter;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Enumeration;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipFile;
+
+import org.apache.commons.io.IOUtils;
+import org.onap.policy.common.logging.flexlogger.FlexLogger;
+import org.onap.policy.common.logging.flexlogger.Logger;
+import org.onap.policy.common.parameters.ParameterService;
+import org.onap.policy.distribution.model.Csar;
+import org.onap.policy.distribution.model.PolicyAsString;
+import org.onap.policy.distribution.model.PolicyInput;
+import org.onap.policy.distribution.reception.decoding.PolicyDecoder;
+import org.onap.policy.distribution.reception.decoding.PolicyDecodingException;
+
+/**
+ * This class extracts policy files from a CSAR file.
+ *
+ * @author Ram Krishna Verma (ram.krishna.verma@ericsson.com)
+ */
+public class PolicyDecoderFileInCsarToPolicy implements PolicyDecoder<Csar, PolicyAsString> {
+
+ private static final Logger LOGGER = FlexLogger.getLogger(PolicyDecoderFileInCsarToPolicy.class);
+ PolicyDecoderFileInCsarToPolicyParameterGroup decoderParameters;
+
+ /**
+ * {@inheritDoc}.
+ */
+ @Override
+ public void configure(final String parameterGroupName) {
+ decoderParameters = ParameterService.get(parameterGroupName);
+ }
+
+ /**
+ * {@inheritDoc}.
+ */
+ @Override
+ public boolean canHandle(final PolicyInput policyInput) {
+ return policyInput.getClass().isAssignableFrom(Csar.class);
+ }
+
+ /**
+ * {@inheritDoc}.
+ */
+ @Override
+ public Collection<PolicyAsString> decode(final Csar csar) throws PolicyDecodingException {
+ final Collection<PolicyAsString> policyList = new ArrayList<>();
+
+ try (ZipFile zipFile = new ZipFile(csar.getCsarPath())) {
+ final Enumeration<? extends ZipEntry> entries = zipFile.entries();
+ while (entries.hasMoreElements()) {
+ final ZipEntry entry = entries.nextElement();
+ if (entry.getName().contains(decoderParameters.getPolicyFileName())) {
+ final StringWriter writer = new StringWriter();
+ IOUtils.copy(zipFile.getInputStream(entry), writer, "UTF-8");
+ final PolicyAsString poilcy = new PolicyAsString(decoderParameters.getPolicyFileName(),
+ decoderParameters.getPolicyType(), writer.toString());
+ policyList.add(poilcy);
+ }
+ }
+ } catch (final IOException exp) {
+ final String message = "Failed decoding the policy";
+ LOGGER.error(message, exp);
+ throw new PolicyDecodingException(message, exp);
+ }
+
+ return policyList;
+ }
+}
--- /dev/null
+/*-
+ * ============LICENSE_START=======================================================
+ * Copyright (C) 2018 Ericsson. 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.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.distribution.reception.decoding.policy.file;
+
+import org.onap.policy.common.parameters.GroupValidationResult;
+import org.onap.policy.common.parameters.ValidationStatus;
+import org.onap.policy.common.utils.validation.ParameterValidationUtils;
+import org.onap.policy.distribution.reception.parameters.PolicyDecoderConfigurationParameterGroup;
+
+/**
+ * Holds the parameters for the{@link PolicyDecoderFileInCsarToPolicy}.
+ *
+ * @author Ram Krishna Verma (ram.krishna.verma@ericsson.com)
+ */
+public class PolicyDecoderFileInCsarToPolicyParameterGroup extends PolicyDecoderConfigurationParameterGroup {
+
+ private String policyFileName;
+ private String policyType;
+
+ /**
+ * Constructor for instantiating {@link PolicyDecoderFileInCsarToPolicyParameterGroup} class.
+ *
+ * @param policyFileName the policy file name
+ * @param policyType the policy type
+ */
+ public PolicyDecoderFileInCsarToPolicyParameterGroup(final String policyFileName, final String policyType) {
+ this.policyFileName = policyFileName;
+ this.policyType = policyType;
+ }
+
+ public String getPolicyFileName() {
+ return policyFileName;
+ }
+
+ public String getPolicyType() {
+ return policyType;
+ }
+
+ @Override
+ public GroupValidationResult validate() {
+ final GroupValidationResult validationResult = new GroupValidationResult(this);
+ if (!ParameterValidationUtils.validateStringParameter(policyFileName)) {
+ validationResult.setResult("policyFileName", ValidationStatus.INVALID,
+ "must be a non-blank string containing the policy file name");
+ }
+ if (!ParameterValidationUtils.validateStringParameter(policyType)) {
+ validationResult.setResult("policyType", ValidationStatus.INVALID,
+ "must be a non-blank string containing the policy type");
+ }
+ return validationResult;
+ }
+}
--- /dev/null
+/*-
+ * ============LICENSE_START=======================================================
+ * Copyright (C) 2018 Ericsson. 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.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.distribution.reception.decoding.policy.file;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+import org.onap.policy.common.parameters.ValidationStatus;
+import org.onap.policy.distribution.reception.decoding.policy.file.PolicyDecoderFileInCsarToPolicyParameterGroup;
+
+/**
+ * Class to perform unit test of {@link PolicyDecoderFileInCsarToPolicyParameterGroup}.
+ *
+ * @author Ram Krishna Verma (ram.krishna.verma@ericsson.com)
+ */
+public class PolicyDecoderFileInCsarToPolicyParameterGroupTest {
+
+ @Test
+ public void testConstructorAndGetters() {
+ final PolicyDecoderFileInCsarToPolicyParameterGroup configurationParameters =
+ new PolicyDecoderFileInCsarToPolicyParameterGroup("SamplePolicy", "APEX");
+ configurationParameters.setName("myConfiguration");
+
+ assertEquals("myConfiguration", configurationParameters.getName());
+ assertEquals("SamplePolicy", configurationParameters.getPolicyFileName());
+ assertEquals("APEX", configurationParameters.getPolicyType());
+ assertEquals(ValidationStatus.CLEAN, configurationParameters.validate().getStatus());
+ }
+
+ @Test
+ public void testInvalidPolicyFileName() {
+ final PolicyDecoderFileInCsarToPolicyParameterGroup configurationParameters =
+ new PolicyDecoderFileInCsarToPolicyParameterGroup("", "APEX");
+ configurationParameters.setName("myConfiguration");
+
+ assertEquals(ValidationStatus.INVALID, configurationParameters.validate().getStatus());
+ }
+
+ @Test
+ public void testInvalidPolicyType() {
+ final PolicyDecoderFileInCsarToPolicyParameterGroup configurationParameters =
+ new PolicyDecoderFileInCsarToPolicyParameterGroup("SamplePolicy", "");
+ configurationParameters.setName("myConfiguration");
+
+ assertEquals(ValidationStatus.INVALID, configurationParameters.validate().getStatus());
+ }
+}
--- /dev/null
+/*-
+ * ============LICENSE_START=======================================================
+ * Copyright (C) 2018 Ericsson. 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.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.distribution.reception.decoding.policy.file;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.Collection;
+
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.runners.MockitoJUnitRunner;
+import org.onap.policy.common.parameters.ParameterService;
+import org.onap.policy.distribution.model.Csar;
+import org.onap.policy.distribution.model.PolicyAsString;
+
+/**
+ * Class to perform unit test of {@link PolicyDecoderFileInCsarToPolicy}.
+ *
+ * @author Ram Krishna Verma (ram.krishna.verma@ericsson.com)
+ */
+@RunWith(MockitoJUnitRunner.class)
+public class PolicyDecoderFileInCsarToPolicyTest {
+
+ private static final String POLICY_FILE_NAME = "SamplePolicyModelJAVASCRIPT";
+ private static final String POLICY_TYPE = "APEX";
+ private static final String GROUP_NAME = "apexPdpDecoderConfiguration";
+
+ /**
+ * Set up.
+ */
+ @BeforeClass
+ public static void setUp() {
+ final PolicyDecoderFileInCsarToPolicyParameterGroup configurationParameters =
+ new PolicyDecoderFileInCsarToPolicyParameterGroup(POLICY_FILE_NAME, POLICY_TYPE);
+ configurationParameters.setName(GROUP_NAME);
+ ParameterService.register(configurationParameters);
+ }
+
+ /**
+ * Tear down.
+ */
+ @AfterClass
+ public static void tearDown() {
+ ParameterService.deregister(GROUP_NAME);
+ }
+
+ @Test
+ public void testDecodePolicy() {
+
+ final PolicyDecoderFileInCsarToPolicy decoder = new PolicyDecoderFileInCsarToPolicy();
+ decoder.configure(GROUP_NAME);
+
+ final File file = new File("src/test/resources/sampleTestService.csar");
+ final Csar csar = new Csar(file.getAbsolutePath());
+
+ try {
+ decoder.canHandle(csar);
+ final Collection<PolicyAsString> policyHolders = decoder.decode(csar);
+ for (final PolicyAsString policy : policyHolders) {
+ assertEquals(POLICY_FILE_NAME, policy.getPolicyName());
+ assertEquals(POLICY_TYPE, policy.getPolicyType());
+ }
+ } catch (final Exception exp) {
+ fail("Test must not throw an exception");
+ }
+ }
+
+ @Test
+ public void testDecodePolicyError() throws IOException {
+
+ final PolicyDecoderFileInCsarToPolicy decoder = new PolicyDecoderFileInCsarToPolicy();
+ decoder.configure(GROUP_NAME);
+
+ final File file = new File("unknown.csar");
+ final Csar csar = new Csar(file.getAbsolutePath());
+
+ try {
+ decoder.canHandle(csar);
+ decoder.decode(csar);
+ fail("Test must throw an exception");
+ } catch (final Exception exp) {
+ assertTrue(exp.getMessage().contains("Failed decoding the policy"));
+ }
+ }
+}
public DummyPolicy getDecodedPolicy() {
return decodedPolicy;
}
+
+ @Override
+ public void configure(final String parameterGroupName) {}
}
private Map<String, PolicyDecoderParameters> getPolicyDecoders() {
final Map<String, PolicyDecoderParameters> policyDecoders = new HashMap<String, PolicyDecoderParameters>();
final PolicyDecoderParameters pDParameters = new PolicyDecoderParameters("DummyDecoder",
- "org.onap.policy.distribution.reception.handling.sdc.DummyDecoder");
+ "org.onap.policy.distribution.reception.handling.sdc.DummyDecoder", "DummyDecoderConfiguration");
policyDecoders.put("DummyDecoderKey", pDParameters);
return policyDecoders;
}
*/
public interface PolicyDecoder<S extends PolicyInput, T extends Policy> {
+ /**
+ * Configure the policy decoder. This method will be invoked immediately after instantiation in order for the policy
+ * decoder to configure itself.
+ *
+ * @param parameterGroupName the name of the parameter group which contains the configuration for the policy decoder
+ */
+ void configure(String parameterGroupName);
+
/**
* Can the decoder handle input of the specified type.
*
(Class<PolicyDecoder<PolicyInput, Policy>>) Class
.forName(decoderParameters.getDecoderClassName());
final PolicyDecoder<PolicyInput, Policy> decoder = policyDecoderClass.newInstance();
+ decoder.configure(decoderParameters.getDecoderConfigurationName());
policyDecoders.add(decoder);
} catch (final ClassNotFoundException | InstantiationException | IllegalAccessException exp) {
LOGGER.error("exception occured while initializing decoders", exp);
--- /dev/null
+/*-
+ * ============LICENSE_START=======================================================
+ * Copyright (C) 2018 Ericsson. 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.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.distribution.reception.parameters;
+
+import org.onap.policy.common.parameters.ParameterGroup;
+import org.onap.policy.distribution.reception.decoding.PolicyDecoder;
+
+/**
+ * Base class of all {@link ParameterGroup} classes for configuration parameters for {@link PolicyDecoder} classes.
+ *
+ * @author Ram Krishna Verma (ram.krishna.verma@ericsson.com)
+ */
+public abstract class PolicyDecoderConfigurationParameterGroup implements ParameterGroup {
+
+ private String name;
+
+ @Override
+ public String getName() {
+ return name;
+ }
+
+ @Override
+ public void setName(final String name) {
+ this.name = name;
+ }
+
+}
--- /dev/null
+/*-
+ * ============LICENSE_START=======================================================
+ * Copyright (C) 2018 Ericsson. 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.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.distribution.reception.parameters;
+
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonDeserializer;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonPrimitive;
+
+import java.lang.reflect.Type;
+
+import org.slf4j.ext.XLogger;
+import org.slf4j.ext.XLoggerFactory;
+
+/**
+ * This class deserialises policy decoder parameters from JSON.
+ *
+ * @author Ram Krishna Verma (ram.krishna.verma@ericsson.com)
+ */
+public class PolicyDecoderConfigurationParametersJsonAdapter
+ implements JsonDeserializer<PolicyDecoderConfigurationParameterGroup> {
+ private static final XLogger LOGGER =
+ XLoggerFactory.getXLogger(PolicyDecoderConfigurationParametersJsonAdapter.class);
+
+ private static final String PARAMETER_CLASS_NAME = "parameterClassName";
+ private static final String POLICY_DECODER_PARAMETERS = "parameters";
+
+ @Override
+ public PolicyDecoderConfigurationParameterGroup deserialize(final JsonElement json, final Type typeOfT,
+ final JsonDeserializationContext context) {
+ final JsonObject jsonObject = json.getAsJsonObject();
+
+ final String policyDecoderParameterClassName = getParameterGroupClassName(jsonObject);
+ final Class<?> policyDecoderParameterClass = getParameterGroupClass(policyDecoderParameterClassName);
+
+ return context.deserialize(jsonObject.get(POLICY_DECODER_PARAMETERS), policyDecoderParameterClass);
+ }
+
+ private String getParameterGroupClassName(final JsonObject jsonObject) {
+ final JsonPrimitive classNameJsonPrimitive = ((JsonPrimitive) jsonObject.get(PARAMETER_CLASS_NAME));
+
+ if (classNameJsonPrimitive == null || classNameJsonPrimitive.getAsString().length() == 0) {
+ final String errorMessage = "parameter \"" + PARAMETER_CLASS_NAME + "\" value \""
+ + (classNameJsonPrimitive != null ? classNameJsonPrimitive.getAsString() : "null")
+ + "\" invalid in JSON file";
+ LOGGER.warn(errorMessage);
+ throw new IllegalArgumentException(errorMessage);
+ }
+ return classNameJsonPrimitive.getAsString().replaceAll("\\s+", "");
+ }
+
+ private Class<?> getParameterGroupClass(final String policyDecoderParameterClassName) {
+ Class<?> policyDecoderParameterClass = null;
+ try {
+ policyDecoderParameterClass = Class.forName(policyDecoderParameterClassName);
+ } catch (final ClassNotFoundException exp) {
+ final String errorMessage = "parameter \"" + PARAMETER_CLASS_NAME + "\" value \""
+ + policyDecoderParameterClassName + "\", could not find class";
+ LOGGER.warn(errorMessage, exp);
+ throw new IllegalArgumentException(errorMessage, exp);
+ }
+ return policyDecoderParameterClass;
+ }
+
+}
private String decoderType;
private String decoderClassName;
+ private String decoderConfigurationName;
/**
* Constructor for instantiating PolicyDecoderParameters.
*
* @param decoderType the policy decoder type
* @param decoderClassName the policy decoder class name
+ * @param decoderConfigurationName the policy decoder configuration name
*/
- public PolicyDecoderParameters(final String decoderType, final String decoderClassName) {
+ public PolicyDecoderParameters(final String decoderType, final String decoderClassName,
+ final String decoderConfigurationName) {
this.decoderType = decoderType;
this.decoderClassName = decoderClassName;
+ this.decoderConfigurationName = decoderConfigurationName;
}
/**
return decoderClassName;
}
+ /**
+ * Return the name of the decoder configuration of this {@link PolicyDecoderParameters} instance.
+ *
+ * @return the the name of the decoder configuration
+ */
+ public String getDecoderConfigurationName() {
+ return decoderConfigurationName;
+ }
+
/**
* {@inheritDoc}
*/
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
+
import org.junit.Test;
import org.onap.policy.common.parameters.ParameterService;
import org.onap.policy.distribution.forwarding.PolicyForwarder;
private static final String FORWARDER_CLASS_NAME =
"org.onap.policy.distribution.reception.handling.DummyPolicyForwarder";
private static final String FORWARDER_CONFIGURATION_PARAMETERS = "DummyConfiguration";
+ private static final String DECODER_CONFIGURATION_PARAMETERS = "DummyDecoderConfiguration";
@Test
public void testInputReceived() throws PolicyDecodingException, NoSuchFieldException, SecurityException,
private Map<String, PolicyDecoderParameters> getPolicyDecoders() {
final Map<String, PolicyDecoderParameters> policyDecoders = new HashMap<String, PolicyDecoderParameters>();
- final PolicyDecoderParameters pDParameters = new PolicyDecoderParameters(DECODER_TYPE, DECODER_CLASS_NAME);
+ final PolicyDecoderParameters pDParameters =
+ new PolicyDecoderParameters(DECODER_TYPE, DECODER_CLASS_NAME, DECODER_CONFIGURATION_PARAMETERS);
policyDecoders.put(DECODER_KEY, pDParameters);
return policyDecoders;
}
public Collection<Policy> decode(final PolicyInput input) throws PolicyDecodingException {
return policesToReturn;
}
+
+ @Override
+ public void configure(final String parameterGroupName) {}
}
Code Review / policy / distribution.git / commitdiff