DefaultTopologyComponent.java

/*
 * Copyright (c) 2005-2010 KOM – Multimedia Communications Lab
 *
 * This file is part of PeerfactSim.KOM.
 * 
 * PeerfactSim.KOM is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * any later version.
 * 
 * PeerfactSim.KOM is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with PeerfactSim.KOM.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

package de.tud.kom.p2psim.impl.topology;

import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.Set;
import java.util.function.Consumer;

import de.tud.kom.p2psim.api.common.HostProperties;
import de.tud.kom.p2psim.api.common.SimHost;
import de.tud.kom.p2psim.api.linklayer.mac.MacAddress;
import de.tud.kom.p2psim.api.linklayer.mac.MacLayer;
import de.tud.kom.p2psim.api.linklayer.mac.PhyType;
import de.tud.kom.p2psim.api.topology.Topology;
import de.tud.kom.p2psim.api.topology.TopologyComponent;
import de.tud.kom.p2psim.api.topology.movement.MovementListener;
import de.tud.kom.p2psim.api.topology.movement.MovementSupported;
import de.tud.kom.p2psim.api.topology.movement.PositionListener;
import de.tud.kom.p2psim.api.topology.placement.PlacementModel;
import de.tud.kom.p2psim.api.topology.views.TopologyView;
import de.tud.kom.p2psim.impl.simengine.Simulator;
import de.tud.kom.p2psim.impl.topology.movement.modular.attraction.AttractionPoint;
import de.tudarmstadt.maki.simonstrator.api.Event;
import de.tudarmstadt.maki.simonstrator.api.EventHandler;
import de.tudarmstadt.maki.simonstrator.api.Graphs;
import de.tudarmstadt.maki.simonstrator.api.Host;
import de.tudarmstadt.maki.simonstrator.api.Randoms;
import de.tudarmstadt.maki.simonstrator.api.common.graph.Graph;
import de.tudarmstadt.maki.simonstrator.api.common.graph.IEdge;
import de.tudarmstadt.maki.simonstrator.api.common.graph.INode;
import de.tudarmstadt.maki.simonstrator.api.common.graph.INodeID;
import de.tudarmstadt.maki.simonstrator.api.component.ComponentNotAvailableException;
import de.tudarmstadt.maki.simonstrator.api.component.network.NetInterface;
import de.tudarmstadt.maki.simonstrator.api.component.network.NetworkComponent.NetInterfaceName;
import de.tudarmstadt.maki.simonstrator.api.component.sensor.location.Location;
import de.tudarmstadt.maki.simonstrator.api.component.sensor.location.LocationListener;
import de.tudarmstadt.maki.simonstrator.api.component.sensor.location.LocationRequest;
import de.tudarmstadt.maki.simonstrator.api.component.sensor.location.LocationSensor;
import de.tudarmstadt.maki.simonstrator.api.component.sis.SiSComponent;
import de.tudarmstadt.maki.simonstrator.api.component.sis.SiSDataCallback;
import de.tudarmstadt.maki.simonstrator.api.component.sis.SiSInfoProperties;
import de.tudarmstadt.maki.simonstrator.api.component.sis.SiSInformationProvider.SiSProviderHandle;
import de.tudarmstadt.maki.simonstrator.api.component.sis.exception.InformationNotAvailableException;
import de.tudarmstadt.maki.simonstrator.api.component.sis.type.SiSTypes;
import de.tudarmstadt.maki.simonstrator.api.component.sis.util.SiSTopologyProvider;
import de.tudarmstadt.maki.simonstrator.api.component.topology.TopologyID;
import de.tudarmstadt.maki.simonstrator.api.component.transport.ConnectivityListener;
import de.tudarmstadt.maki.simonstrator.api.operation.Operations;
import de.tudarmstadt.maki.simonstrator.api.operation.PeriodicOperation;

/**
 * Default implementation of a {@link TopologyComponent}.
 * 
 * @author Bjoern Richerzhagen
 * @version 1.0, 29.02.2012
 */
public class DefaultTopologyComponent implements TopologyComponent {

	protected static Random rnd = Randoms.getRandom(AttractionPoint.class);

	private SimHost host;

	private PositionVector position;

	private Topology topology;

	private Set<PositionListener> positionListener = new LinkedHashSet<PositionListener>();

	private Set<MovementListener> movementListeners = new LinkedHashSet<>();
	
	private double currentMovementSpeed = -1;

	/**
	 * This reference is nulled after placement, as the process is only done
	 * once.
	 */
	private PlacementModel placement;

	public DefaultTopologyComponent(SimHost host, Topology topology,
			PlacementModel placement) {
		this.topology = topology;
		this.placement = placement;
		this.host = host;
		// TODO maybe we need to do this in the initialize-method
		placement.addComponent(this);
	}

