--- /dev/null
+/*-
+ * ============LICENSE_START=======================================================
+ * ECOMP-XACML
+ * ================================================================================
+ * Copyright (C) 2017 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.openecomp.policy.xacml.test;
+
+import java.io.IOException;
+import java.net.MalformedURLException;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.SimpleFileVisitor;
+import java.nio.file.attribute.BasicFileAttributes;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.regex.Matcher;
+
+import javax.xml.bind.JAXBContext;
+import javax.xml.bind.JAXBElement;
+import javax.xml.bind.Marshaller;
+
+import oasis.names.tc.xacml._3_0.core.schema.wd_17.AttributeType;
+import oasis.names.tc.xacml._3_0.core.schema.wd_17.AttributeValueType;
+import oasis.names.tc.xacml._3_0.core.schema.wd_17.AttributesType;
+import oasis.names.tc.xacml._3_0.core.schema.wd_17.ObjectFactory;
+import oasis.names.tc.xacml._3_0.core.schema.wd_17.PolicySetType;
+import oasis.names.tc.xacml._3_0.core.schema.wd_17.PolicyType;
+import oasis.names.tc.xacml._3_0.core.schema.wd_17.RequestType;
+
+import org.apache.commons.cli.CommandLine;
+import org.apache.commons.cli.GnuParser;
+import org.apache.commons.cli.Option;
+import org.apache.commons.cli.ParseException;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+import com.att.research.xacml.api.AttributeValue;
+import com.att.research.xacml.api.DataType;
+import com.att.research.xacml.api.DataTypeException;
+import com.att.research.xacml.api.DataTypeFactory;
+import com.att.research.xacml.api.Identifier;
+import com.att.research.xacml.api.XACML3;
+import com.att.research.xacml.std.IdentifierImpl;
+import com.att.research.xacml.util.FactoryException;
+import com.att.research.xacml.util.XACMLObjectCopy;
+import com.att.research.xacml.util.XACMLPolicyAggregator;
+import com.att.research.xacml.util.XACMLPolicyScanner;
+import com.att.research.xacml.util.XACMLProperties;
+
+/**
+ * This class reads the policy in and extracts all the attributes and their values that is contained
+ * in the Policy. It then generates a request every single combination of attributes found.
+ *
+ * The attributes mostly come from the Target Match elements, since they have both an attribute designator/selector
+ * matched with an attribute value.
+ *
+ *
+ */
+public class TestPolicy extends TestBase {
+ private static Log logger = LogFactory.getLog(TestPolicy.class);
+
+ private boolean skip;
+ private Path policy;
+ private XACMLPolicyAggregator aggregator = new XACMLPolicyAggregator();
+ private long index;
+
+ //
+ // Our command line parameters
+ //
+ public static final String OPTION_POLICY = "policy";
+ public static final String OPTION_SKIP_GENERATE = "skip";
+
+ static {
+ options.addOption(new Option(OPTION_POLICY, true, "Path to the policy file."));
+ options.addOption(new Option(OPTION_SKIP_GENERATE, false, "Skip generating requests."));
+ }
+
+ public class FlattenerObject {
+ Identifier category;
+ Identifier datatype;
+ Identifier attribute;
+ Set<AttributeValue<?>> values;
+ }
+
+ /**
+ * This application exercises a policy by producing ALL the possible request combinations for a policy.
+ *
+ * -policy Path to a policy file
+ *
+ * @param args
+ * @throws HelpException
+ * @throws ParseException
+ * @throws MalformedURLException
+ */
+
+ public TestPolicy(String[] args) throws MalformedURLException, ParseException, HelpException {
+ super(args);
+ }
+
+ /*
+ * Look for the -policy command line argument. This application needs a pointer to a specific policy
+ * in order to run.
+ *
+ *
+ * (non-Javadoc)
+ * @see com.att.research.xacmlatt.pdp.test.TestBase#parseCommands(java.lang.String[])
+ */
+ @Override
+ protected void parseCommands(String[] args) throws ParseException, MalformedURLException, HelpException {
+ //
+ // Have our super do its job
+ //
+ super.parseCommands(args);
+ //
+ // Look for the policy option
+ //
+ CommandLine cl;
+ cl = new GnuParser().parse(options, args);
+ if (cl.hasOption(OPTION_POLICY)) {
+ this.policy = Paths.get(cl.getOptionValue(OPTION_POLICY));
+ //
+ // Ensure it exists
+ //
+ if (Files.notExists(this.policy)) {
+ throw new ParseException("Policy file does not exist.");
+ }
+ } else {
+ throw new ParseException("You need to specify the policy file to be used.");
+ }
+ if (cl.hasOption(OPTION_SKIP_GENERATE)) {
+ this.skip = true;
+ } else {
+ this.skip = false;
+ }
+ }
+
+ /*
+ * We override this method because here is where we want to scan the policy and aggregate all
+ * the attributes that are defined within the policy. This routine will then dump all the possible
+ * requests into the requests sub-directory. Thus, when this method returns the TestBase can proceed
+ * to iterate each generated request and run it against the PDP engine.
+ *
+ * (non-Javadoc)
+ * @see com.att.research.xacmlatt.pdp.test.TestBase#configure()
+ */
+ @Override
+ protected void configure() throws FactoryException {
+ //
+ // Have our base class do its thing
+ //
+ super.configure();
+ //
+ // Setup where the PDP can find the policy
+ //
+ System.setProperty(XACMLProperties.PROP_ROOTPOLICIES, "policy");
+ System.setProperty("policy.file", this.policy.toString());
+ //
+ // Determine if they want us to skip generation. This helps when a huge number of
+ // requests will get generated for a policy and can take some time to do so. The user
+ // can generate the requests once and then start testing a policy against the requests. Thus,
+ // the attributes never changed but the policy logic did (saves time).
+ //
+ if (this.skip) {
+ return;
+ }
+ //
+ // Now we will scan the policy and get all the attributes.
+ //
+ XACMLPolicyScanner scanner = new XACMLPolicyScanner(this.policy, this.aggregator);
+ //
+ // The scanner returns us a policy object
+ //
+ Object policyObject = scanner.scan();
+ //
+ // Just dump some info
+ //
+ if (policyObject instanceof PolicySetType) {
+ logger.info("Creating requests for policyset: " + ((PolicySetType)policyObject).getDescription());
+ } else if (policyObject instanceof PolicyType) {
+ logger.info("Creating requests for policy: " + ((PolicyType)policyObject).getDescription());
+ }
+ //
+ // Call the function to create the requests
+ //
+ if (policyObject != null) {
+ this.createRequests();
+ }
+
+ logger.info("Completed Generating requests.");
+ }
+
+ @SuppressWarnings("unchecked")
+ protected void createRequests() {
+ //
+ // Clear out our request directory
+ //
+ this.removeRequests();
+ //
+ // Get our map
+ //
+ Map<Identifier, Map<Identifier, Map<Identifier, Set<AttributeValue<?>>>>> attributeMap = this.aggregator.getAttributeMap();
+ //
+ // We're going to create an initial flat list of requests for each unique attribute ID. Unique being the
+ // category, datatype and attribute id.
+ //
+ // By flattening the list, it makes it easier to then generate all the combinations of possible requests.
+ //
+ List<FlattenerObject> attributes = new ArrayList<FlattenerObject>();
+ //
+ // Iterate through all the maps, we are going to flatten it
+ // out into an array list.
+ //
+ for (Map.Entry<Identifier, Map<Identifier, Map<Identifier, Set<AttributeValue<?>>>>> categoryEntry : attributeMap.entrySet()) {
+ String category = categoryEntry.getKey().toString();
+ if (logger.isDebugEnabled()) {
+ logger.debug("Category: " + category);
+ }
+ Map<Identifier, Map<Identifier, Set<AttributeValue<?>>>> datatypeMap = categoryEntry.getValue();
+ for (Map.Entry<Identifier, Map<Identifier, Set<AttributeValue<?>>>> datatypeEntry : datatypeMap.entrySet()) {
+ String datatype = datatypeEntry.getKey().toString();
+ if (logger.isDebugEnabled()) {
+ logger.debug("\tData Type: " + datatype);
+ }
+ Map<Identifier, Set<AttributeValue<?>>> attributeIDMap = datatypeEntry.getValue();
+ for (Map.Entry<Identifier, Set<AttributeValue<?>>> attributeIDEntry : attributeIDMap.entrySet()) {
+ String attributeID = attributeIDEntry.getKey().toString();
+ if (logger.isDebugEnabled()) {
+ logger.debug("\t\tAttribute ID: " + attributeID);
+ }
+ Set<AttributeValue<?>> attributeValueSet = attributeIDEntry.getValue();
+ //
+ // Sanity check to see if there are any values. Sometimes there isn't if an attribute
+ // is a designator that is part of a condition or variable.
+ //
+ if (attributeValueSet.isEmpty()) {
+ if (logger.isDebugEnabled()) {
+ logger.debug("No values for attribute " + attributeIDEntry.getKey().stringValue());
+ }
+ //
+ // Check for the boolean datatype, in that case we can safely
+ // assume the true/false are ALL the possible values.
+ //
+ if (datatypeEntry.getKey().equals(XACML3.ID_DATATYPE_BOOLEAN) == false) {
+ //
+ // Not boolean, so skip it
+ //
+ continue;
+ }
+ if (logger.isDebugEnabled()) {
+ logger.debug("No values but its a boolean datatype, we will include it anyway.");
+ }
+ }
+ //
+ // Create our flattener object
+ //
+ FlattenerObject flat = new FlattenerObject();
+ flat.category = categoryEntry.getKey();
+ flat.datatype = datatypeEntry.getKey();
+ flat.attribute = attributeIDEntry.getKey();
+ flat.values = new HashSet<AttributeValue<?>>();
+ if (datatypeEntry.getKey().equals(XACML3.ID_DATATYPE_BOOLEAN)) {
+ //
+ // There are only 2 possible values, true or false
+ //
+ flat.values.add(this.createAttributeValue(flat.datatype, true));
+ flat.values.add(this.createAttributeValue(flat.datatype, false));
+ } else {
+ flat.values.addAll(attributeValueSet);
+ }
+ attributes.add(flat);
+ }
+ }
+ }
+ if (attributes.size() <= 1) {
+ //
+ // Only one attribute, why bother
+ //
+ logger.info("Not enough attributes in policy: " + attributes.size());
+ return;
+ }
+ /*
+ * PLD work more on this later. This combinatorial formula is only accurate if each
+ * attribute has one value.
+ *
+ */
+ if (logger.isDebugEnabled()) {
+ //
+ // This isn't really accurate, if an attribute has more than one value
+ //
+ logger.debug(attributes.size() + " will generate " + computePossibleCombinations(attributes.size()));
+ }
+ this.index = 1;
+ for (int i = 0; i < attributes.size(); i++) {
+ FlattenerObject flat = attributes.get(i);
+ for (AttributeValue<?> value : flat.values) {
+ //
+ // Create a basic request object for just that attribute value.
+ //
+ RequestType request = new RequestType();
+ //
+ AttributesType attrs = new AttributesType();
+ attrs.setCategory(flat.category.stringValue());
+ request.getAttributes().add(attrs);
+ //
+ AttributeType attr = new AttributeType();
+ attr.setAttributeId(flat.attribute.stringValue());
+ attrs.getAttribute().add(attr);
+ //
+ AttributeValueType val = new AttributeValueType();
+ val.setDataType(flat.datatype.stringValue());
+ if (value.getValue() instanceof Collection) {
+ val.getContent().addAll((Collection<? extends Object>) value.getValue());
+ } else {
+ val.getContent().add(value.getValue().toString());
+ }
+ //
+ attr.getAttributeValue().add(val);
+ //
+ // Dump it out
+ //
+ this.writeRequest(request);
+ //
+ // Initiate recursive call to add other attributes to the request
+ //
+ this.recursivelyGenerateRequests(request, i + 1, attributes);
+ }
+ }
+ }
+
+ protected void recursivelyGenerateRequests(RequestType request, int i, List<FlattenerObject> attributes) {
+ if (logger.isTraceEnabled()) {
+ logger.trace("recursiveGenerate index: " + index + " i: " + i);
+ }
+ for ( ; i < attributes.size(); i++) {
+ FlattenerObject flat = attributes.get(i);
+ for (AttributeValue<?> value : flat.values) {
+ //
+ // Make a copy of the request
+ //
+ RequestType copyRequest = XACMLObjectCopy.deepCopy(request);
+ //
+ // Create the value object
+ //
+ AttributeValueType newValue = new AttributeValueType();
+ newValue.setDataType(flat.datatype.stringValue());
+ if (value.getValue() instanceof Collection) {
+ for (Object v : (Collection<?>) value.getValue()) {
+ newValue.getContent().add(v.toString());
+ }
+ } else {
+ newValue.getContent().add(value.getValue().toString());
+ }
+ //
+ // Add the value to the request
+ //
+ this.addAttribute(copyRequest, flat.category.stringValue(), flat.attribute.stringValue(), newValue);
+ //
+ // Now write it out
+ //
+ this.writeRequest(copyRequest);
+ //
+ // Recursively go through the rest of the attributes
+ //
+ this.recursivelyGenerateRequests(copyRequest, i + 1, attributes);
+ }
+ }
+ }
+
+ public static long computePossibleCombinations(long numberOfAttributes) {
+ long num = 0;
+ for (long i = numberOfAttributes; i > 0; i--) {
+ num += computeCombinations(numberOfAttributes, i);
+ }
+ return num;
+ }
+
+ public static long computeFactorial(long n) {
+ long fact = 1;
+ for (long i = 1; i <= n; i++) {
+ fact *= i;
+ }
+ return fact;
+ }
+
+ public static long computePermutationsWithoutRepetition(long n, long r) {
+ //
+ // n!
+ // ---------
+ // (n - r)!
+ //
+ long nPrime = 1;
+ long n_rPrime = 1;
+ for (long i = n; i > 1; i--) {
+ nPrime *= i;
+ }
+
+ for (long i = (n - r); i > 1; i--) {
+ n_rPrime *= i;
+ }
+ return nPrime / n_rPrime;
+ }
+
+ public static long computeCombinations(long n, long r) {
+ //
+ // n!
+ // -----------
+ // r! * (n-r)!
+ //
+ long nPrime = 1;
+ long rPrime = 1;
+ long n_rPrime = 1;
+
+ for (long i = n; i > 1; i--) {
+ nPrime *= i;
+ }
+
+ for (long i = r; i > 1; i--) {
+ rPrime *= i;
+ }
+
+ for (long i = (n - r); i > 1; i--) {
+ n_rPrime *= i;
+ }
+
+ return nPrime / (rPrime * n_rPrime);
+ }
+
+ protected Set<AttributeValue<?>> getAttributeValues(RequestType request) {
+ //
+ // Get our map
+ //
+ Map<Identifier, Map<Identifier, Map<Identifier, Set<AttributeValue<?>>>>> attributeMap = this.aggregator.getAttributeMap();
+ //
+ // Find the attribute
+ //
+ AttributesType attrs = request.getAttributes().get(0);
+ Map<Identifier, Map<Identifier, Set<AttributeValue<?>>>> categoryMap = attributeMap.get(new IdentifierImpl(attrs.getCategory()));
+ if (categoryMap != null) {
+ AttributeType a = attrs.getAttribute().get(0);
+ Map<Identifier, Set<AttributeValue<?>>> datatypeMap = categoryMap.get(new IdentifierImpl(a.getAttributeValue().get(0).getDataType()));
+ if (datatypeMap != null) {
+ Set<AttributeValue<?>> values = datatypeMap.get(new IdentifierImpl(a.getAttributeId()));
+ if (values != null) {
+ return values;
+ }
+ }
+ }
+ return Collections.emptySet();
+ }
+
+ protected AttributeValue<?> createAttributeValue(Identifier datatype, Object value) {
+ DataTypeFactory dataTypeFactory = null;
+ try {
+ dataTypeFactory = DataTypeFactory.newInstance();
+ if (dataTypeFactory == null) {
+ logger.error("Could not create data type factory");
+ return null;
+ }
+ } catch (FactoryException e) {
+ logger.error("Can't get Data type Factory: " + e.getLocalizedMessage());
+ return null;
+ }
+ DataType<?> dataTypeExtended = dataTypeFactory.getDataType(datatype);
+ if (dataTypeExtended == null) {
+ logger.error("Unknown datatype: " + datatype);
+ return null;
+ }
+ try {
+ return dataTypeExtended.createAttributeValue(value);
+ } catch (DataTypeException e) {
+ logger.error(e);
+ }
+ return null;
+ }
+
+ protected void removeRequests() {
+ //
+ // Delete any existing request files that we generate. i.e. Have the Unknown in the file name.
+ //
+ try {
+ Files.walkFileTree(Paths.get(this.directory.toString(), "requests"), new SimpleFileVisitor<Path>() {
+
+ @Override
+ public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
+ //
+ // Sanity check the file name
+ //
+ Matcher matcher = pattern.matcher(file.getFileName().toString());
+ if (matcher.matches()) {
+ try {
+ //
+ // Pull what this request is supposed to be
+ //
+ String group = null;
+ int count = matcher.groupCount();
+ if (count >= 1) {
+ group = matcher.group(count-1);
+ }
+ //
+ // Send it
+ //
+ if (group.equals("Unknown")) {
+ //
+ // Remove the file
+ //
+ Files.delete(file);
+ }
+ } catch (Exception e) {
+ logger.error(e);
+ e.printStackTrace();
+ }
+ }
+ return super.visitFile(file, attrs);
+ }
+ });
+ } catch (IOException e) {
+ logger.error("Failed to removeRequests from " + this.directory + " " + e);
+ }
+ }
+
+ protected void addRequests(RequestType request, List<RequestType> requests, int index) {
+ for (RequestType req : requests) {
+ //
+ // There really should only be one attribute
+ //
+ for (AttributesType attrs : req.getAttributes()) {
+ for (AttributeType attr : attrs.getAttribute()) {
+ for (AttributeValueType value : attr.getAttributeValue()) {
+ if (this.addAttribute(request, attrs.getCategory(), attr.getAttributeId(), value)) {
+ this.writeRequest(request);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ /**
+ * Writes the request into the "requests" sub-directory, relative to the value of the "directory" setup
+ * during initialization.
+ *
+ * Writing the requests out allows one to go back and easily refer to the request when analyzing the responses
+ * generated after the PDP decide() call. Also, one can then use the generated requests into any test tools
+ * they wish to build.
+ *
+ * @param request - The request to be written.
+ */
+ protected void writeRequest(RequestType request) {
+ if (logger.isTraceEnabled()) {
+ logger.trace("writeRequest: " + index);
+ }
+ try {
+ ObjectFactory of = new ObjectFactory();
+ JAXBElement<RequestType> requestElement = of.createRequest(request);
+ JAXBContext context = JAXBContext.newInstance(RequestType.class);
+ Marshaller m = context.createMarshaller();
+ m.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);
+ Path outFile = Paths.get(this.directory, "requests", String.format("Request.%06d.Unknown.xml", this.index));
+ m.marshal(requestElement, outFile.toFile());
+ } catch (Exception e) {
+ logger.error("Failed to write request: " + e.getMessage());
+ }
+ this.index++;
+ }
+
+ protected boolean addAttribute(RequestType request, String category, String id, AttributeValueType value) {
+ //
+ // See if the category exists
+ //
+ for (AttributesType attrs : request.getAttributes()) {
+ if (attrs.getCategory().equals(category)) {
+ //
+ // It does have the category. But does it have the attribute ID?
+ //
+ for (AttributeType attr : attrs.getAttribute()) {
+ if (attr.getAttributeId().equals(id)) {
+ //
+ // Yes, check for the same datatype
+ //
+ for (AttributeValueType val : attr.getAttributeValue()) {
+ if (val.getDataType().equals(value.getDataType())) {
+ //
+ // We have something already there
+ //
+ return false;
+ }
+ }
+ //
+ // The ID exists, but not the datatype
+ //
+ attr.getAttributeValue().add(value);
+ return true;
+ }
+ }
+ //
+ // If we get here, the ID does not exist
+ //
+ AttributeType attr = new AttributeType();
+ attr.setAttributeId(id);
+ attr.getAttributeValue().add(value);
+ attrs.getAttribute().add(attr);
+ return true;
+ }
+ }
+ //
+ // If we get here, the category does not exist. So add it in.
+ //
+ AttributesType attrs = new AttributesType();
+ attrs.setCategory(category);
+ AttributeType attr = new AttributeType();
+ attr.setAttributeId(id);
+ attr.getAttributeValue().add(value);
+ attrs.getAttribute().add(attr);
+ request.getAttributes().add(attrs);
+ return true;
+ }
+
+ public static void main(String[] args) {
+ try {
+ new TestPolicy(args).run();
+ } catch (ParseException | IOException | FactoryException e) {
+ logger.error(e);
+ } catch (HelpException e) {
+ }
+ }
+
+ /*
+ // Map<CATEGORY, MAP<DATATYPE, MAP<ATTRIBUTEID, SET<VALUES>>>
+ @SuppressWarnings("unchecked")
+ private void generateRequests(Map<Identifier, Map<Identifier, Map<Identifier, Set<AttributeValue<?>>>>> categoryMap) {
+ meta = new ArrayList<>();
+
+ for (Map.Entry<Identifier, Map<Identifier, Map<Identifier, Set<AttributeValue<?>>>>> categoryEntry : categoryMap.entrySet()) {
+ String category = categoryEntry.getKey().toString();
+ logger.debug("Category: " + category);
+ Map<Identifier, Map<Identifier, Set<AttributeValue<?>>>> datatypeMap = categoryEntry.getValue();
+ for (Map.Entry<Identifier, Map<Identifier, Set<AttributeValue<?>>>> datatypeEntry : datatypeMap.entrySet()) {
+ String datatype = datatypeEntry.getKey().toString();
+ logger.debug("\tData Type: " + datatype);
+ Map<Identifier, Set<AttributeValue<?>>> attributeIDMap = datatypeEntry.getValue();
+ for (Map.Entry<Identifier, Set<AttributeValue<?>>> attributeIDEntry : attributeIDMap.entrySet()) {
+ String attributeID = attributeIDEntry.getKey().toString();
+ logger.debug("\t\tAttribute ID: " + attributeID);
+ Set<AttributeValue<?>> attributeValueSet = attributeIDEntry.getValue();
+ for (AttributeValue<?> value : attributeValueSet) {
+ logger.debug("\t\t\tAttribute Value: " + value);
+ }
+ Iterator<AttributeValue<?>> iterator = attributeValueSet.iterator();
+ logger.debug("\t\t\t# of Attribute values: " + attributeValueSet.size());
+ meta.add(new Object[] {category, datatype, attributeID, iterator.next(), iterator, attributeValueSet});
+ }
+ }
+ }
+
+ int count = 0;
+ for (File file : output.toFile().listFiles()) {
+ file.delete();
+ }
+
+ do {
+ RequestType request = new RequestType();
+ request.setCombinedDecision(false);
+ request.setReturnPolicyIdList(false);
+ List<AttributesType> attributesList = request.getAttributes();
+
+ Map<String, AttributesType> category2Attribute= new HashMap<>();
+ for (int i = 0; i < meta.size(); i++) {
+ Object[] record = meta.get(i);
+
+ AttributesType attributes = null;
+ if (category2Attribute.containsKey(record[0].toString()))
+ attributes = category2Attribute.get(record[0].toString());
+ else {
+ attributes = new AttributesType();
+ attributes.setCategory(record[0].toString());
+ category2Attribute.put(record[0].toString(), attributes);
+ attributesList.add(attributes);
+ }
+// attributes.setId(record[2].toString());
+ List<AttributeType> attrList = attributes.getAttribute();
+
+ AttributeType attribute = new AttributeType();
+ attribute.setAttributeId(record[2].toString());
+ List<AttributeValueType> valueList = attribute.getAttributeValue();
+
+ AttributeValue<?> attributeValue = (AttributeValue<?>) record[3];
+
+ AttributeValueType value = new AttributeValueType();
+ value.setDataType(attributeValue.getDataTypeId().toString());
+ List<Object> content = value.getContent();
+ content.addAll((Collection<? extends Object>) attributeValue.getValue());
+ valueList.add(value);
+
+ attrList.add(attribute);
+ }
+
+ try {
+ ObjectFactory of = new ObjectFactory();
+ JAXBElement<RequestType> requestElement = of.createRequest(request);
+ JAXBContext context = JAXBContext.newInstance(RequestType.class);
+ Marshaller m = context.createMarshaller();
+ m.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);
+ m.marshal(requestElement, output.resolve("request" + count + ".xml").toFile());
+
+// if (count == 0) {//Just send the first request to the engine
+ StringWriter sw = new StringWriter();
+ m.marshal(requestElement, sw);
+ logger.info(sw.toString());
+ EngineCaller engine = new LocalEngineCaller();
+ if (engine.startEngine("")) {
+ String response = engine.decide(sw.toString(), "xml");
+ FileWriter writer = new FileWriter(output.resolve("response" + count + ".xml").toFile());
+ writer.write(response);
+ writer.close();
+ logger.info("Response received: \n" + response);
+ }
+// }
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+
+ count++;
+ } while (hasNextRequest());
+
+ logger.info("# of requests generated: " + count);
+ }
+
+ private boolean hasNextRequest() {
+ int i = meta.size() - 1;
+ Object[] record = meta.get(i);
+
+ @SuppressWarnings("unchecked")
+ Iterator<AttributeValue<?>> iterator = (Iterator<AttributeValue<?>>) record[4];
+ if (iterator.hasNext()) {
+ record[3] = iterator.next();
+ } else {
+ return recycleAttributeValue(i);
+ }
+
+ return true;
+ }
+
+ @SuppressWarnings("unchecked")
+ private boolean recycleAttributeValue(int position) {
+ boolean rc = true;
+
+ if (position == 0)
+ return false;
+
+ Object[] record = meta.get(position);
+ Set<AttributeValue<?>> attributeValueSet = (Set<AttributeValue<?>>) record[5];
+ Iterator<AttributeValue<?>> newIt = attributeValueSet.iterator();
+ record[4] = newIt;
+ record[3] = newIt.next();
+ int i = position - 1;
+ Object[] previous = meta.get(i);
+ Iterator<AttributeValue<?>> preIt = (Iterator<AttributeValue<?>>) previous[4];
+ if (preIt.hasNext()) {
+ previous[3] = preIt.next();
+ } else {
+ rc = recycleAttributeValue(i);
+ }
+
+ return rc;
+ }
+
+ */
+
+}
+
Code Review / policy / engine.git / blobdiff