MarkPassingReceiver's events.
*/
private static final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
private final DomainFactory tractracDomainFactory;
private final com.sap.sailing.domain.swisstimingadapter.DomainFactory swissTimingDomainFactory;
private final ExpeditionWindTrackerFactory windTrackerFactory;
/**
* Holds the {@link Event} objects for those event registered with this service. Note that there may be {@link Event}
* objects that exist outside this service for events not (yet) registered here.
*/
protected final ConcurrentHashMapupdatedLeaderboard and
* replaces the one in the group with the updated one.removedLeaderboardName and removes it from the group.
* @param removedLeaderboardName
*/
private void syncGroupsAfterLeaderboardRemove(String removedLeaderboardName, boolean doDatabaseUpdate) {
boolean groupNeedsUpdate = false;
synchronized (leaderboardGroupsByName) {
for (LeaderboardGroup leaderboardGroup : leaderboardGroupsByName.values()) {
for (Leaderboard leaderboard : leaderboardGroup.getLeaderboards()) {
if (leaderboard.getName().equals(removedLeaderboardName)) {
leaderboardGroup.removeLeaderboard(leaderboard);
groupNeedsUpdate = true;
// TODO we assume that the leaderboard names are unique, so we can break the inner loop here
break;
}
}
if (doDatabaseUpdate && groupNeedsUpdate) {
mongoObjectFactory.storeLeaderboardGroup(leaderboardGroup);
}
groupNeedsUpdate = false;
}
}
}
@Override
public Leaderboard getLeaderboardByName(String name) {
synchronized (leaderboardsByName) {
return leaderboardsByName.get(name);
}
}
@Override
public Mapregatta {@link Regatta#isPersistent() is a persistent one}, the association of the race with the
* regatta is remembered persistently so that {@link #getRememberedRegattaForRace(Serializable)} will provide it.
*/
@Override
public void raceAdded(Regatta regatta, RaceDefinition raceDefinition) {
if (regatta.isPersistent()) {
setRegattaForRace(regatta, raceDefinition);
}
final CourseChangeReplicator listener = new CourseChangeReplicator(this, regatta, raceDefinition);
courseListeners.put(raceDefinition, listener);
raceDefinition.getCourse().addCourseListener(listener);
replicate(new AddRaceDefinition(regatta.getRegattaIdentifier(), raceDefinition));
}
@Override
public void raceRemoved(Regatta regatta, RaceDefinition raceDefinition) {
raceDefinition.getCourse().removeCourseListener(courseListeners.remove(raceDefinition));
}
@Override
public RacesHandle addRace(RegattaIdentifier regattaToAddTo, RaceTrackingConnectivityParameters params,
WindStore windStore, long timeoutInMilliseconds) throws Exception {
RaceTracker tracker = raceTrackersByID.get(params.getTrackerID());
if (tracker == null) {
Regatta regatta = regattaToAddTo == null ? null : getRegatta(regattaToAddTo);
if (regatta == null) {
// create tracker and use an existing or create a default regatta
tracker = params.createRaceTracker(this);
} else {
// use the regatta selected by the RaceIdentifier regattaToAddTo
tracker = params.createRaceTracker(regatta, this);
assert tracker.getRegatta() == regatta;
}
synchronized (raceTrackersByRegatta) {
raceTrackersByID.put(params.getTrackerID(), tracker);
Setregatta is not yet in {@link #regattasByName}, it is added, this service is
* {@link Regatta#addRegattaListener(RegattaListener) added} as regatta listener, and the regatta and all its
* contained {@link Regatta#getAllRaces() races} are replicated to all replica.
*
* @param regatta
* the series of this regatta must not have any {@link Series#getRaceColumns() race columns associated
* (yet)}.
*/
private void cacheAndReplicateSpecificRegattaWithoutRaceColumns(Regatta regatta) {
if (!regattasByName.containsKey(regatta.getName())) {
logger.info("putting regatta "+regatta.getName()+" ("+regatta.hashCode()+") into regattasByName of "+this);
regattasByName.put(regatta.getName(), regatta);
regatta.addRegattaListener(this);
regatta.addRaceColumnListener(raceLogReplicator);
regatta.addRaceColumnListener(raceLogScoringReplicator);
Serializable courseAreaId = null;
if (regatta.getDefaultCourseArea() != null) {
courseAreaId = regatta.getDefaultCourseArea().getId();
}
replicate(new AddSpecificRegatta(
regatta.getBaseName(), regatta.getBoatClass() == null ? null : regatta
.getBoatClass().getName(), regatta.getId(), getSeriesWithoutRaceColumnsConstructionParametersAsMap(regatta),
regatta.isPersistent(), regatta.getScoringScheme(), courseAreaId));
RegattaIdentifier regattaIdentifier = regatta.getRegattaIdentifier();
for (RaceDefinition race : regatta.getAllRaces()) {
replicate(new AddRaceDefinition(regattaIdentifier, race));
}
}
}
private Mapregatta is not yet in {@link #regattasByName}, it is added, this service is
* {@link Regatta#addRegattaListener(RegattaListener) added} as regatta listener, and the regatta and all its contained
* {@link Regatta#getAllRaces() races} are replicated to all replica.
*/
private void cacheAndReplicateDefaultRegatta(Regatta regatta) {
if (!regattasByName.containsKey(regatta.getName())) {
logger.info("putting regatta "+regatta.getName()+" ("+regatta.hashCode()+") into regattasByName of "+this);
regattasByName.put(regatta.getName(), regatta);
regatta.addRegattaListener(this);
regatta.addRaceColumnListener(raceLogReplicator);
regatta.addRaceColumnListener(raceLogScoringReplicator);
replicate(new AddDefaultRegatta(regatta.getBaseName(), regatta.getBoatClass() == null ? null : regatta.getBoatClass().getName(),
regatta.getId()));
RegattaIdentifier regattaIdentifier = regatta.getRegattaIdentifier();
for (RaceDefinition race : regatta.getAllRaces()) {
replicate(new AddRaceDefinition(regattaIdentifier, race));
}
}
}
@Override
public TrackedRace createTrackedRace(RegattaAndRaceIdentifier raceIdentifier, WindStore windStore,
long delayToLiveInMillis, long millisecondsOverWhichToAverageWind, long millisecondsOverWhichToAverageSpeed) {
DynamicTrackedRegatta trackedRegatta = getOrCreateTrackedRegatta(getRegatta(raceIdentifier));
RaceDefinition race = getRace(raceIdentifier);
return trackedRegatta.createTrackedRace(race, windStore, delayToLiveInMillis,
millisecondsOverWhichToAverageWind, millisecondsOverWhichToAverageSpeed,
/* raceDefinitionSetToUpdate */null);
}
@Override
public RacesHandle addTracTracRace(RegattaIdentifier regattaToAddTo, URL paramURL, URI liveURI,
URI storedURI, URI courseDesignUpdateURI, TimePoint startOfTracking, TimePoint endOfTracking,
RaceLogStore raceLogStore, WindStore windStore, long timeoutInMilliseconds, boolean simulateWithStartTimeNow,
String tracTracUsername, String tracTracPassword) throws Exception {
return addRace(regattaToAddTo, getTracTracDomainFactory().createTrackingConnectivityParameters(paramURL, liveURI, storedURI, courseDesignUpdateURI, startOfTracking,
endOfTracking, delayToLiveInMillis, simulateWithStartTimeNow, raceLogStore, windStore, tracTracUsername, tracTracPassword), windStore, timeoutInMilliseconds);
}
private void ensureRegattaIsObservedForDefaultLeaderboardAndAutoLeaderboardLinking(DynamicTrackedRegatta trackedRegatta) {
synchronized (regattasObservedForDefaultLeaderboard) {
if (!regattasObservedForDefaultLeaderboard.contains(trackedRegatta)) {
trackedRegatta.addRaceListener(new RaceAdditionListener());
regattasObservedForDefaultLeaderboard.add(trackedRegatta);
}
}
}
private void stopObservingRegattaForRedaultLeaderboardAndAutoLeaderboardLinking(DynamicTrackedRegatta trackedRegatta) {
synchronized (regattasObservedForDefaultLeaderboard) {
regattasObservedForDefaultLeaderboard.remove(trackedRegatta);
}
}
/**
* A listener class used to ensure that when a tracked race is added to any {@link TrackedRegatta} managed by this
* service, the service adds the tracked race to the default leaderboard and links it to the leaderboard columns
* that were previously connected to it. Additionally, a {@link RaceChangeListener} is added to the {@link TrackedRace}
* which is responsible for triggering the replication of all relevant changes to the tracked race. When a tracked
* race is removed, the {@link TrackedRaceReplicator} that was added as listener to that tracked race is removed again.
*
* @author Axel Uhl (d043530)
*
*/
private class RaceAdditionListener implements RaceListener, Serializable {
private static final long serialVersionUID = 1036955460477000265L;
private final MaptrackedRace's {@link TrackedRace#getRaceIdentifier() race identifier}, the tracked race
* is (re-)associated to all {@link RaceColumn race columns} that currently have no
* {@link RaceColumn#getTrackedRace(Fleet) tracked race assigned} and whose
* {@link RaceColumn#getRaceIdentifier(Fleet) race identifier} equals that of trackedRace.
*/
private void linkRaceToConfiguredLeaderboardColumns(TrackedRace trackedRace) {
boolean leaderboardHasChanged = false;
RegattaAndRaceIdentifier trackedRaceIdentifier = trackedRace.getRaceIdentifier();
for (Leaderboard leaderboard : getLeaderboards().values()) {
for (RaceColumn column : leaderboard.getRaceColumns()) {
for (Fleet fleet : column.getFleets()) {
if (trackedRaceIdentifier.equals(column.getRaceIdentifier(fleet)) && column.getTrackedRace(fleet) == null) {
column.setTrackedRace(fleet, trackedRace);
leaderboardHasChanged = true;
replicate(new ConnectTrackedRaceToLeaderboardColumn(leaderboard.getName(), column.getName(),
fleet.getName(), trackedRaceIdentifier));
}
}
}
if (leaderboardHasChanged) {
//Update the corresponding groups, to keep them in sync
syncGroupsAfterLeaderboardChange(leaderboard, /*doDatabaseUpdate*/ false);
}
}
}
@Override
public void stopTracking(Regatta regatta) throws MalformedURLException, IOException, InterruptedException {
synchronized (raceTrackersByRegatta) {
if (raceTrackersByRegatta.containsKey(regatta)) {
for (RaceTracker raceTracker : raceTrackersByRegatta.get(regatta)) {
final Set
*
* Future implementations of this method will need to also replicate the effects of the operation to all replica
* of this service known.
*/
@Override
public regatta with its {@link Regatta#getRegattaIdentifier() identifier} so that the next time
* {@link #getRememberedRegattaForRace(RaceDefinition)} is called with race as argument,
* regatta will be returned.
*/
private void setRegattaForRace(Regatta regatta, RaceDefinition race) {
persistentRegattasForRaceIDs.put(race.getId().toString(), regatta);
mongoObjectFactory.storeRegattaForRaceID(race.getId().toString(), regatta);
}
@Override
public CourseArea addCourseArea(Serializable eventId, String courseAreaName, Serializable courseAreaId) {
CourseArea courseArea = new CourseAreaImpl(courseAreaName, courseAreaId);
synchronized (eventsById) {
if (!eventsById.containsKey(eventId)) {
throw new IllegalArgumentException("No sailing event with ID " + eventId + " found.");
}
Event event = eventsById.get(eventId);
event.getVenue().addCourseArea(courseArea);
replicate(new AddCourseArea(eventId, courseAreaName, courseAreaId));
mongoObjectFactory.storeEvent(event);
}
return courseArea;
}
}