	@Override
	public void initialize() {
		position = placement.place(this);
		placement = null;
		topology.addComponent(this);

		try {
			final SiSComponent sis = host.getComponent(SiSComponent.class);
			sis.provide().nodeState(SiSTypes.PHY_LOCATION,
					new SiSDataCallback<Location>() {

						Set<INodeID> localID = INodeID.getSingleIDSet(getHost()
								.getId());

						@Override
						public Location getValue(INodeID nodeID,
								SiSProviderHandle providerHandle)
								throws InformationNotAvailableException {
							if (nodeID.equals(getHost().getId())) {
								return getLastLocation();
							} else {
								throw new InformationNotAvailableException();
							}
						}

						@Override
						public Set<INodeID> getObservedNodes() {
							return localID;
						}

						@Override
						public SiSInfoProperties getInfoProperties() {
							return new SiSInfoProperties();
						}
					});

			// Provide Underlay topology
			Event.scheduleImmediately(new EventHandler() {

				@Override
				public void eventOccurred(Object content, int type) {
					if (getHost().getLinkLayer().hasPhy(PhyType.WIFI)) {
						new SiSTopologyProvider(sis, SiSTypes.NEIGHBORS_WIFI,
								DefaultTopologyComponent.this, getTopologyID(
										NetInterfaceName.WIFI, true),
								DefaultTopologyComponent.class);
					}
				}
			}, null, 0);

		} catch (ComponentNotAvailableException e) {
			// OK
		}
	}

	@Override
	public void shutdown() {
		topology = null;
		positionListener.clear();
		movementListeners.clear();
		host = null;
	}

	@Override
	public SimHost getHost() {
		return host;
	}

	@Override
	public void positionChanged() {
		for (PositionListener listener : positionListener) {
			if (listener.getPosition().distanceTo(position) < listener
					.getRadius()) {
				listener.reachedPosition();
			}
		}
	}

	@Override
	public void afterComponentMoved(MovementSupported comp) {
		for (MovementListener moveListener : movementListeners) {
			moveListener.afterComponentMoved(this);
		}
	}

	@Override
	public boolean movementActive() {
		/*
		 * Needed? Maybe redesign the API
		 */
		return true;
	}

	@Override
	public PositionVector getRealPosition() {
		return position;
	}

	@Override
	public Topology getTopology() {
		return topology;
	}

	@Override
	public void addPositionListener(PositionListener listener) {
		positionListener.add(listener);
	}

	@Override
	public void removePositionListener(PositionListener listener) {
		positionListener.remove(listener);
	}

	@Override
	public void addMovementListener(MovementListener listener) {
		movementListeners.add(listener);
	}

	@Override
	public void removeMovementListener(MovementListener listener) {
		movementListeners.remove(listener);
	}

	@Override
	public double getMinMovementSpeed() {
		HostProperties properties = getHost().getProperties();

		return properties.getMinMovementSpeed();
	}

	@Override
	public double getMaxMovementSpeed() {
		HostProperties properties = getHost().getProperties();
		return properties.getMaxMovementSpeed();
	}
	
	private void calcRandomMovementSpeed() {
		double min_speed = getMinMovementSpeed();
		double max_speed = getMaxMovementSpeed();

		double value = rnd.nextDouble();
		this.currentMovementSpeed = (value * (max_speed - min_speed)) + min_speed;
	}

	@Override
	public double getMovementSpeed() {
		if (currentMovementSpeed == -1) {
			calcRandomMovementSpeed();
		}
		return this.currentMovementSpeed;
	}
	
	@Override
	public void setMovementSpeed(double speed) {
		this.currentMovementSpeed = speed;
	}

	@Override
	public Location getLastLocation() {
		/*
		 * As we want to mimic real world behavior, the current position
		 * snapshot is cloned to prevent information propagation due to Java.
		 */
		return position.clone();
	}

	@Override
	public void requestLocationUpdates(LocationRequest request,
			LocationListener listener) {
		if (openRequests.containsKey(listener)) {
			throw new AssertionError("This LocationListener is already in use.");
		}
		LocationRequestImpl req = (LocationRequestImpl) request;
		openRequests.put(listener, req);
		req.immunizeAndStart(listener);
	}

	@Override
	public void removeLocationUpdates(LocationListener listener) {
		LocationRequestImpl impl = openRequests.remove(listener);
		impl.cancel(listener);
	}

	@Override
	public LocationRequest getLocationRequest() {
		return new LocationRequestImpl();
	}

	private Map<LocationListener, LocationRequestImpl> openRequests = new LinkedHashMap<LocationListener, LocationRequestImpl>();

