diff options
Diffstat (limited to 'sandbox/dougsleite/guardian-model/src/main/java/org/apache/tuscany/sca/guardian/GuardianGroupImpl.java')
| -rw-r--r-- | sandbox/dougsleite/guardian-model/src/main/java/org/apache/tuscany/sca/guardian/GuardianGroupImpl.java | 355 |
1 files changed, 295 insertions, 60 deletions
diff --git a/sandbox/dougsleite/guardian-model/src/main/java/org/apache/tuscany/sca/guardian/GuardianGroupImpl.java b/sandbox/dougsleite/guardian-model/src/main/java/org/apache/tuscany/sca/guardian/GuardianGroupImpl.java index ee78dadddf..a54ffe71b7 100644 --- a/sandbox/dougsleite/guardian-model/src/main/java/org/apache/tuscany/sca/guardian/GuardianGroupImpl.java +++ b/sandbox/dougsleite/guardian-model/src/main/java/org/apache/tuscany/sca/guardian/GuardianGroupImpl.java @@ -18,28 +18,49 @@ */ package org.apache.tuscany.sca.guardian; +import java.io.FileInputStream; +import java.io.FileNotFoundException; import java.util.ArrayList; import java.util.LinkedList; import java.util.List; import java.util.logging.Level; import java.util.logging.Logger; +import javax.xml.stream.XMLInputFactory; +import javax.xml.stream.XMLStreamException; +import javax.xml.stream.XMLStreamReader; +import org.apache.axis2.jaxws.message.util.ResettableReader; +import org.osoa.sca.annotations.Property; import org.osoa.sca.annotations.Scope; -import org.apache.tuscany.sca.guardian.exceptions.*; import org.osoa.sca.annotations.Service; @Service(GuardianGroup.class) @Scope("COMPOSITE") public class GuardianGroupImpl implements GuardianGroup { - List<GuardianMember> guardianMembers; + private List<GuardianMember> guardianList; + private ResettableReader reader; public GuardianGroupImpl() { - guardianMembers = new LinkedList<GuardianMember>(); + guardianList = new LinkedList<GuardianMember>(); + } + + @Property(name = "recovery_rules", required = true) + public void setRecoveryRules(String recoveryRules) { + try { + //FileInputStream fileInputStream = new FileInputStream("src/main/resources/recoveryrules.xml"); + FileInputStream fileInputStream = new FileInputStream("src/main/resources/recoveryrules.xml"); + XMLStreamReader xmlReader = XMLInputFactory.newInstance().createXMLStreamReader(fileInputStream); + reader = new ResettableReader(xmlReader); + } catch (XMLStreamException ex) { + Logger.getLogger(GuardianGroupImpl.class.getName()).log(Level.SEVERE, null, ex); + } catch (FileNotFoundException ex) { + Logger.getLogger(GuardianGroupImpl.class.getName()).log(Level.SEVERE, null, ex); + } } public void addGuardianMember(GuardianMember guardianMember) { - guardianMembers.add(guardianMember); - guardianMember.setUniqueParticipantID(guardianMembers.size() - 1); + guardianList.add(guardianMember); + guardianMember.setUniqueParticipantID(guardianList.size() - 1); } public void enableContext(Context context) { @@ -58,14 +79,14 @@ public class GuardianGroupImpl implements GuardianGroup { //Sends a message representing the exception to the other guardian members if (participantList == null) { - for (GuardianMember g : guardianMembers) { + for (GuardianMember g : guardianList) { if (!g.getParticipantIdentifier().equals(ex.getSignalingParticipant())) { //g.gthrow(ex, participantList); g.gthrow(null, null); } } } else { - for (GuardianMember g : guardianMembers) { + for (GuardianMember g : guardianList) { if (participantList.contains(g.getCurrentContext())) { //g.gthrow(ex, participantList); g.gthrow(null, null); @@ -74,9 +95,9 @@ public class GuardianGroupImpl implements GuardianGroup { } //Check if the participants are blocked - List<Integer> flags = new ArrayList<Integer>(guardianMembers.size()); - for (int i = 0; i < guardianMembers.size(); i++) { - if (guardianMembers.get(i).getService().isBlocked()) { + List<Integer> flags = new ArrayList<Integer>(guardianList.size()); + for (int i = 0; i < guardianList.size(); i++) { + if (guardianList.get(i).getService().isBlocked()) { flags.add(i, 1); } else { flags.add(i, 0); @@ -93,7 +114,7 @@ public class GuardianGroupImpl implements GuardianGroup { } //3)Once ALL required participants are SUSPENDED (suspended point), invoke the defined Recovery Rules - for (GuardianMember g : guardianMembers) { + for (GuardianMember g : guardianList) { g.addException(new SuspendException()); } // 3.1) recovery_rules < signaled exceptions + context information of all participant > target context + exception to raise @@ -104,66 +125,280 @@ public class GuardianGroupImpl implements GuardianGroup { // g.addException(ex); // } - //HARDCODED - SERVER-BACKUP EXAMPLE - //Rule 1 - if (ex instanceof JoinException) { - if (guardianMembers.size() > 1) { + applyRecoveryRules(ex); - PrimaryExistsException primaryExists = new PrimaryExistsException(); - primaryExists.setTargetContext(new Context("MAIN")); +// //HARDCODED - SERVER-BACKUP EXAMPLE +// //Rule 1 +// if (ex instanceof JoinException) { +// if (guardianMembers.size() > 1) { +// +// PrimaryExistsException primaryExists = new PrimaryExistsException(); +// primaryExists.setTargetContext(new Context("MAIN")); +// +// BackupJoinedException backupJoined = new BackupJoinedException(); +// backupJoined.setTargetContext(new Context("PRIMARY")); +// +// for (GuardianMember g : guardianMembers) { +// //let p = JoinException.signaler +// if (g.getParticipantIdentifier().equals(ex.getSignalingParticipant())) { +// g.addException(primaryExists); +// System.out.println("adding PrimaryExistsException to " + g.getParticipantIdentifier()); +// } else { +// g.addException(backupJoined); +// System.out.println("adding BackupJoinedException to " + g.getParticipantIdentifier()); +// } +// } +// } +// } //Rule 2 +// else if (ex instanceof PrimaryFailedException) { +// +// PrimaryFailedException primaryFailedInit = new PrimaryFailedException(); +// primaryFailedInit.setTargetContext(Context.INIT_CONTEXT); +// +// PrimaryFailedException primaryFailedMain = new PrimaryFailedException(); +// primaryFailedMain.setTargetContext(new Context("MAIN")); +// +// for (GuardianMember g : guardianMembers) { +// if (g.getCurrentContext().getName().equals("PRIMARY")) { +// System.out.println("adding PrimaryFailedException to " + g.getParticipantIdentifier()); +// g.addException(primaryFailedInit); +// } else if (g.getCurrentContext().getName().equals("BACKUP")) { +// System.out.println("adding PrimaryFailedException to " + g.getParticipantIdentifier()); +// g.addException(primaryFailedMain); +// } +// } +// } //Rule 3 +// else if (ex instanceof BackupFailedException) { +// +// BackupFailedException backupFailedPrimary = new BackupFailedException(); +// backupFailedPrimary.setTargetContext(new Context("PRIMARY")); +// +// BackupFailedException backupFailedInit = new BackupFailedException(); +// backupFailedInit.setTargetContext(Context.INIT_CONTEXT); +// +// for (GuardianMember g : guardianMembers) { +// if (g.getCurrentContext().getName().equals("PRIMARY")) { +// System.out.println("adding BackupFailedException to " + g.getParticipantIdentifier()); +// g.addException(backupFailedPrimary); +// } else if (g.getCurrentContext().getName().equals("BACKUP")) { +// System.out.println("adding BackupFailedException to " + g.getParticipantIdentifier()); +// g.addException(backupFailedInit); +// } +// } +// +// } - BackupJoinedException backupJoined = new BackupJoinedException(); - backupJoined.setTargetContext(new Context("PRIMARY")); + } - for (GuardianMember g : guardianMembers) { - //let p = JoinException.signaler - if (g.getParticipantIdentifier().equals(ex.getSignalingParticipant())) { - g.addException(primaryExists); - System.out.println("adding PrimaryExistsException to " + g.getParticipantIdentifier()); - } else { - g.addException(backupJoined); - System.out.println("adding BackupJoinedException to " + g.getParticipantIdentifier()); + private void applyRecoveryRules(GlobalException ex) { + + String exceptionClassName; + String targetContextName; + Integer min_participant_joined; + Integer max_participant_joined; + + List<GuardianMember> gmList; + + try { + + reader.reset(); + + while (reader.hasNext()) { + reader.next(); + //<rule name="" signaled_exception=""> + if (reader.isStartElement() && reader.getLocalName().equals("rule")) { + for (int i = 0; i < reader.getAttributeCount(); i++) { + //ex == signaled_exception + if (reader.getAttributeLocalName(i).equals("signaled_exception") && + ex.getClass().getName().equals(reader.getAttributeValue(i))) { + + while (reader.hasNext() && !(reader.isEndElement() && reader.getLocalName().equals("rule"))) { + reader.next(); + + //<participant match="<REG_EXP> | SIGNALER"> + if (reader.isStartElement() && reader.getLocalName().equals("participant")) { + + String participant_match = reader.getAttributeValue(0).trim(); + + while (reader.hasNext() && !(reader.isEndElement() && reader.getLocalName().equals("participant"))) { + reader.next(); + + //<throw_exception class="<Exception>" target_context="<Context>"/> + if (reader.isStartElement() && reader.getLocalName().equals("throw_exception")) { + + exceptionClassName = null; + targetContextName = null; + min_participant_joined = null; + max_participant_joined = null; + + for (int j = 0; j < reader.getAttributeCount(); j++) { + if (reader.getAttributeLocalName(j).equals("class")) { + //class value + exceptionClassName = reader.getAttributeValue(j); + } else if (reader.getAttributeLocalName(j).equals("target_context")) { + //target_context value + targetContextName = reader.getAttributeValue(j); + } else if (reader.getAttributeLocalName(j).equals("min_participant_joined")) { + //min_participant_joined value + min_participant_joined = Integer.parseInt(reader.getAttributeValue(j)); + } else { + //max_participant_joined value + max_participant_joined = Integer.parseInt(reader.getAttributeValue(j)); + } + } + + //Test the min and max joined participants condition + if (min_participant_joined != null && max_participant_joined != null) { + if (!(guardianList.size() >= min_participant_joined && guardianList.size() < max_participant_joined)) { + break; + } + } else if (min_participant_joined != null) { + if (!(guardianList.size() >= min_participant_joined)) { + break; + } + } else if (max_participant_joined != null) { + if (!(guardianList.size() >= min_participant_joined)) { + break; + } + } + + //match value + gmList = getMatchingParticipants(participant_match, ex); + + Class exceptionClass = Class.forName(exceptionClassName); + + Context targetContext; + if (targetContextName.toUpperCase().equals(Context.CURRENT_CONTEXT.getName().toUpperCase())) { + targetContext = Context.CURRENT_CONTEXT; + } else if (targetContextName.toUpperCase().equals(Context.INIT_CONTEXT.getName().toUpperCase())) { + targetContext = Context.INIT_CONTEXT; + } else { + targetContext = new Context(targetContextName); + } + + GlobalException newException = (GlobalException) exceptionClass.newInstance(); + newException.setTargetContext(targetContext); + + //Add the exception to the participants matched + for (GuardianMember gm : gmList) { + gm.addException(newException); + } + } + } + } + } + break; + } } } } - } //Rule 2 - else if (ex instanceof PrimaryFailedException) { - - PrimaryFailedException primaryFailedInit = new PrimaryFailedException(); - primaryFailedInit.setTargetContext(Context.INIT_CONTEXT); - - PrimaryFailedException primaryFailedMain = new PrimaryFailedException(); - primaryFailedMain.setTargetContext(new Context("MAIN")); - - for (GuardianMember g : guardianMembers) { - if (g.getCurrentContext().getName().equals("PRIMARY")) { - System.out.println("adding PrimaryFailedException to " + g.getParticipantIdentifier()); - g.addException(primaryFailedInit); - } else if (g.getCurrentContext().getName().equals("BACKUP")) { - System.out.println("adding PrimaryFailedException to " + g.getParticipantIdentifier()); - g.addException(primaryFailedMain); + } catch (XMLStreamException ex1) { + Logger.getLogger(GuardianGroupImpl.class.getName()).log(Level.SEVERE, null, ex1); + } catch (Exception ex1) { + Logger.getLogger(GuardianGroupImpl.class.getName()).log(Level.SEVERE, null, ex1); + } + } + + private List<GuardianMember> getMatchingParticipants(String regularExpression, GlobalException signaledException) { + List<GuardianMember> matchingParticipants = new LinkedList(); + + if (regularExpression.toUpperCase().equals("SIGNALER")) { + for (GuardianMember gm : guardianList) { + if (gm.getParticipantIdentifier().equals(signaledException.getSignalingParticipant())) { + matchingParticipants.add(gm); + break; + } + } + } else if (regularExpression.toUpperCase().equals("!SIGNALER")) { + for (GuardianMember gm : guardianList) { + if (!gm.getParticipantIdentifier().equals(signaledException.getSignalingParticipant())) { + matchingParticipants.add(gm); } } - } //Rule 3 - else if (ex instanceof BackupFailedException) { - - BackupFailedException backupFailedPrimary = new BackupFailedException(); - backupFailedPrimary.setTargetContext(new Context("PRIMARY")); - - BackupFailedException backupFailedInit = new BackupFailedException(); - backupFailedInit.setTargetContext(Context.INIT_CONTEXT); - - for (GuardianMember g : guardianMembers) { - if (g.getCurrentContext().getName().equals("PRIMARY")) { - System.out.println("adding BackupFailedException to " + g.getParticipantIdentifier()); - g.addException(backupFailedPrimary); - } else if (g.getCurrentContext().getName().equals("BACKUP")) { - System.out.println("adding BackupFailedException to " + g.getParticipantIdentifier()); - g.addException(backupFailedInit); + + } else { + //Create an java regular expression + String re = createJavaRegularExpression(regularExpression); + + for (GuardianMember gm : guardianList) { + if (gm.getParticipantIdentifier().matches(re)) { + matchingParticipants.add(gm); } } + } + + return matchingParticipants; + } + + /* Valid expressions: *, <Context>.*, <Context>, *.<Context>, *.<Context>.*, + * *.<Context>.*.<Context>.*, <REG_EXP> || <REG_EXP> + * + * Invalid expressions: *.*, **, + * + * Not supported yet: !<Context>, !<Context> || <Context>, !(<Context> || <Context>) + */ + private String createJavaRegularExpression(String regularExpression) throws InvalidRegularExpression { + StringBuffer re = new StringBuffer(); + + String[] splitedByBar = regularExpression.split("\\|\\|"); + String[] splitedByPeriod; + + for (int i = 0; i < splitedByBar.length; i++) { + + splitedByPeriod = splitedByBar[i].split("\\."); + + if (i > 0) { + re.append("|"); + } + re.append("^"); + for (int j = 0; j < splitedByPeriod.length; j++) { + + //* + if (splitedByPeriod[j].equals("*")) { + + //Validate the regular expression + if (j + 1 != splitedByPeriod.length && splitedByPeriod[j + 1].equals("*")) { + throw new InvalidRegularExpression(); + } + + //* + if (splitedByPeriod.length == 1) { + re.append("(\\w+)"); + } //*.<CONTEXT> + + if (j == 0 && splitedByPeriod.length != 1) { + re.append("(\\w+\\"); + re.append(".)*"); + } //<CONTEXT>.* + else { + re.append("(\\"); + re.append(".\\w+)*"); + } + } //<CONTEXT> + else { + +// //Validate the regular expression +// if (splitedByPeriod[j].matches("^(\\*)*$")) { +// throw new RuntimeException("Invalid name for a context"); +// } + + //<CONTEXT> || <CONTEXT>.<CONTEXT>.<CONTEXT> || *.<CONTEXT> + if (splitedByPeriod.length == 1) { + re.append("(\\w+\\"); + re.append(".)*"); + } + + if (j == 0 || j - 1 == 0) { + re.append("(" + splitedByPeriod[j] + ")"); + } else { + re.append("(\\." + splitedByPeriod[j] + ")"); + } + } + } + re.append("$"); } + return re.toString(); } public boolean propagate(GlobalException ex) { @@ -175,6 +410,6 @@ public class GuardianGroupImpl implements GuardianGroup { } public boolean removeGuardianMember(GuardianMember guardianMember) { - return this.guardianMembers.remove(guardianMember); + return this.guardianList.remove(guardianMember); } } |