/// <inhertidoc />
public void AddLink(IMLink link, Parameters parameters)
{
IMNode neighbour = link.OtherEnd(this);
//Add the link referenced by both its own UUID and the ID of the neighbour it connects to
lock (_links) {
if (!_links.ContainsKey(neighbour.ID))
{
_links.Add(neighbour.ID, link);
}
if (!_links.ContainsKey(link.ID))
{
_links.Add(link.ID, link);
}
}
lock (_neighbours)
if (!_neighbours.ContainsKey(link.ID))
{
_neighbours.Add(link.ID, neighbour);
}
link.OnWeightChanged += _weightDelegate;
if (OnLinkAdded != null)
{
OnLinkAdded(ID, link, parameters);
Logger.Debug(Name + " triggered OnLinkAdded for '" + link.Name + "'.");
}
}
protected bool GetPaused(string name, UUID id)
{
if (!_paused.ContainsKey(id))
{
_paused.Add(id, false);
}
return(_paused[id]);
}
public void RegisterPrim(IPrim prim)
{
if (_prims.ContainsKey(prim.ID))
{
return;
}
lock (_prims)
_prims.Add(prim.ID, prim);
}
/// <summary>
/// Map a string to an ID so it can be looked up when serializing and deserializing.
/// </summary>
/// <param name="id"></param>
/// <param name="name"></param>
private T MapID <T>(T instance) where T : class, ILogicEntity
{
if (_readerMap.ContainsKey(instance.Name))
{
_readerMap[instance.Name] = instance.ID;
}
else
{
_readerMap.Add(instance.Name, instance.ID);
}
_reader.MapInstance <T>(instance);
if (_recordingEnabled)
{
IXmlLogWriter <T> writer = new OpenSimLogWriter <T>(_writerMap, instance, HostPrim.Pos, true);
_writers.Add(instance.ID, writer);
_writerMap.Add(instance.ID, instance.Name);
if (_currentlyRecording)
{
writer.StartRecording(_modelWriter.Log);
}
return(writer.Instance);
}
return(instance);
}
public T Make <T>(T instance, bool recursive) where T : class
{
if (!_recordingEnabled)
{
_reader.MapInstance <T>(instance, !recursive);
return(instance);
}
IXmlLogWriter <T> writer = new OpenSimLogWriter <T>(_writerMap, instance, _hostPrim.Pos, true, recursive);;
if (_baseWriter == null)
{
_baseWriter = writer;
}
else
{
_writers.Add(UUID.Random(), writer);
}
if (_currentlyRecording)
{
writer.StartRecording();
}
_reader.MapInstance <T>(writer.Instance, !recursive);
return(writer.Instance);
}
public virtual void AddStateButton(UUID id, IButton button)
{
if (!_stateButtons.ContainsKey(id))
{
_stateButtons.Add(id, new List <IButton>());
}
_stateButtons[id].Add(button);
}
protected override IMNodeExternal MakeNode(string name, Parameters parameters, Vector3 position, Color colour)
{
Logger.Debug("Creating node '" + name + "'.");
MNode node = new MNode(_view.AddNode(name, parameters, position, colour), _view.Send, _currentAlgorithm, _algorithms, TableFactory);
_knownNodes.Add(node.ID, node);
node.OnForwardingTableChange += (id, routes) => _view.UpdateForwardingTable(id, routes);
Logger.Info("Created node '" + name + "'.");
return(node);
}
/// <summary>
/// Used to specify that the route to a target node is along the specified AddLink
/// </summary>
/// <param name = "target">The node to map a route to</param>
/// <param name = "link">The AddLink along which to pass packets intended for target node</param>
public void SetWIPRoute(UUID target, IMLink link)
{
lock (_wipRoute) {
if (_wipRoute.ContainsKey(target))
{
_wipRoute[target] = link;
}
else
{
_wipRoute.Add(target, link);
}
}
}
public virtual INode AddNode(string name, Parameters parameters, Vector3 position = default(Vector3), Color colour = default(Color))
{
if (name == null)
{
throw new Exception("Unable to add entity. Name cannot be null");
}
lock (this) {
TNode node = MakeNode(name, parameters, position, colour);
_nodes.Add(node.ID, node);
_neighbours.Add(node.ID, TableFactory.MakeKeyTable <TNode>());
_connections.Add(node.ID, TableFactory.MakeKeyTable <TLink>());
Logger.Debug("Stored node '" + name + "'.");
return(node);
}
}
private void OnSelected(string name, UUID id)
{
Control.State.SetState(SandboxControl.LinkSelected, name, id);
Control.State.SetSelectedPrim(ID, name, id);
if (!_bufferedChanges.ContainsKey(id))
{
_bufferedChanges.Add(id, Weight);
}
else
{
_bufferedChanges[id] = Weight;
}
ShowLinkDialog(name, id);
}
public OriginalControl(IKeyTableFactory tableFactory, IAsynchQueueFactory queueFactory, IPrimFactory primFactory, IModel model, UUID hostID, IConfigSource config)
: base(tableFactory, queueFactory)
{
_hostPrim = primFactory[hostID];
_readerMap = new Dictionary <string, UUID>();
_writerMap = tableFactory.MakeKeyTable <string>();
_paused = tableFactory.MakeKeyTable <bool>();
IConfig controlConfig = config.Configs["Control"];
IConfig commonConfig = config.Configs["Common"];
if (controlConfig == null)
{
controlConfig = config.Configs[0];
}
if (commonConfig == null)
{
commonConfig = config.Configs[0];
}
_wait = commonConfig.GetInt("Wait", 50);
_userFolder = controlConfig.Get("UserFolder", ".");
_recordingEnabled = controlConfig.GetBoolean("RecordingEnabled", false);
_timing = controlConfig.GetBoolean("TimedPlayback", true);
_schemaFile = controlConfig.GetString("TopologySchema", null);
_reader = new OpenSimLogReader(_readerMap, model, HostPrim.Pos);
_reader.MapInstance <IModule>(this);
_writers = tableFactory.MakeKeyTable <IXmlLogWriter>();
_factory = primFactory;
if (_recordingEnabled)
{
_modelWriter = new OpenSimLogWriter <IModel>(_writerMap, model, HostPrim.Pos, true, false);
_model = _modelWriter.Instance;
IXmlLogWriter <IModule> baseWriter = new OpenSimLogWriter <IModule>(_writerMap, this, HostPrim.Pos, true);
_recordingBase = baseWriter.Instance;
_writers.Add(hostID, baseWriter);
}
else
{
_model = model;
}
Namespace = controlConfig.Get("Namespace", Namespace);
Logger.Info("Control started.");
}
public virtual void AddToggle(UUID id, Toggle toggle)
{
if (!_toggles.ContainsKey(id))
{
_toggles.Add(id, new Dictionary <string, Toggle>());
}
if (!_toggles[id].ContainsKey(toggle.Name))
{
_toggles[id].Add(toggle.Name, toggle);
}
else
{
_toggles[id][toggle.Name] = toggle;
}
}
/// <summary>
/// Trigger the node to display its forwarding table.
/// </summary>
/// <param name="node">The ID of the node to display the forwarding table for.</param>
/// <param name="routes">The strings which represent each route the forwarding table knows of.</param>
public void DisplayForwardingTable(UUID node, Route[] routes, params UUID[] boards)
{
if (!IsNode(node))
{
return;
}
_factory.Host.Say("Displaying forwarding table. " + boards.Length + " buttons selected for " + GetNode(node).Name + ".");
foreach (UUID board in boards)
{
if (board == UUID.Zero)
{
continue;
}
if (_displayingBoards.ContainsKey(board))
{
foreach (UUID oldNode in _displayingBoards[board])
{
if (!oldNode.Equals(node) && IsNode(oldNode))
{
GetNode(oldNode).RemoveBoard(board);
}
}
_displayingBoards[board] = _displayingBoards[board].Concat(new UUID[] { node });
}
else
{
_displayingBoards.Add(board, new UUID[] { node });
}
}
new Thread(() => {
try {
GetNode(node).
DisplayForwardingTable(routes, boards.
Where(board => !board.Equals(UUID.Zero) && _factory.PrimExists(board)).
Select <UUID, IPrim>(board => _factory[board]));
} catch (Exception e) {
Logger.Warn("Problem displaying board. " + e.Message);
}
}).Start();
}
public override void ProcessPacket(IMPacket p)
{
if (!Links.ContainsKey(p.S))
{
_unknownPacket = p;
return;
}
DVPacket packet = p as DVPacket;
lock (neighbourVectors)
//Add the new distance vector to the collection of known distance vectors
if (!neighbourVectors.ContainsKey(p.S))
{
neighbourVectors.Add(p.S, packet.DistanceVector);
}
else
{
neighbourVectors[p.S] = packet.DistanceVector;
}
findShortestPaths(packet.TTL, "Distance Vector receiving '" + p.Name + "'", p.Visualise);
}
internal void SetDistanceFromRoot(UUID root, float value, DijkstraNode prevNode, IMLink link)
{
//if (prevNode != null/* && !Links.ContainsKey(prevNode.ID)*/)
// return;
lock (_distances) {
if (_distances.ContainsKey(root))
{
_distances[root] = value;
_prev[root] = prevNode;
}
else
{
_distances.Add(root, value);
_prev.Add(root, prevNode);
}
}
if (prevNode != null)
{
SetWIPRoute(root, link);
}
}
protected void SetRoute(string alg, UUID target, IMLink link, float dist)
{
if (_table.ContainsKey(target))
{
IMLink oldLink = _table[target];
float oldDist = _distances[target];
_table[target] = link;
_distances[target] = dist;
if (OnRouteChange != null && IsCurrentAlgorithm && (!link.Equals(oldLink) || dist != oldDist))
{
OnRouteChange(alg, KnownNodes[target], oldLink, link, oldDist, dist);
}
}
else
{
_table.Add(target, link);
_distances.Add(target, dist);
if (OnRouteChange != null && IsCurrentAlgorithm)
{
OnRouteChange(alg, KnownNodes[target], null, link, -1f, dist);
}
}
}
public virtual ILink AddLink(UUID from, UUID to, Parameters parameters, float weight = default(float), bool bidirectional = true)
{
lock (this) {
CheckLinksPair(from, to, "add");
if (AreLinked(from, to))
{
throw new Exception("Unable to add link. '" + _nodes[from].Name + "' and '" + _nodes[to] + "' are alread linked.");
}
TLink link = MakeLink(from, to, parameters, weight, bidirectional);
_links.Add(link.ID, link);
_neighbours[from].Add(link.ID, _nodes[to]);
_connections[from].Add(to, link);
if (bidirectional)
{
_neighbours[to].Add(link.ID, _nodes[from]);
_connections[to].Add(from, link);
}
Logger.Debug("Stored '" + link.Name + "'.");
return(link);
}
}