	/**
	 * Update 15.03.16 added support for multiple listeners (however, frequency etc. 
	 * is immune after the first request is registered.)
	 * 
	 * @author Bjoern Richerzhagen
	 * @version 1.0, Mar 15, 2016
	 */
	private class LocationRequestImpl implements LocationRequest, EventHandler {

		private boolean immune = false;

		private long interval = 1 * Simulator.MINUTE_UNIT;

		private int priority = LocationRequest.PRIORITY_BALANCED_POWER_ACCURACY;
		
		private Location lastLocation = null;

		private List<LocationListener> listeners = new LinkedList<LocationListener>();
		
		public LocationRequestImpl() {
			// nothing to do
		}

		protected void cancel(LocationListener listener) {
			boolean removed = listeners.remove(listener);
			assert removed;
		}

		protected void immunizeAndStart(LocationListener listener) {
			immune = true;
			assert interval > 0;
			if (listeners.isEmpty()) {
				// Only start once!
				lastLocation = null;
				Event.scheduleImmediately(this, null, 0);
			} else {
				// Fire each new listener at least once
				listener.onLocationChanged(getLastLocation());
			}
			listeners.add(listener);
		}

		@Override
		public void setInterval(long interval) {
			if (!immune) {
				this.interval = interval;
			}
		}

		@Override
		public void setPriority(int priority) {
			if (!immune) {
				this.priority = priority;
			}
		}

		@Override
		public void eventOccurred(Object content, int type) {
			if (!listeners.isEmpty()) {
				// Only reschedule, if at least one listener is ... listening
				Location newLoc = getLastLocation();
				if (lastLocation == null || lastLocation.distanceTo(newLoc) > 0) {
					listeners.forEach((LocationListener listener) -> listener.onLocationChanged(newLoc));
					lastLocation = newLoc;
				}
				Event.scheduleWithDelay(interval, this, null, 0);
			}
		}

	}

	/*
	 * Methods for the Graph Interface
	 */

	/**
	 * Graph views: static, as we use global knowledge and maintain one shared
	 * graph (potentially with partitions!)
	 */
	private final static LinkedHashMap<TopologyID, LocalGraphView> graphViews = new LinkedHashMap<>();

	@Override
	public TopologyID getTopologyID(NetInterfaceName netName, boolean onlyOnline) {
		TopologyID id = TopologyID.getIdentifier(netName.toString()
				+ (onlyOnline ? "-online" : "-all"),
				DefaultTopologyComponent.class);
		if (!this.graphViews.containsKey(id)) {
			this.graphViews.put(id, new LocalGraphView(netName, onlyOnline));
		}
		return id;
	}

	@Override
	public TopologyID getTopologyID(NetInterfaceName netName,
			boolean onlyOnline, double range) {
		TopologyID id = TopologyID.getIdentifier(netName.toString()
				+ (onlyOnline ? "-online" : "-all") + String.valueOf(range),
				DefaultTopologyComponent.class);
		if (!this.graphViews.containsKey(id)) {
			this.graphViews.put(id, new LocalGraphView(netName, onlyOnline,
					range));
		}
		return id;
	}

	@Override
	public INode getNode(TopologyID identifier) {
		assert graphViews.containsKey(identifier);
		return graphViews.get(identifier).getOwnNode(host);
	}

	@Override
	public Set<IEdge> getNeighbors(TopologyID topologyIdentifier) {
		assert graphViews.containsKey(topologyIdentifier);
		return graphViews.get(topologyIdentifier).getNeighbors(host);
	}

	@Override
	public Graph getLocalView(TopologyID topologyIdentifier) {
		assert graphViews.containsKey(topologyIdentifier);
		return graphViews.get(topologyIdentifier).getLocalView();
	}

	@Override
	public Iterable<TopologyID> getTopologyIdentifiers() {
		return graphViews.keySet();
	}

