source: src/main/java/geniusweb/partiesserver/repository/RunningParty.java@ 11

package geniusweb.partiesserver.repository;

import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.Date;
import java.util.UUID;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.JsonAutoDetect.Visibility;

import geniusweb.actions.PartyId;
import geniusweb.connection.DefaultConnection;
import geniusweb.partiesserver.RunningPartiesUpdater;
import geniusweb.partiesserver.websocket.PartySocket;
import geniusweb.party.Party;
import geniusweb.party.inform.Inform;
import tudelft.utilities.repository.RepoElement;

/**
 * Class that contains a running party. Adds a start/end times and generates
 * party ID. Also stores original filename of the party.
 * 
 * This object can not be deserialized here because running parties have to be
 * created.
 */
@JsonAutoDetect(fieldVisibility = Visibility.ANY, getterVisibility = Visibility.NONE, setterVisibility = Visibility.NONE)
public class RunningParty implements RepoElement<PartyId> {
        private static int nr = 1; // counter for generating unique new parties.
        private static String uniqueid = getUniqueMachineID(); // world-wide unique
                                                                                                                        // ID for this
                                                                                                                        // number. For ID
                                                                                                                        // generation.

        private final PartyId id;
        private final Date startDate;
        private final Date endDate; // agent will be declared dead and removed after
                                                                // this
        private final String name;
        /*
         * set when someone contacts our socket. null if not set.
         */
        private final transient PartySocket connection;

        /**
         * The actually running party
         */
        private transient final Party party;

        /**
         * Only available for testing.
         * 
         * @param party the new party
         * @param id    the new id for the party.
         * @param start the start date for this party. Usually set to current time.
         * @param end   the end date for this party
         * @param conn  the connection to use, or null if no connection is available
         *              yet.
         */
        protected RunningParty(Party party, PartyId id, String name, Date start,
                        Date end, PartySocket conn) {
                if (party == null || id == null || name == null || start == null
                                || end == null) {
                        throw new NullPointerException("arguments must not be null");
                }
                this.party = party;
                this.id = id;
                this.name = name;
                this.startDate = start;
                this.endDate = end;
                this.connection = conn;
        }

        /**
         * Create instance from availableparty
         * 
         * @param availableparty the {@link AvailableParty}
         * @param name           the (file)name
         * @param maxlifetimems  the maximum life time for this party (ms). The
         *                       party will be killed and removed after this point.
         *                       This value should be set to the maximum negotiation
         *                       time plus the worst time to actual start up of the
         *                       negotiation
         * @throws IllegalAccessException
         * @throws InstantiationException
         */
        public static RunningParty create(AvailableParty availableparty,
                        long maxlifetimems)
                        throws InstantiationException, IllegalAccessException {
                if (availableparty == null) {
                        throw new IllegalArgumentException(
                                        "availableparty must not be null");
                }
                return create(availableparty.getPartyClass().newInstance(),
                                availableparty.getName(), maxlifetimems);
        }

        /**
         * Create a running party.
         * 
         * @param party        the {@link Party} that is loaded and ready to run.
         * @param name         The name, this should match the filename in the repo
         *                     (without the .jar).
         * @param maxRunTimeMS the maximum runtime for this party (ms). The
         *                     {@link RunningPartiesUpdater} will keep an eye on the
         *                     time and handle removal after time is up.
         * 
         */
        public static RunningParty create(Party party, String name,
                        long maxRunTimeMS) {
                if (maxRunTimeMS <= 0) {
                        throw new IllegalArgumentException("runtime must be >0");
                }
                Date now = new Date();
                return new RunningParty(party,
                                new PartyId("party" + (nr++) + "_" + uniqueid), name, now,
                                new Date(now.getTime() + maxRunTimeMS), null);
        }

        /**
         * @return unique ID for this running party
         */
        @Override
        public PartyId getID() {
                return id;
        }

        /**
         * @return the implementation of this party
         */
        public Party getParty() {
                return party;
        }

        /**
         * The name, this should match the filename in the repo (without the .jar).
         * 
         * @return
         */
        public String getName() {
                return name;
        }

        /**
         * @return the start {@link Date} of this runningparty.
         */
        public Date getStartDate() {
                return startDate;
        }

        /**
         * 
         * @return the end date/ deadline for this party
         */
        public Date getEndDate() {
                return endDate;
        }

        @Override
        public int hashCode() {
                final int prime = 31;
                int result = 1;
                result = prime * result + ((id == null) ? 0 : id.hashCode());
                result = prime * result + ((name == null) ? 0 : name.hashCode());
                result = prime * result + ((party == null) ? 0 : party.hashCode());
                result = prime * result
                                + ((startDate == null) ? 0 : startDate.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;
                RunningParty other = (RunningParty) obj;
                if (id == null) {
                        if (other.id != null)
                                return false;
                } else if (!id.equals(other.id))
                        return false;
                if (name == null) {
                        if (other.name != null)
                                return false;
                } else if (!name.equals(other.name))
                        return false;
                if (party == null) {
                        if (other.party != null)
                                return false;
                } else if (!party.equals(other.party))
                        return false;
                if (startDate == null) {
                        if (other.startDate != null)
                                return false;
                } else if (!startDate.equals(other.startDate))
                        return false;
                return true;
        }

        @Override
        public String toString() {
                return "RunningParty[" + id + "," + startDate + party.getClass() + ","
                                + name + "]";
        }

        /**
         * You must have called {@link #connect(DefaultConnection)} before calling
         * this.
         * 
         * @param info
         */
        public void inform(Inform info) {
                connection.notifyListeners(info);
        }

        /**
         * Attach RunningParty to a connection. We allow at most 1 connection.
         * 
         * @param newconn the new connection that has been made with this party.
         * @return new RunningParty. This must be inserted into the
         *         {@link RunningPartiesRepo} by the caller.
         * @throws IllegalStateException if the party is already connected.
         */
        public RunningParty withConnection(PartySocket newconn) {
                if (newconn == null)
                        throw new NullPointerException("newconn must be not null");
                if (this.connection != null) {
                        throw new IllegalStateException(
                                        "RunningParty is already connected");
                }
                party.connect(newconn);
                return new RunningParty(party, id, name, startDate, endDate, newconn);
        }

        /**
         * 
         * @param terminationTime the new termination time
         * @return new RunningParty with changed end time (all other things
         *         unchanged)
         */
        public RunningParty withEndTime(Date terminationTime) {
                return new RunningParty(party, id, name, startDate, terminationTime,
                                connection);
        }

        /**
         * Get a id that is world-wide unique. We use the IP number here instead of
         * UUID because UUID usually is just a random number which is (1) long (22
         * bytes) (2) not guaranteed unique.
         */
        private static String getUniqueMachineID() {
                if (uniqueid == null) {
                        try {
                                uniqueid = InetAddress.getLocalHost().getHostAddress();
                        } catch (UnknownHostException e1) {
                                uniqueid = UUID.randomUUID().toString(); // fallback, should
                                                                                                                        // never be needed
                        }
                        uniqueid = uniqueid.replaceAll("\\.", "_");
                }
                return uniqueid;
        }

}