Changeset 24 for protocol/src/main/java/geniusweb/protocol/session/mopac/MOPACState.java

Timestamp:

10/06/20 13:12:20 (4 years ago)

Author:

bart

Message:

Fixes an issue with processing maxPower of a vote. Javadoc maven plugin now uses latest version.

File:

• protocol/src/main/java/geniusweb/protocol/session/mopac/MOPACState.java (modified) (11 diffs)

protocol/src/main/java/geniusweb/protocol/session/mopac/MOPACState.java

@@ -17 +17 @@
 import geniusweb.progress.Progress;
 import geniusweb.progress.ProgressRounds;
+import geniusweb.protocol.NegoProtocol;
 import geniusweb.protocol.ProtocolException;
-import geniusweb.protocol.partyconnection.ProtocolToPartyConn;
-import geniusweb.protocol.partyconnection.ProtocolToPartyConnections;
 import geniusweb.protocol.session.SessionResult;
 import geniusweb.protocol.session.SessionState;
@@ -27 +26 @@
 import geniusweb.protocol.session.saop.SAOPSettings;
 import geniusweb.references.PartyWithProfile;
-import geniusweb.voting.VotingEvaluator;
-
+
+/**
+ * Keeps track of the current {@link Phase}. Adds initializing stuff and
+ * time/deadline checking. This state does not contain connections, this assumes
+ * that someone else handles (i.e. {@link NegoProtocol} that and the connections
+ * with the parties and that negotiation events are just pumped in from there.
+ * <p>
+ * This object is a bit tricky. It has two states
+ * <ol>
+ * <li>The initial state, where phase=null and connections are being made to all
+ * parties. At this point, problems can not be handled nicely yet because there
+ * are no PartyId's for problematic parties
+ * <li>The working state, where all parties are connected and all problems can
+ * be connected to an offending party.
+ * </ol>
+ */
 public class MOPACState implements SessionState {
 
-        private final Phase phase;
+        private final Phase phase; // maybe null while initializing
         private final MOPACSettings settings;
         private final Map<PartyId, PartyWithProfile> partyprofiles;
-        private final ProtocolToPartyConnections connections;
         private final List<Action> actions;
         private final Progress progress;
@@ -44 +56 @@
          */
         public MOPACState(MOPACSettings settings) {
-                this(null, Arrays.asList(),
-                                new ProtocolToPartyConnections(Collections.emptyList()), null,
-                                settings, Collections.emptyMap());
+                this(null, Arrays.asList(), null, settings, Collections.emptyMap());
 
         }
@@ -54 +64 @@
          *                      set something only after we have connections.
          * @param actions       the legal actions that have been done in the
-         *                      negotiation. A new-sub-list is added for each phase
-         *                      change. It is assumed that the last element of the
-         *                      list is the list with actions taken in the current
-         *                      phase. first action in first list is the oldest.
-         *                      This MUST NOT contain illegal actions. Parties doing
-         *                      illegal actions are killed and the offending action
-         *                      ends up in the stacktrace. Previous actions of
-         *                      crashed parties remain standing and valid.
-         * @param conns         the existing party connections. we assume ownership
-         *                      of this so it should not be modified although
-         *                      connections may of course break.
+         *                      negotiation. {@link PartyStates#getActions()} is
+         *                      called to collect the actions after the phase is
+         *                      finished.first action in list is the oldest. This
+         *                      will not contain actions that immediately led to an
+         *                      agreement, because {@link PartyStates} removes the
+         *                      actions that led to an agreement. This MUST NOT
+         *                      contain illegal actions. Parties doing illegal
+         *                      actions are killed and the offending action ends up
+         *                      in the stacktrace. Previous actions of crashed
+         *                      parties remain standing and valid.
          * @param progress      the {@link Progress} line. can be null if not yet
-         *                      known. This happens because during setup we first
-         *                      add all connections, and only when we have that we
-         *                      set the correct deadline.
+         *                      known. null happens because during initialization
+         *                      phase the protocol first add all connections. During
+         *                      this time, parties may already enter the
+         *                      failed/exception state.
          * @param settings      the {@link SAOPSettings}
          * @param partyprofiles map with the {@link PartyWithProfile} for connected
          *                      parties. null is equivalent to an empty map.
-         * @param evaluator     the {@link VotingEvaluator}
          */
         @JsonCreator
         protected MOPACState(@JsonProperty("phase") Phase phase,
                         @JsonProperty("actions") List<Action> actions,
-                        @JsonProperty("connections") ProtocolToPartyConnections conns,
                         @JsonProperty("progress") Progress progress,
                         @JsonProperty("settings") MOPACSettings settings,
@@ -83 +91 @@
                 this.phase = phase;
                 this.actions = actions;
-                this.connections = conns;
                 this.progress = progress;
                 this.settings = settings;
@@ -90 +97 @@
 
         /**
-         * Can be called after all connections are initialized.
-         * 
-         * @param now current time ms since 1970
-         * 
-         * @return state with the initial partystates set.
-         */
-        public MOPACState initPhase(long now) {
-                PartyStates partyStates = new PartyStates(getPowers());
-                Phase firstPhase = new OfferPhase(null, partyStates,
-                                now + getAvailablePhaseTime(now),
-                                settings.getVotingEvaluation());
-                return new MOPACState(firstPhase, actions, connections, progress,
-                                settings, partyprofiles);
-        }
-
-        @Override
-        public List<Action> getActions() {
-                return Collections.unmodifiableList(actions);
-        }
-
-        @Override
-        public Progress getProgress() {
-                return progress;
-        }
-
-        public Map<PartyId, PartyWithProfile> getPartyProfiles() {
-                return Collections.unmodifiableMap(partyprofiles);
-        }
-
-        /**
-         * @return all current/remaining active party connections. Finished/crashed
-         *         parties should be removed immediately.
-         */
-        public ProtocolToPartyConnections getConnections() {
-                return connections;
-        }
-
-        /**
-         * @param now current time ms since 1970
-         * @return the max possible duration in ms of the NEXT phase. Maybe 0 or
-         *         negative if past deadline.
-         */
-        private Long getAvailablePhaseTime(long now) {
-                // explicit check, to check also the round counts.
-                if (incrementProgress().isPastDeadline(now + Phase.PHASE_MINTIME))
-                        return 0l;
-                return Math.min(progress.getTerminationTime().getTime() - now,
-                                Phase.PHASE_MAXTIME);
-        }
-
-        /**
-         * 
-         * @param connection   the new {@link ProtocolToPartyConn}
-         * @param partyprofile the {@link PartyWithProfile} that is associated with
-         *                     this state
-         * @return new {@link MOPACState} with the new connection added. This call
-         *         ignores the progress (does not check isFinal) because we uses
-         *         this during the setup where the deadline is not yet relevant.
-         */
-        protected MOPACState with(ProtocolToPartyConn connection,
-                        PartyWithProfile partyprofile) {
-                if (phase != null)
-                        throw new IllegalStateException(
-                                        "Adding connections only allowed while initializing");
-
-                ProtocolToPartyConnections newconns = getConnections().with(connection);
-                Map<PartyId, PartyWithProfile> newprofiles = new HashMap<>(
-                                partyprofiles);
-                newprofiles.put(connection.getParty(), partyprofile);
-                return new MOPACState(null, actions, newconns, progress, settings,
-                                newprofiles);
-        }
-
-        /**
-         * @param id the {@link PartyId} of the party that failed.
-         * @param e  the {@link ProtocolException} that occurred in the party
-         * @return a new state with the error set.
-         */
-        public MOPACState with(ProtocolException e) {
-                return new MOPACState(phase.with(e), actions, connections, progress,
-                                settings, partyprofiles);
-        }
-
-        /**
-         * Sets the progress for this session. Can be set only if progress=null.
-         * Should be set in INIT phase.
-         * 
-         * @param newprogress the new progress
-         * @return new {@link MOPACState} with the progress set
-         */
-        public MOPACState with(Progress newprogress) {
+         * Sets the progress for this session and initial phase. Must be called
+         * after all parties have been connected with
+         * {@link #with(PartyId, PartyWithProfile)}.
+         * 
+         * @param newprogress the initial {@link Progress} typically matching the
+         *                    settings deadline object
+         * @param now         current time ms since 1970
+         * 
+         * @return state with the initial partystates , progress set.
+         */
+        public MOPACState initPhase(Progress newprogress, long now) {
                 if (progress != null || newprogress == null || phase != null) {
                         throw new IllegalArgumentException(
                                         "progress must be null, newprogress must be not null and phase must be INIT");
                 }
-                return new MOPACState(phase, actions, connections, newprogress,
-                                getSettings(), partyprofiles);
+
+                PartyStates partyStates = new PartyStates(getPowers());
+                Phase firstPhase = new OfferPhase(partyStates,
+                                now + getAvailablePhaseTime(newprogress, now),
+                                settings.getVotingEvaluation());
+                return new MOPACState(firstPhase, actions, newprogress, settings,
+                                partyprofiles);
+        }
+
+        @Override
+        public List<Action> getActions() {
+                return Collections.unmodifiableList(actions);
+        }
+
+        @Override
+        public Progress getProgress() {
+                return progress;
+        }
+
+        @Override
+        public Agreements getAgreements() {
+                return phase.getPartyStates().getAgreements();
+        }
+
+        @Override
+        public MOPACSettings getSettings() {
+                return settings;
+        }
+
+        public Map<PartyId, PartyWithProfile> getPartyProfiles() {
+                return Collections.unmodifiableMap(partyprofiles);
+        }
+
+        @Override
+        public boolean isFinal(long now) {
+                return phase != null && phase.isFinal(now) && !isNewPhasePossible(now);
+        }
+
+        @Override
+        public SessionResult getResult() {
+                return new SessionResult(partyprofiles, getAgreements(),
+                                Collections.emptyMap(), null);
+        }
+
+        /**
+         * @param progress the Progress that needs to be checked
+         * @param now      current time ms since 1970
+         * @return the max possible duration in ms of a phase considering the
+         *         progress.
+         */
+        private static Long getAvailablePhaseTime(Progress aprogress, long now) {
+                return Math.min(aprogress.getTerminationTime().getTime() - now,
+                                Phase.PHASE_MAXTIME);
+        }
+
+        /**
+         * @param id           the new {@link PartyId}
+         * @param partyprofile the {@link PartyWithProfile} that is associated with
+         *                     this state
+         * @return new {@link MOPACState} with the new party added. This call
+         *         ignores the progress (does not check isFinal) because we uses
+         *         this during the setup where the deadline is not yet relevant.
+         */
+        protected MOPACState with(PartyId id, PartyWithProfile partyprofile) {
+                if (phase != null)
+                        throw new IllegalStateException(
+                                        "Adding connections only allowed while initializing");
+
+                Map<PartyId, PartyWithProfile> newprofiles = new HashMap<>(
+                                partyprofiles);
+                newprofiles.put(id, partyprofile);
+                return new MOPACState(null, actions, progress, settings, newprofiles);
+        }
+
+        /**
+         * @param e the {@link ProtocolException} that occured
+         * @return a new state with the error set. You MUST have called
+         *         {@link #initPhase(Progress, long)} before using this
+         */
+        public MOPACState with(ProtocolException e) {
+                return new MOPACState(phase.with(e), actions, progress, settings,
+                                partyprofiles);
         }
 
@@ -202 +209 @@
                                 Math.min(remainingNegoTime, Phase.PHASE_MAXTIME));
 
-                return new MOPACState(newphase, actions, connections,
-                                incrementProgress(), getSettings(), partyprofiles);
-        }
-
-        /**
-         * 
-         * @return the next progress. Progress round advances if phase is
-         *         {@link OptIn}.
-         */
-        private Progress incrementProgress() {
-                if (progress instanceof ProgressRounds && phase instanceof OptInPhase)
-                        return ((ProgressRounds) progress).advance();
-                return progress;
-        }
-
-        @Override
-        public boolean isFinal(long now) {
-                return phase != null && phase.isFinal(now) && !isNewPhasePossible(now);
+                return new MOPACState(newphase, actions, increment(progress, phase),
+                                getSettings(), partyprofiles);
         }
 
@@ -225 +216 @@
          * When this is called, all parties should have acted.
          * 
-         * @param now
-         * @return
+         * @param now current time
+         * @return true if there are still &gt;2 parties active and we have enough
+         *         time for a new phase.
          */
         public boolean isNewPhasePossible(long now) {
                 // System.out.println("phase=" + phase);
-                boolean a = phase.getPartyStates().getNegotiatingParties().size() >= 2
-                                && getAvailablePhaseTime(now) > Phase.PHASE_MINTIME;
-                // System.out.println("newstate possible:" + a);
-                return a;
-        }
-
-        @Override
-        public Agreements getAgreements() {
-                return phase.getPartyStates().getAgreements();
-        }
-
-        @Override
-        public MOPACSettings getSettings() {
-                return settings;
+                Progress newprogress = increment(progress, phase);
+                if (newprogress.isPastDeadline(now + Phase.PHASE_MINTIME))
+                        return false;
+
+                return phase.getPartyStates().getNegotiatingParties().size() >= 2
+                                && getAvailablePhaseTime(newprogress,
+                                                now) > Phase.PHASE_MINTIME;
         }
 
@@ -261 +246 @@
          * @param now    the current time in ms since 1970, see
          *               {@link System#currentTimeMillis()}
+         * @return new {@link MOPACState} with the action checked and registered. If
+         *         the action is not allowed, the new state may be that the actor is
+         *         in the exception list.
          */
 
         public MOPACState with(PartyId actor, Action action, long now) {
-                return new MOPACState(phase.with(actor, action, now), actions,
-                                connections, progress, settings, partyprofiles);
-        }
-
-        @Override
-        public SessionResult getResult() {
-                return new SessionResult(partyprofiles, getAgreements(),
-                                Collections.emptyMap(), null);
+                return new MOPACState(phase.with(actor, action, now), actions, progress,
+                                settings, partyprofiles);
+        }
+
+        /**
+         * @param aprogress the progress that might need to be advanced
+         * @param aphase    the phase
+         * @return the next progress. Progress round advances if phase is
+         *         {@link OptIn}.
+         */
+        private static Progress increment(Progress aprogress, Phase aphase) {
+                if (aprogress instanceof ProgressRounds && aphase instanceof OptInPhase)
+                        return ((ProgressRounds) aprogress).advance();
+                return aprogress;
         }
 
@@ -294 +288 @@
         public String toString() {
                 return "MOPACState[" + phase + "," + settings + "," + partyprofiles
-                                + "," + connections + "," + progress + "," + "]";
+                                + "," + progress + "]";
         }
 
@@ -306 +300 @@
                 LinkedList<Action> newactions = new LinkedList<Action>(actions);
                 newactions.addAll(newphase.getPartyStates().getActions());
-                return new MOPACState(newphase, newactions, connections, progress,
-                                settings, partyprofiles);
+                return new MOPACState(newphase, newactions, progress, settings,
+                                partyprofiles);
+        }
+
+        @Override
+        public int hashCode() {
+                final int prime = 31;
+                int result = 1;
+                result = prime * result + ((actions == null) ? 0 : actions.hashCode());
+                result = prime * result
+                                + ((partyprofiles == null) ? 0 : partyprofiles.hashCode());
+                result = prime * result + ((phase == null) ? 0 : phase.hashCode());
+                result = prime * result
+                                + ((progress == null) ? 0 : progress.hashCode());
+                result = prime * result
+                                + ((settings == null) ? 0 : settings.hashCode());
+                return result;
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+                if (this == obj)
+                        return true;
+                if (obj == null)
+                        return false;
+                if (getClass() != obj.getClass())
+                        return false;
+                MOPACState other = (MOPACState) obj;
+                if (actions == null) {
+                        if (other.actions != null)
+                                return false;
+                } else if (!actions.equals(other.actions))
+                        return false;
+                if (partyprofiles == null) {
+                        if (other.partyprofiles != null)
+                                return false;
+                } else if (!partyprofiles.equals(other.partyprofiles))
+                        return false;
+                if (phase == null) {
+                        if (other.phase != null)
+                                return false;
+                } else if (!phase.equals(other.phase))
+                        return false;
+                if (progress == null) {
+                        if (other.progress != null)
+                                return false;
+                } else if (!progress.equals(other.progress))
+                        return false;
+                if (settings == null) {
+                        if (other.settings != null)
+                                return false;
+                } else if (!settings.equals(other.settings))
+                        return false;
+                return true;
         }