	/**
	 * This is calculated based on global knowledge. It only registers as
	 * {@link MovementListener}, if a range is specified by the Provider.
	 * 
	 * @author Bjoern Richerzhagen
	 * @version 1.0, May 13, 2015
	 */
	private class LocalGraphView implements MovementListener,
			ConnectivityListener {

		/**
		 * Marker: has there been any movement since the graph view was last
		 * requested? If so: recalculate! Otherwise, we ignore this object to
		 * not perform calculations if no one is interested...
		 */
		private final double distance;

		private final boolean isDistanceBased;

		private final NetInterfaceName medium;

		private final TopologyView topoView;

		private final boolean onlyOnline;

		private Graph currentView;

		private boolean isInvalid = true;

		private final PhyType phy;

		public LocalGraphView(NetInterfaceName medium, boolean onlyOnline) {
			this(medium, onlyOnline, -1);
		}

		public LocalGraphView(NetInterfaceName medium, boolean onlyOnline,
				double distance) {
			this.medium = medium;
			PhyType localPhy = null;
			for (PhyType currPhy : PhyType.values()) {
				if (currPhy.getNetInterfaceName() == medium
						&& getTopology().getTopologyView(currPhy) != null) {
					localPhy = currPhy;
					break;
				}
			}
			phy = localPhy;
			assert localPhy != null;
			this.topoView = getTopology().getTopologyView(localPhy);
			this.distance = distance;
			this.onlyOnline = onlyOnline;
			this.isDistanceBased = (distance > 0);
			assert !isDistanceBased || phy.isBroadcastMedium();
			if (phy.isBroadcastMedium()) {
				// register as listener for movement
				addMovementListener(LocalGraphView.this);
			}
			// register as listener for online/offline events
			if (onlyOnline) {
				getHost().getNetworkComponent().getByName(medium)
						.addConnectivityListener(LocalGraphView.this);
			}
		}

		private void recalculateLocalView() {
			if (!isInvalid) {
				/*
				 * Graphs are invalidated (i) based on movement, IFF a range was
				 * specified, (ii) based on online/offline events, IFF only
				 * online hosts are to be considered.
				 */
				return;
			}
			/*
			 * Calculate a complete global connectivity graph
			 */

			// Create new, empty graph
			currentView = Graphs.createGraph();

			// Add all (online?) nodes
			for (MacLayer mac : topoView.getAllMacs()) {
				if (!onlyOnline || mac.isOnline()) {
					INode node = currentView.createNode(mac.getHost().getId());
					node.setProperty(SiSTypes.PHY_LOCATION,
							topoView.getPosition(mac.getMacAddress()));
					currentView.addElement(node);
				}
			}

			if (isDistanceBased) {
				// Build neighbors solely based on an assumed range
				for (MacLayer mac : topoView.getAllMacs()) {
					// Consider all nodes as potential neighbors
					for (MacLayer neighborMac : topoView.getAllMacs()) {
						// create, but do NOT add the node object
						INode neighbor = currentView.createNode(neighborMac
								.getHost().getId());
						// only online nodes (already in graph)
						if (!onlyOnline
								|| currentView.containsNode(neighbor.getId())) {
							// Distance?
							if (topoView.getDistance(mac.getMacAddress(),
									neighborMac.getMacAddress()) <= distance) {
								IEdge edge = currentView.createEdge(mac
										.getHost().getId(), neighborMac
										.getHost().getId());
								currentView.addElement(edge);
							}
						}
					}
				}
			} else {
				// Build neighborhoods based on underlay neighbors (1-hop)
				for (MacLayer mac : topoView.getAllMacs()) {
					// Rely on underlay for neighbors
					List<MacAddress> neighbors = topoView.getNeighbors(mac
							.getMacAddress());
					for (MacAddress neighborMac : neighbors) {
						// create, but do NOT add the node object
						INode neighbor = currentView.createNode(topoView
								.getMac(neighborMac).getHost().getId());
						// only online nodes (already in graph)
						if (!onlyOnline
								|| currentView.containsNode(neighbor.getId())) {
							IEdge edge = currentView.createEdge(mac.getHost()
									.getId(), topoView.getMac(neighborMac)
									.getHost().getId());
							currentView.addElement(edge);
							edge.setProperty(SiSTypes.PHY_DISTANCE, topoView
									.getDistance(mac.getMacAddress(),
											neighborMac));
						}
					}
				}
			}

			isInvalid = false;
		}

		public INode getOwnNode(SimHost ownHost) {
			MacLayer mac = ownHost.getLinkLayer().getMac(phy);
			if (!onlyOnline || mac.isOnline()) {
				return currentView.createNode(ownHost.getId());
			}
			return null;
		}

		public Set<IEdge> getNeighbors(SimHost ownHost) {
			recalculateLocalView();
			INode ownNode = getOwnNode(ownHost);
			return currentView.getOutgoingEdges(ownNode.getId());
		}

		/**
		 * This is the global view, therefore we do not distinguish between
		 * hosts.
		 * 
		 * @return
		 */
		public Graph getLocalView() {
			recalculateLocalView();
			return currentView;
		}

		@Override
		public void afterComponentMoved(MovementSupported comp) {
			this.isInvalid = true;
		}

		@Override
		public void wentOnline(Host host, NetInterface netInterface) {
			assert netInterface.getName() == medium;
			this.isInvalid = true;
		}

		@Override
		public void wentOffline(Host host, NetInterface netInterface) {
			assert netInterface.getName() == medium;
			this.isInvalid = true;
		}

	}

}