Ignore:
Timestamp:
01/28/20 10:19:54 (5 years ago)
Author:
bart
Message:

Update 28 jan 2020

Location:
protocol/src/main/java/geniusweb/protocol
Files:
8 added
8 edited

Legend:

Unmodified
Added
Removed

  • protocol/src/main/java/geniusweb/protocol/session/DefaultSessionState.java

    r9 r10  
    6464                        Map<PartyId, PartyWithProfile> partyprofiles, ProtocolException e) {
    6565                if (partyprofiles == null) {
    66                         partyprofiles = Collections.EMPTY_MAP;
     66                        partyprofiles = Collections.emptyMap();
    6767                }
    6868                if (conns == null) {
    6969                        this.connections = new ProtocolToPartyConnections(
    70                                         Collections.EMPTY_LIST);
     70                                        Collections.emptyList());
    7171                } else {
    7272                        this.connections = conns;
    … …  
    9797
    9898        /**
    99          * @return
    10099         * @return map with {@link PartyWithProfile} for the parties. May be an
    101100         *         incomplete map, as more parties with their profiles may be set

  • protocol/src/main/java/geniusweb/protocol/session/SessionSettings.java

    r1 r10  
    77import geniusweb.protocol.NegoSettings;
    88import geniusweb.protocol.session.saop.SAOPSettings;
     9import geniusweb.protocol.session.shaop.SHAOPSettings;
    910import geniusweb.references.PartyWithProfile;
    1011import tudelft.utilities.logging.Reporter;
    … …  
    1314 * interface for settings for session protocols. Immutable.
    1415 */
    15 @JsonSubTypes({ @JsonSubTypes.Type(value = SAOPSettings.class) })
    16 
     16@JsonSubTypes({ @JsonSubTypes.Type(value = SAOPSettings.class),
     17                @JsonSubTypes.Type(value = SHAOPSettings.class) })
    1718public interface SessionSettings extends NegoSettings {
    1819
    … …  
    2223         * @return list of {@link PartyWithProfile} items.
    2324         */
    24         public List<PartyWithProfile> getParticipants();
     25        List<TeamOfPartiesAndProfiles> getTeams();
    2526
    2627        /**
    27          * Allows modification of SessionSettings to include a party. This is needed for
    28          * tournament auto-configuration of sessions.
     28         * Allows modification of SessionSettings to include a party. This is needed
     29         * for tournament auto-configuration of sessions.
    2930         *
    30          * @param partyprof the party with profile to be added
     31         * @param partyprofteam the {@link TeamOfPartiesAndProfiles} to be added
    3132         * @return new modified SessionSettings object
    3233         */
    33         public SessionSettings with(PartyWithProfile partyprof);
     34        SessionSettings with(TeamOfPartiesAndProfiles partyprofteam);
     35
     36        /**
     37         *
     38         * @return all parties from all teams, as a flattened ordered list. The
     39         *         order : start with all parties from team 1, then all from team 2,
     40         *         etc. The specific order of the parties from a team depends on the
     41         *         protocol.
     42         */
     43        List<PartyWithProfile> getAllParties();
    3444
    3545        /**
    3646         * @param logger the logger where the protocol can log events to.
    37          * @return the an initialized and ready to use {@link SessionProtocol} that can
    38          *         handle this Negotiation.
     47         * @return the an initialized and ready to use {@link SessionProtocol} that
     48         *         can handle this Negotiation.
    3949         */
    4050        @Override
    41         public SessionProtocol getProtocol(Reporter logger);
     51        SessionProtocol getProtocol(Reporter logger);
    4252
    4353}

  • protocol/src/main/java/geniusweb/protocol/session/saop/SAOP.java

    r9 r10  
    6565public class SAOP extends DefaultListenable<ProtocolEvent>
    6666                implements SessionProtocol {
    67         private static final int TIME_MARGIN = 20;// ms extra delay after deadline
    68         private static final int MINDURATION = 100;
    69         private static final int MIN_SLEEP_TIME = 1000;
    70         private static final int MAX_SLEEP_TIME = 60000;
     67        public static final int TIME_MARGIN = 20;// ms extra delay after deadline
     68        public static final int MINDURATION = 100;
     69        public static final int MIN_SLEEP_TIME = 1000;
     70        public static final int MAX_SLEEP_TIME = 60000;
    7171        private static final ProtocolRef SAOP = new ProtocolRef("SAOP");
    7272        private final Reporter log;
    … …  
    154154                        throws InterruptedException, IOException {
    155155                List<PartyWithProfile> participants = state.getSettings()
    156                                 .getParticipants();
     156                                .getAllParties();
    157157                List<Reference> parties = participants.stream()
    158158                                .map(parti -> (parti.getParty().getPartyRef()))
    … …  
    319319                        setState(state.with(new ProtocolException(message, party, e)));
    320320                }
     321                log.log(Level.WARNING, "SAOP protocol intercepted error due to party "
     322                                + party + ":" + message, e);
    321323        }
    322324

  • protocol/src/main/java/geniusweb/protocol/session/saop/SAOPSettings.java

    r1 r10  
    44import java.util.LinkedList;
    55import java.util.List;
     6import java.util.stream.Collectors;
    67
    78import com.fasterxml.jackson.annotation.JsonCreator;
    … …  
    1112import geniusweb.protocol.session.SessionProtocol;
    1213import geniusweb.protocol.session.SessionSettings;
     14import geniusweb.protocol.session.TeamOfPartiesAndProfiles;
    1315import geniusweb.references.PartyWithProfile;
    1416import tudelft.utilities.logging.Reporter;
    1517
    1618public class SAOPSettings implements SessionSettings {
    17         private final List<PartyWithProfile> participants;
     19        private final List<SaopPartyWithProfile> participants;
    1820        private final Deadline deadline;
    1921
    … …  
    2830        @JsonCreator
    2931        public SAOPSettings(
    30                         @JsonProperty("participants") List<PartyWithProfile> participants,
     32                        @JsonProperty("participants") List<SaopPartyWithProfile> participants,
    3133                        @JsonProperty("deadline") Deadline deadline) {
    3234                this.participants = participants;
    … …  
    5153
    5254        @Override
    53         public List<PartyWithProfile> getParticipants() {
     55        public List<TeamOfPartiesAndProfiles> getTeams() {
    5456                return Collections.unmodifiableList(participants);
    5557        }
    … …  
    6062        public Deadline getDeadline() {
    6163                return deadline;
     64        }
     65
     66        @Override
     67        public List<PartyWithProfile> getAllParties() {
     68                return participants.stream()
     69                                .map(particip -> particip.getAllParties().get(0))
     70                                .collect(Collectors.toList());
    6271        }
    6372
    … …  
    101110
    102111        @Override
    103         public SessionSettings with(PartyWithProfile party) {
    104                 List<PartyWithProfile> newparts = new LinkedList<>(participants);
    105                 newparts.add(party);
     112        public SessionSettings with(TeamOfPartiesAndProfiles party) {
     113                if (!(party instanceof SaopPartyWithProfile))
     114                        throw new IllegalArgumentException(
     115                                        "Added party must be SaopPartyWithProfile but got "
     116                                                        + party);
     117                List<SaopPartyWithProfile> newparts = new LinkedList<>(participants);
     118                newparts.add((SaopPartyWithProfile) party);
    106119                return new SAOPSettings(newparts, deadline);
    107120        }

  • protocol/src/main/java/geniusweb/protocol/session/saop/SAOPState.java

    r9 r10  
    1616import geniusweb.progress.ProgressRounds;
    1717import geniusweb.protocol.ProtocolException;
     18import geniusweb.protocol.partyconnection.ProtocolToPartyConn;
    1819import geniusweb.protocol.partyconnection.ProtocolToPartyConnections;
    19 import geniusweb.protocol.partyconnection.ProtocolToPartyConn;
    2020import geniusweb.protocol.session.DefaultSessionState;
    2121import geniusweb.protocol.session.SessionSettings;
    … …  
    6161
    6262        /**
    63          * @param actor         the actor that did this action. Can be used to check
    64          *                      if action is valid. NOTICE caller has to make sure
    65          *                      the current state is not final.
    66          * @param action        the action that was proposed by actor.
    67          * @param currentTimeMs the current time in ms since 1970, see
    68          *                      {@link System#currentTimeMillis()}
    69          * @return new SessionState with the action added as last action.
    70          */
    71         public SAOPState with(PartyId actor, Action action) {
    72                 try {
    73                         return with1(actor, action);
    74                 } catch (ProtocolException e) {
    75                         List<Action> newactions = new LinkedList<>(getActions());
    76                         newactions.add(action);
    77                         return new SAOPState(newactions, getConnections(), getProgress(),
    78                                         getSettings(), getPartyProfiles(), e);
    79                 }
    80         }
    81 
    82         /**
    8363         *
    8464         * @param connection   the new {@link ProtocolToPartyConn}
    … …  
    164144
    165145        /**
     146         * @param actor         the actor that did this action. Can be used to check
     147         *                      if action is valid. NOTICE caller has to make sure
     148         *                      the current state is not final.
     149         * @param action        the action that was proposed by actor.
     150         * @param currentTimeMs the current time in ms since 1970, see
     151         *                      {@link System#currentTimeMillis()}
     152         * @return new SessionState with the action added as last action.
     153         */
     154
     155        public SAOPState with(PartyId actor, Action action) {
     156
     157                if (actor == null) { // this is a bug
     158                        throw new IllegalArgumentException("actor must not be null");
     159                }
     160                if (!actor.equals(getNextActor())) {
     161                        throw new IllegalArgumentException("Party does not have the turn ");
     162
     163                }
     164                if (action == null) {
     165                        throw new IllegalArgumentException("action is null");
     166                }
     167                if (!actor.equals(action.getActor())) {
     168                        throw new IllegalArgumentException(
     169                                        "act contains wrong credentials: " + action);
     170                }
     171
     172                // check protocol is followed for specific actions
     173                if (action instanceof Accept) {
     174                        Bid bid = getLastBid();
     175                        if (bid == null) {
     176                                throw new IllegalArgumentException(
     177                                                "Accept without a recent offer");
     178                        }
     179                        if (!bid.equals(((Accept) action).getBid())) {
     180                                throw new IllegalArgumentException(
     181                                                "Party accepts a bid differing from the last offer ="
     182                                                                + bid + ", action=" + action + ")");
     183                        }
     184                } else if (action instanceof Offer) {
     185                        // offer is always fine. We don't check if bid is actually in domain
     186                        // or complete etc. We would need domain for that
     187                } else if (action instanceof EndNegotiation) {
     188                        // just act, we will get into the final state then.
     189                } else {
     190                        throw new IllegalArgumentException(
     191                                        "Action " + action + " is not allowed in SAOP");
     192                }
     193
     194                List<Action> newactions = new LinkedList<>(getActions());
     195                newactions.add(action);
     196                return new SAOPState(newactions, getConnections(), advanceProgress(),
     197                                getSettings(), getPartyProfiles(), null);
     198        }
     199
     200        /**
    166201         * Check up to nparticipants-1 steps back if there was an offer.
    167202         *
    … …  
    182217        }
    183218
    184         private SAOPState with1(PartyId actor, Action action)
    185                         throws ProtocolException {
    186 
    187                 if (actor == null) { // this is a bug
    188                         throw new IllegalArgumentException("actor must not be null");
    189                 }
    190                 if (!actor.equals(getNextActor())) {
    191                         throw new ProtocolException("Party does not have the turn ",
    192                                         actor.getName());
    193 
    194                 }
    195                 if (action == null) {
    196                         throw new ProtocolException("action is null", actor.getName());
    197                 }
    198                 if (!actor.equals(action.getActor())) {
    199                         throw new ProtocolException(
    200                                         "act contains wrong credentials: " + action,
    201                                         actor.getName());
    202                 }
    203 
    204                 // check protocol is followed for specific actions
    205                 if (action instanceof Accept) {
    206                         Bid bid = getLastBid();
    207                         if (bid == null) {
    208                                 throw new ProtocolException("Accept without a recent offer",
    209                                                 actor.getName());
    210                         }
    211                         if (!bid.equals(((Accept) action).getBid())) {
    212                                 throw new ProtocolException(
    213                                                 "Party accepts a bid differing from the last offer ="
    214                                                                 + bid + ", action=" + action + ")",
    215                                                 actor.getName());
    216                         }
    217                 } else if (action instanceof Offer) {
    218                         // offer is always fine. We don't check if bid is actually in domain
    219                         // or complete etc. We would need domain for that
    220                 } else if (action instanceof EndNegotiation) {
    221                         // just act, we will get into the final state then.
    222                 } else {
    223                         throw new ProtocolException(
    224                                         "Action " + action + " is not allowed in SAOP",
    225                                         actor.getName());
    226                 }
    227 
    228                 List<Action> newactions = new LinkedList<>(getActions());
    229                 newactions.add(action);
    230                 return new SAOPState(newactions, getConnections(), advanceProgress(),
    231                                 getSettings(), getPartyProfiles(), null);
    232         }
    233 
    234219        /**
    235220         *

  • protocol/src/main/java/geniusweb/protocol/tournament/allpermutations/AllPermutationsProtocol.java

    r9 r10  
    8181                        long now = System.currentTimeMillis();
    8282                        if (sessionstate.isFinal(now)) {
     83                                // List<TeamOfPartiesAndProfiles> participants =
     84                                // sessionstate.getSettings().getParticipants()
    8385                                SessionResult result = new SessionResult(
    84                                                 sessionstate.getSettings().getParticipants(),
     86                                                sessionstate.getSettings().getAllParties(),
    8587                                                sessionstate.getAgreement(), sessionstate.getError());
    8688                                state = state.with(result);

  • protocol/src/main/java/geniusweb/protocol/tournament/allpermutations/AllPermutationsSettings.java

    r8 r10  
    11package geniusweb.protocol.tournament.allpermutations;
    22
     3import java.net.URI;
     4import java.net.URISyntaxException;
    35import java.util.Collections;
    46import java.util.List;
    … …  
    79import com.fasterxml.jackson.annotation.JsonProperty;
    810
     11import geniusweb.profile.Profile;
    912import geniusweb.protocol.session.SessionSettings;
     13import geniusweb.protocol.session.TeamOfPartiesAndProfiles;
     14import geniusweb.protocol.session.saop.SAOPSettings;
     15import geniusweb.protocol.session.saop.SaopPartyWithProfile;
     16import geniusweb.protocol.session.shaop.SHAOPSettings;
     17import geniusweb.protocol.session.shaop.ShaopTeam;
    1018import geniusweb.protocol.tournament.TournamentProtocol;
    1119import geniusweb.protocol.tournament.TournamentSettings;
     20import geniusweb.references.Parameters;
    1221import geniusweb.references.PartyRef;
    1322import geniusweb.references.PartyWithParameters;
    … …  
    3039 * Takes a number of parties and profiles and makes all permutations of them
    3140 * with the given number of parties and profiles. All profiles must be in the
    32  * same domain. All sessions are based on the given sessionsettings (can be any
    33  * session protocol). The parties for each tournament session are added to this
    34  * basic sessionsettings.
    35  *
     41 * same domain.
     42 * <p>
     43 * All sessions are based on the given {@link SessionSettings} (can be
     44 * {@link SAOPSettings} or {@link SHAOPSettings}). The parties for each
     45 * tournament session are added to this basic sessionsettings. sessionsettings
     46 * contains basically all the normal run-sessionsettings. This is used as a
     47 * "template" for all sessions of the tournament. You can put any use any
     48 * session setting here, and each session will be run according to the protocol
     49 * you select here.
     50 *
     51 * The participants list usually is empty. The AllPermutationsProtocol adds the
     52 * the required parties to this list. So if you provide a non-empty list here,
     53 * then these parties would be present in every session in the tournament.
     54 * <p>
     55 * If the tournament is used with a SHAOP sessionsettings, a number of rules are
     56 * used to generate the COB party from the settings.
     57 *
     58 * The COB party is assumed to be the comparebids-1.0.0 party on the same server
     59 * as the party you provide. So if you provide http://server/../party1-1.2.3
     60 * then the cob party will be assumed to be at
     61 * http://server/../comparebids-1.0.0. The provided parties that you provide are
     62 * the SHAOP parties (you can also use SAOP parties). The provided profile is
     63 * also given to the SHAOP party. Be aware that you typically need a parameter
     64 * like partial=10. The COB party gets the profile as specified, but without the
     65 * query part. The COB and SHAOP party are thus a fixed pair.
    3666 */
    3767public class AllPermutationsSettings implements TournamentSettings {
     68
    3869        private final List<PartyWithParameters> parties;
    3970        private final List<ProfileRef> profiles;
    … …  
    4980         *                          we use PermutationsWithoutReturn to create the
    5081         *                          parties.
    51          * @param profiles
     82         * @param profiles          list of available {@link Profile}s to be
     83         *                          permutated over the parties
    5284         * @param partiesPerSession number of parties per session, must be at least
    5385         *                          2.
    … …  
    97129         */
    98130        public ImmutableList<SessionSettings> permutations() {
    99                 ImmutableList<ImmutableList<PartyWithProfile>> partylistlist;
     131                ImmutableList<ImmutableList<TeamOfPartiesAndProfiles>> partylistlist;
    100132                ImmutableList<PartyWithParameters> partieslist = new FixedList<PartyWithParameters>(
    101133                                parties);
    … …  
    166198         */
    167199        private SessionSettings createSetting(
    168                         ImmutableList<PartyWithProfile> partyproflist) {
     200                        ImmutableList<TeamOfPartiesAndProfiles> partyproflist) {
    169201                SessionSettings settings = sessionsettings;
    170                 for (PartyWithProfile partyprof : partyproflist) {
     202                for (TeamOfPartiesAndProfiles partyprof : partyproflist) {
    171203                        settings = settings.with(partyprof);
    172204                }
    … …  
    181213         * @param drawPartyWithPutback if parties can be drawn multiple times
    182214         * @return list of sessionsets where each sessionset contains settings for a
    183          *         session: a list with {@link PartyWithProfile}s. The sessionsets
    184          *         are made by making all combinations of parties and profiles.
    185          *         Profiles are drawn with replace.
    186          */
    187         private ImmutableList<ImmutableList<PartyWithProfile>> getParticipants(
     215         *         session: a list with {@link TeamOfPartiesAndProfiles}s. The
     216         *         sessionsets are made by making all combinations of parties and
     217         *         profiles. Profiles are drawn with replace.
     218         */
     219        private ImmutableList<ImmutableList<TeamOfPartiesAndProfiles>> getParticipants(
    188220                        ImmutableList<PartyWithParameters> parties,
    189221                        ImmutableList<ProfileRef> profiles, int n,
    … …  
    205237                                partiesPermutations, profilesPermutations);
    206238
    207                 return new MapList<Tuple<ImmutableList<PartyWithParameters>, ImmutableList<ProfileRef>>, ImmutableList<PartyWithProfile>>(
    208                                 tuple -> partyprofilelist(tuple), tuples);
     239                return new MapList<Tuple<ImmutableList<PartyWithParameters>, ImmutableList<ProfileRef>>, ImmutableList<TeamOfPartiesAndProfiles>>(
     240                                tuple -> teamlist(tuple), tuples);
    209241        }
    210242
    … …  
    213245         * @param tuple a tuple with (1) ImmutableList<PartyRef> (2)
    214246         *              ImmutableList<ProfileRef>
    215          * @return list of PartyWithProfile, each picked from the two lists in
    216          *         order.
    217          */
    218         private ImmutableList<PartyWithProfile> partyprofilelist(
     247         * @return list of TeamOfPartiesAndProfiles, each picked from the two lists
     248         *         in order.
     249         */
     250        private ImmutableList<TeamOfPartiesAndProfiles> teamlist(
    219251                        Tuple<ImmutableList<PartyWithParameters>, ImmutableList<ProfileRef>> tuple) {
    220                 Function2<PartyWithParameters, ProfileRef, PartyWithProfile> //
    221                 makeparty = new Function2<PartyWithParameters, ProfileRef, PartyWithProfile>() {
     252                Function2<PartyWithParameters, ProfileRef, TeamOfPartiesAndProfiles> //
     253                makeparty = new Function2<PartyWithParameters, ProfileRef, TeamOfPartiesAndProfiles>() {
    222254                        @Override
    223                         public PartyWithProfile apply(PartyWithParameters party,
     255                        public TeamOfPartiesAndProfiles apply(PartyWithParameters party,
    224256                                        ProfileRef profile) {
    225                                 return new PartyWithProfile(party, profile);
     257                                if (sessionsettings instanceof SAOPSettings)
     258                                        return new SaopPartyWithProfile(party, profile);
     259                                else if (sessionsettings instanceof SHAOPSettings) {
     260                                        return new ShaopTeam(new PartyWithProfile(party, profile),
     261                                                        makeCob(party.getPartyRef(), profile));
     262                                } else
     263                                        throw new IllegalArgumentException(
     264                                                        "Unknown/unsupported protocol "
     265                                                                        + sessionsettings.getClass());
    226266                        }
     267
    227268                };
    228                 return new MapThreadList<PartyWithProfile, PartyWithParameters, ProfileRef>(
     269                return new MapThreadList<TeamOfPartiesAndProfiles, PartyWithParameters, ProfileRef>(
    229270                                makeparty, tuple.get1(), tuple.get2());
    230271        }
    231272
     273        /**
     274         * Extract the raw URL, without the part after the question mark
     275         *
     276         * @param party   a party reference (for another party)
     277         * @param profile a profile that may have a filter like "?partial=XX"
     278         * @return profile without the filter and with a cob party on the same
     279         *         machine. IT IS ASSUMED that there will the default
     280         *         "comparebids-1.0.0" party on the same machine as where the other
     281         *         party is
     282         */
     283        protected static PartyWithProfile makeCob(PartyRef party,
     284                        ProfileRef profile) {
     285                try {
     286                        URI profileuri = profile.getURI();
     287                        URI partyuri = party.getURI();
     288                        ProfileRef cobprof = new ProfileRef(profileuri.getScheme() + "://"
     289                                        + profileuri.getAuthority() + profileuri.getPath());
     290                        String partypath = partyuri.getPath();
     291                        partypath = partypath.substring(0, partypath.lastIndexOf('/'));
     292                        PartyWithParameters cobparty = new PartyWithParameters(new PartyRef(
     293                                        partyuri.getScheme() + "://" + partyuri.getAuthority()
     294                                                        + partypath + "/comparebids-1.0.0"),
     295                                        new Parameters());
     296                        return new PartyWithProfile(cobparty, cobprof);
     297
     298                } catch (URISyntaxException e) {
     299                        throw new IllegalArgumentException(
     300                                        "Failed making cob party with profile " + profile, e);
     301                }
     302        }
     303
    232304}

  • protocol/src/main/java/geniusweb/protocol/tournament/allpermutations/AllPermutationsState.java

    r1 r10  
    5555         */
    5656        public AllPermutationsState with(SessionResult result) {
    57                 if (!getNextSettings().getParticipants()
     57                if (!getNextSettings().getAllParties()
    5858                                .equals(result.getParticipants())) {
    5959                        throw new IllegalArgumentException("Inconsistent session result");
Note: See TracChangeset for help on using the changeset viewer.