From 18e6036b97b6cb5efcf4a1614e92f0635a206aff Mon Sep 17 00:00:00 2001 From: seb Date: Fri, 17 Dec 2010 17:44:27 +0000 Subject: [PATCH] Add a new nomination strategy which consists in nominate first host or server reflexive candidate. If relayed candidates are first validated, wait some time to see if no host or server reflexive candidates get validated and be nominated instead of relayed ones. Note that this strategy is not the default and thus need to be explicitely set via Agent's setNominationStrategy method to be used. --- src/org/ice4j/ice/Agent.java | 4 +- src/org/ice4j/ice/CheckList.java | 72 +++++++ .../ice4j/ice/ConnectivityCheckClient.java | 1 + src/org/ice4j/ice/DefaultNominator.java | 184 +++++++++++++++++- src/org/ice4j/ice/NominationStrategy.java | 9 + src/org/ice4j/stack/MessageProcessor.java | 5 +- 6 files changed, 270 insertions(+), 5 deletions(-) diff --git a/src/org/ice4j/ice/Agent.java b/src/org/ice4j/ice/Agent.java index 976a845..228af80 100644 --- a/src/org/ice4j/ice/Agent.java +++ b/src/org/ice4j/ice/Agent.java @@ -20,8 +20,8 @@ import org.ice4j.ice.harvest.*; import org.ice4j.stack.*; /** - * An Agent could be described as the main class (i.e. the chef d'orchestre) - * of an ICE implementation. + * An Agent could be described as the main class (i.e. the chef + * d'orchestre) of an ICE implementation. *

* As defined in RFC 3264, an agent is the protocol implementation involved in * the offer/answer exchange. There are two agents involved in an offer/answer diff --git a/src/org/ice4j/ice/CheckList.java b/src/org/ice4j/ice/CheckList.java index 79244ad..1586f5b 100644 --- a/src/org/ice4j/ice/CheckList.java +++ b/src/org/ice4j/ice/CheckList.java @@ -60,12 +60,25 @@ public class CheckList private final List stateListeners = new LinkedList(); + /** + * Contains {@link PropertyChangeListener}s registered with this {@link + * Agent} and following its changes of state. + */ + private final List checkListeners + = new LinkedList(); + /** * The name of the {@link PropertyChangeEvent} that we use to deliver * changes on the state of this check list. */ public static final String PROPERTY_CHECK_LIST_STATE = "CheckListState"; + /** + * The name of the {@link PropertyChangeEvent} that we use to deliver + * changes on the end of checks of this check list. + */ + public static final String PROPERTY_CHECK_LIST_CHECKS = "CheckListChecks"; + /** * Creates a check list with the specified name. * @@ -492,6 +505,65 @@ public class CheckList } } + /** + * Add a CheckListener. It will be notified when ordinary checks + * ended. + * + * @param l CheckListener to add + */ + public void addChecksListener(PropertyChangeListener l) + { + synchronized(checkListeners) + { + if(!checkListeners.contains(l)) + { + checkListeners.add(l); + } + } + } + + /** + * Remove a CheckListener. + * + * @param l CheckListener to remove + */ + public void removeChecksListener(PropertyChangeListener l) + { + synchronized(checkListeners) + { + if(checkListeners.contains(l)) + { + checkListeners.remove(l); + } + } + } + + /** + * Creates a new {@link PropertyChangeEvent} and delivers it to all + * currently registered checks listeners. + * + * @param oldState old state + * @param newState new state + */ + protected void fireEndOfOrdinaryChecks() + { + List listenersCopy; + + synchronized(checkListeners) + { + listenersCopy + = new LinkedList(checkListeners); + } + + PropertyChangeEvent evt = new PropertyChangeEvent( + this, PROPERTY_CHECK_LIST_CHECKS, false, true); + + for(PropertyChangeListener l : listenersCopy) + { + l.propertyChange(evt); + } + } + /** * Returns a reference to the {@link IceMediaStream} that created and that * maintains this check list. diff --git a/src/org/ice4j/ice/ConnectivityCheckClient.java b/src/org/ice4j/ice/ConnectivityCheckClient.java index 8f8b31b..2b076bc 100644 --- a/src/org/ice4j/ice/ConnectivityCheckClient.java +++ b/src/org/ice4j/ice/ConnectivityCheckClient.java @@ -726,6 +726,7 @@ class ConnectivityCheckClient * processTimeout() or processFailure() method. */ logger.finest("will skip a check beat."); + checkList.fireEndOfOrdinaryChecks(); } } } diff --git a/src/org/ice4j/ice/DefaultNominator.java b/src/org/ice4j/ice/DefaultNominator.java index bceb752..7536dd2 100644 --- a/src/org/ice4j/ice/DefaultNominator.java +++ b/src/org/ice4j/ice/DefaultNominator.java @@ -35,6 +35,13 @@ public class DefaultNominator private NominationStrategy strategy = NominationStrategy.NOMINATE_FIRST_VALID; + /** + * Map that will remember association between validated relayed candidate + * and a timer. It is use with the NOMINATE_FIRST_HIGHEST_VALID strategy. + */ + private Map validatedCandidates = + new HashMap(); + /** * Creates a new instance of this nominator using parentAgent as * a reference to the Agent instance that we should use to @@ -83,7 +90,9 @@ public class DefaultNominator strategyNominateFirstValid(evt); else if (strategy == NominationStrategy.NOMINATE_HIGHEST_PRIO) strategyNominateHighestPrio(evt); - + else if (strategy == + NominationStrategy.NOMINATE_FIRST_HOST_OR_REFLEXIVE_VALID) + strategyNominateFirstHostOrReflexiveValid(evt); } /** @@ -154,4 +163,177 @@ public class DefaultNominator { this.strategy = strategy; } + + /** + * Implements a nomination strategy that consists in nominating directly + * host or server reflexive pair that has become valid for a + * check list. For relayed pair, a timer is armed to see if no other host or + * server reflexive pair gets validated prior to timeout, the relayed ones + * gets nominated. + * + * @param evt the {@link PropertyChangeEvent} containing the pair which + * has been validated. + */ + private void strategyNominateFirstHostOrReflexiveValid( + PropertyChangeEvent evt) + { + if(IceMediaStream.PROPERTY_PAIR_VALIDATED.equals(evt.getPropertyName())) + { + CandidatePair validPair = (CandidatePair)evt.getSource(); + + TimerTask task = validatedCandidates.get( + validPair.getParentComponent().toShortString()); + boolean isRelayed = + validPair.getLocalCandidate() instanceof HostCandidate; + + if(isRelayed && task == null) + { + /* armed a timer and see if a host or server reflexive pair + * gets nominated. Otherwise nominate the relayed candidate pair + */ + Timer timer = new Timer(); + task = new RelayedCandidateTask(validPair); + + logger.info("Wait timeout to nominate relayed candidate"); + timer.schedule(task, 0); + synchronized(validatedCandidates) + { + validatedCandidates.put( + validPair.getParentComponent().toShortString(), + task); + } + } + else if(!isRelayed) + { + // host or server reflexive candidate pair + if(task != null) + { + task.cancel(); + logger.info("Found a better candidate pair to nominate for " + + validPair.getParentComponent().toShortString()); + } + + logger.info("Nominate (first highest valid): " + + validPair.toShortString()); + parentAgent.nominate(validPair); + } + } + } + + /** + * TimerTask that will wait a certain amount of time to let other candidate + * pair to be validated and possibly be better than the relayed candidate. + * + * @author Sebastien Vincent + */ + private class RelayedCandidateTask + extends TimerTask + implements PropertyChangeListener + { + /** + * Wait time in milliseconds. + */ + private static final int WAIT_TIME = 1000; + + /** + * The relayed candidate pair. + */ + private final CandidatePair pair; + + /** + * If the task has been canceled. + */ + private boolean canceled = false; + + /** + * Constructor. + * + * @param pair relayed candidate pair + */ + public RelayedCandidateTask(CandidatePair pair) + { + this.pair = pair; + pair.getParentComponent().getParentStream().getCheckList(). + addChecksListener(this); + } + + /** + * Tracks end of checks of the {@link CheckList}. + * + * @param evt the event + */ + public void propertyChange(PropertyChangeEvent evt) + { + /* check list has running out of ordinary checks, see if all other + * candidates are FAILED, in which case we nominate immediately + * the relayed candidate + */ + CheckList checkList = (CheckList)evt.getSource(); + boolean allFailed = true; + + synchronized(checkList) + { + for(CandidatePair c : checkList) + { + if(c != pair && c.getState() != CandidatePairState.FAILED) + { + allFailed = false; + } + } + } + + if(allFailed) + { + // all other pairs are failed to do not waste time, cancel + // timer and nominate ourself (the relayed candidate). + this.cancel(); + + logger.info("Nominate (first highest valid): " + + pair.toShortString()); + parentAgent.nominate(pair); + } + } + + /** + * Cancel task. + */ + @Override + public boolean cancel() + { + canceled = true; + return super.cancel(); + } + + /** + * Task entry point. + */ + public void run() + { + try + { + Thread.sleep(WAIT_TIME); + } + catch(InterruptedException e) + { + canceled = true; + } + + pair.getParentComponent().getParentStream().getCheckList(). + removeChecksListener(this); + validatedCandidates.remove( + pair.getParentComponent().toShortString()); + + if(canceled) + { + return; + } + + logger.info("Nominate (first highest valid): " + + pair.toShortString()); + + // task has not been canceled after WAIT_TIME milliseconds so + // nominate the pair + parentAgent.nominate(pair); + } + } } diff --git a/src/org/ice4j/ice/NominationStrategy.java b/src/org/ice4j/ice/NominationStrategy.java index 61fd43e..28c01cb 100644 --- a/src/org/ice4j/ice/NominationStrategy.java +++ b/src/org/ice4j/ice/NominationStrategy.java @@ -38,6 +38,15 @@ public enum NominationStrategy */ NOMINATE_HIGHEST_PRIO("NominateHighestPriority"), + /** + * The strategy consists in nominating the first host or server reflexive + * that's confirmed as valid pair. When a relayed candidate pair is + * validated first, a timer is armed and only if no host or server + * reflexive pair gets validated prior to timeout, the relayed ones + * gets nominated. + */ + NOMINATE_FIRST_HOST_OR_REFLEXIVE_VALID("NominateFirstHostOrReflexiveValid"), + /** * The strategy consists in nominating the pair that showed the best * shortest round trip time once all checks in a list completed. diff --git a/src/org/ice4j/stack/MessageProcessor.java b/src/org/ice4j/stack/MessageProcessor.java index 2ca9dd8..859ec35 100644 --- a/src/org/ice4j/stack/MessageProcessor.java +++ b/src/org/ice4j/stack/MessageProcessor.java @@ -75,7 +75,7 @@ class MessageProcessor throw new NullPointerException("netAccessManager"); MessageQueue messageQueue = netAccessManager.getMessageQueue(); - + if (messageQueue == null) { throw new IllegalArgumentException( @@ -155,7 +155,8 @@ class MessageProcessor try { StunMessageEvent stunMessageEvent - = new StunMessageEvent(stunStack, rawMessage, stunMessage); + = new StunMessageEvent(stunStack, rawMessage, + stunMessage); messageEventHandler.handleMessageEvent(stunMessageEvent); }