@Test
public void testFactory() throws Exception {
// TransactionPolicy
Policy p = PolicyFactory.getPolicy("managedTransaction.Global");
Assert.assertEquals(TransactionPolicy.MANAGED_TRANSACTION_GLOBAL, p);
Assert.assertTrue(p.supports(PolicyType.IMPLEMENTATION));
p = PolicyFactory.getPolicy("managedTransaction.Local");
Assert.assertEquals(TransactionPolicy.MANAGED_TRANSACTION_LOCAL, p);
Assert.assertTrue(p.supports(PolicyType.IMPLEMENTATION));
p = PolicyFactory.getPolicy("noManagedTransaction");
Assert.assertEquals(TransactionPolicy.NO_MANAGED_TRANSACTION, p);
Assert.assertTrue(p.supports(PolicyType.IMPLEMENTATION));
p = PolicyFactory.getPolicy("propagatesTransaction");
Assert.assertEquals(TransactionPolicy.PROPAGATES_TRANSACTION, p);
Assert.assertTrue(p.supports(PolicyType.INTERACTION));
p = PolicyFactory.getPolicy("suspendsTransaction");
Assert.assertEquals(TransactionPolicy.SUSPENDS_TRANSACTION, p);
Assert.assertTrue(p.supports(PolicyType.INTERACTION));
// SecurityPolicy
p = PolicyFactory.getPolicy("authorization");
Assert.assertEquals(SecurityPolicy.AUTHORIZATION, p);
Assert.assertTrue(p.supports(PolicyType.INTERACTION));
p = PolicyFactory.getPolicy("clientAuthentication");
Assert.assertEquals(SecurityPolicy.CLIENT_AUTHENTICATION, p);
Assert.assertTrue(p.supports(PolicyType.INTERACTION));
p = PolicyFactory.getPolicy("confidentiality");
Assert.assertEquals(SecurityPolicy.CONFIDENTIALITY, p);
Assert.assertTrue(p.supports(PolicyType.INTERACTION));
// Generic Policy
p = PolicyFactory.getPolicy("myGenericPolicy");
Assert.assertEquals("myGenericPolicy", p.getName());
Assert.assertTrue(p.supports(PolicyType.IMPLEMENTATION));
Assert.assertTrue(p.supports(PolicyType.INTERACTION));
}
@Override
public String toString() {
return "Scenario [id="
+ id
+ ", image.name="
+ image.getName()
+ ", policyA.name="
+ policyA.getName()
+ ", argumentA.name="
+ argumentA.getName()
+ "]";
}
public static void logPerformances(Policy policy, boolean logBadTrajectories) {
float[] performance = performance(policy, logBadTrajectories);
PrintWriter performanceLog = null;
try {
performanceLog = new PrintWriter(new FileWriter("performance.log", true));
} catch (IOException e) {
e.printStackTrace();
}
String line;
if (policy.getClass() == DirectPolicySearch.class) {
DirectPolicySearch dps = (DirectPolicySearch) policy;
float totalComputationTime = (float) dps.getTotalComputationTime() / 1000f / 60f;
line =
dps.getName()
+ ";"
+ dps.getTotalNbOfIterations()
+ ";"
+ totalComputationTime
+ ";"
+ performance[0]
+ ";"
+ performance[1];
} else if (policy.getClass() == Qiteration.class) {
Qiteration qit = (Qiteration) policy;
float totalComputationTime = (float) qit.getTotalComputationTime() / 1000f / 60f;
line =
qit.getName()
+ ";"
+ qit.getDiscountFactor()
+ ";"
+ qit.getTotalNbOfIterations()
+ ";"
+ totalComputationTime
+ ";"
+ performance[0]
+ ";"
+ performance[1];
} else {
line = policy.getName() + ";" + performance[0] + ";" + performance[1];
}
performanceLog.println(line);
performanceLog.close();
}
private void addPolicies(
DeploymentContext context,
Service service,
Map<String, String> filterParams,
List<FilterParamDescriptor> params,
ResourceDescriptor resource,
List<Policy> policyBindings)
throws URISyntaxException {
for (Policy policyBinding : policyBindings) {
String role = policyBinding.getRole();
if (role == null) {
throw new IllegalArgumentException(
"Policy defined has no role for service " + service.getName());
}
role = role.trim().toLowerCase();
if (role.equals("rewrite")) {
addRewriteFilter(context, service, filterParams, params, resource);
} else if (topologyContainsProviderType(context, role)) {
context.contributeFilter(service, resource, role, policyBinding.getName(), null);
}
}
}
public static float[] performance(Policy policy, boolean logBadTrajectories) {
float[] performance = new float[2];
PrintWriter badTrajectories = null;
if (logBadTrajectories) {
try {
badTrajectories =
new PrintWriter(new FileWriter(policy.getName() + "_bad_trajectories.log"));
badTrajectories.println("");
} catch (IOException e1) {
e1.printStackTrace();
}
}
LinkedList<State> ts = new LinkedList<State>();
LinkedList<Action> ta = new LinkedList<Action>();
LinkedList<Float> tr = new LinkedList<Float>();
float score;
int iterationsDone = 0;
int nbOfBadTrajectories = 0;
float totalScore = 0f;
float averageScore = 0f;
for (State s : initialStates) {
ts.clear();
ta.clear();
tr.clear();
score = MarkovDecisionProcess.trajectoryReward(s, policy, 500, ts, ta, tr);
if (score < 0f) {
nbOfBadTrajectories++;
if (logBadTrajectories) {
badTrajectories.println("Total score: " + score + ":");
for (int i = 1; !(ts.isEmpty() || ta.isEmpty()); i++) {
badTrajectories.println(
i + ": " + ts.removeFirst() + " | " + ta.removeFirst() + " | " + tr.removeFirst());
}
badTrajectories.println("");
badTrajectories.println("----------------------------------------------------");
badTrajectories.println("");
}
} else {
totalScore += score;
}
iterationsDone++;
if (iterationsDone == 10 && nbOfBadTrajectories == 10) {
totalScore = 0f;
averageScore = 0f;
nbOfBadTrajectories = initialStates.size();
break;
}
}
if (logBadTrajectories) {
badTrajectories.println("Total number of bad trajectories: " + nbOfBadTrajectories);
badTrajectories.close();
}
if (nbOfBadTrajectories != initialStates.size()) {
averageScore = totalScore / (initialStates.size() - nbOfBadTrajectories);
}
performance[0] = averageScore;
performance[1] = nbOfBadTrajectories;
return performance;
}
