private void UpdateRoutes(byte[] response, int bytesReceived)
{
var neighbor = new RouteEntry()
{
Ip = ConvertFromBytesToInteger(response, 8),
Gateway = ConvertFromIpAddressToInteger(OwnIP),
Cost = 0
};
var routes = new List <RouteEntry>();
routes.Add(neighbor);
if (bytesReceived > 24)
{
for (int index = 24; index < bytesReceived; index += 20)
{
var entry = new RouteEntry()
{
Ip = ConvertFromBytesToInteger(response, index + 4),
Gateway = neighbor.Ip,
Cost = ConvertFromBytesToInteger(response, index + 16) + 1
};
//dont add yourself to route list
if (ConvertFromIntegerToIpAddress(entry.Ip).Equals(OwnIP))
{
continue;
}
//dont add routes with hop count higher than 15
if (entry.Cost > MaxHopCount)
{
continue;
}
routes.Add(entry);
}
}
RouteTable.mutex.WaitOne();
foreach (var entry in routes)
{
if (RouteTable.Contains(entry))
{
int index = RouteTable.IndexOf(entry);
var oldEntry = RouteTable[index];
if (oldEntry.Cost >= entry.Cost)
{
RouteTable[index] = entry;
}
}
else
{
RouteTable.Add(entry);
}
}
RouteTable.mutex.ReleaseMutex();
}
public void WS(string route, Func <OryxWebContext, Task> func)
{
RouteTable.Add(route + "_ws", new RouteTableItem
{
Func = func,
Path = route,
Method = "ws"
});
}
public void Request(string route, string method, Func <OryxWebContext, Task> func)
{
RouteTable.Add(route + "_" + method, new RouteTableItem
{
Func = func,
Path = route,
Method = method
});
}
public void CreateRouteTable()
{
routes.Add(String.Empty, rootTarget);
routes.Add("one/two", oneTwo);
routes.Add("one/three", oneThree);
routes.Add("one/two/three/{id}", withId);
routes.Add("one/two/greedy/{id+}", withGreedyId);
routes.Add("one/two/optional/{id?}", withOptionalId);
routes.Add("one/two/optgreedy/{id*}", withOptGreedyId);
routes.Add("{id}/one/two", withLanguage);
}
private void addToRouteTable(byte nodeReference, byte nodeGateway, byte distance)
{
if (RouteTable.ContainsKey(nodeReference))
{
if (distance < RouteTable[nodeReference][1])
{
RouteTable[nodeReference][0] = nodeGateway;
RouteTable[nodeReference][1] = distance;
}
}
else
{
RouteTable.Add(nodeReference, new byte[] { nodeGateway, distance });
}
}
public void RefreshNeigbors()
{
lock (RouteTable)
{
lock (NeighborsTable)
{
NeighborsTable.Clear();
foreach (var node in Program.NodeList)
{
if (IsNeigbor(node))
{
NeighborsTable.Add(node.Address);
if (RouteTable.ContainsKey(node.Address))
{
RouteTable.Remove(node.Address);
}
RouteTable.Add(node.Address, new KeyValuePair <string, int>(node.Address, 0)); //Longitud = 0 -> Camino directo
}
}
}
List <string> removeList = new List <string>();
foreach (var item in RouteTable)
{
if (!NeighborsTable.Contains(item.Value.Key))//is not a neigbor
{
removeList.Add(item.Key);
}
}
foreach (string address in removeList)
{
RouteTable.Remove(address);
}
}
}
void mainLoopTimer_Elapsed(object sender, ElapsedEventArgs e)
{
lock (this)
{
mainLoopTimer.Enabled = false;
RefreshNeigbors();
TimeSpan iterationTime = new TimeSpan(DateTime.Now.Ticks);
int diff = (int)(iterationTime - lastIterationTime).TotalMilliseconds;
lastIterationTime = iterationTime;
if (LookTable.Count > 0) //Check pending searches
{
List <string> items = LookTable.Keys.ToList();
for (int i = 0; i < items.Count; i++)
{
string search = items[i];
var aux = LookTable[search];
if (aux.Value > 0)
{
int newCount = aux.Value - diff;
LookTable[search] = new KeyValuePair <string, int>(aux.Key, newCount);
}
else
{
LookTable.Remove(search);
}
}
}
if (outputBuffer.Count > 0)//Messages to send
{
List <RFMessage> items = outputBuffer.Keys.ToList();
//List<RFMessage> removeList = new List<RFMessage>();
foreach (var outmsg in items)
{
if (!LookTable.ContainsKey(outmsg.To))//Look finished
{
transmitRF(outmsg);
//removeList.Add(outmsg);
outputBuffer.Remove(outmsg);
}
else if (LookTable[outmsg.To].Value <= 0)
{
Program.MessageBoxCustom("Timeout superado", "MESSAGE FROM " + outmsg.Root + " TO " + outmsg.To + " ");
//removeList.Add(outmsg);
outputBuffer.Remove(outmsg);
LookTable.Remove(outmsg.To);
}
}
//outputBuffer.RemoveAll(x => removeList.Contains(x));
}
if (inputBuffer.Count > 0)//Messages to read
{
RFMessage message = inputBuffer[0];
byte maskHeader = (byte)(message.Header & 0xC0);
if (maskHeader == 0x40)//Is RouteAnswer?
{
if (RouteTable.ContainsKey(message.Data))
{
RFMessage routeResponse = new RFMessage();
routeResponse.To = message.From;
routeResponse.From = Address;
routeResponse.Header = (byte)(0x20 | RouteTable[message.Data].Value); //RouteResponse OK y longitud almacenada en la routeTable
routeResponse.Data = message.Data; //Search Node
Node Dest = Program.NodeList.First <Node>(x => x.Address == message.From);
Dest.SendMessage(routeResponse);
}
else
{
LookFor(message.Data, message.From);
}
}
else if (maskHeader == 0x00) //Is RouteResponse?
{
bool isOK = (message.Header & 0xE0) == 0x20; //is OK?
if (isOK)
{
byte distance = (byte)(message.Header & 0x1F);
if (distance == 0x1F)
{
throw new IndexOutOfRangeException(); //Distance Overflow
}
if (RouteTable.ContainsKey(message.Data))
{
if ((distance + 1) < RouteTable[message.Data].Value) //Short way
{
RouteTable[message.Data] = new KeyValuePair <string, int>(message.From, distance + 1);
}
}
else
{
RouteTable.Add(message.Data, new KeyValuePair <string, int>(message.From, distance + 1));
}
}
else if (RouteTable.ContainsKey(message.Data) && RouteTable[message.Data].Key == message.From)
{
RouteTable.Remove(message.Data);
//Avisar a mis vecinos de que ya no puedo llegar al destinatario del mensaje
foreach (var nodeAddress in NeighborsTable)
{
if (message.From != nodeAddress)
{
RFMessage routeResponse = new RFMessage();
routeResponse.To = nodeAddress;
routeResponse.From = Address;
routeResponse.Data = message.Data; //Search Node
routeResponse.Header = 0x00; //RouteResponse FAIL
routeResponse.Root = message.Root; //TRAMPA
Node Dest = Program.NodeList.First <Node>(x => x.Address == routeResponse.To);
Dest.SendMessage(routeResponse);
}
}
//TODO: Si existen mensajes pendientes para este nodo, se reintenta para trazar una nueva ruta
if (message.Root == Address)//outputBuffer.Exists(x => x.To == message.Data))
{
//RFMessage retry = outputBuffer.First(x => x.To == message.Data);
//outputBuffer.Remove(retry);
//transmitRF(retry);
Program.MessageBoxCustom("Ha cambiado la topologia de la red. Reenviar", "MESSAGE FROM " + Address + " TO " + message.Data + " ");
}
}
if (LookTable.ContainsKey(message.Data) && LookTable[message.Data].Key != null)
{
RFMessage routeResponse = new RFMessage();
routeResponse.To = LookTable[message.Data].Key;
routeResponse.From = Address;
routeResponse.Data = message.Data; //Search Node
if (isOK)
{
routeResponse.Header = (byte)(0x20 | (byte)(message.Header & 0x1F) + 1); //RouteResponse OK y longitud recibida + 1
}
else
{
routeResponse.Header = 0x00; //RouteResponse FAIL
}
Node Dest = Program.NodeList.First <Node>(x => x.Address == routeResponse.To);
Dest.SendMessage(routeResponse);
}
LookTable.Remove(message.Data);
}
else //Is a message
{
if (message.To == Address) //it's to me?
{
message.Data += Address;
Program.MessageBoxCustom(message.Data, "MESSAGE FROM " + message.Root + " TO " + message.To + " ");
}
else if (RouteTable.ContainsKey(message.To))
{
message.From = Address;
message.Data += Address + " -> ";
Node Dest = Program.NodeList.First <Node>(x => x.Address == RouteTable[message.To].Key);
Dest.SendMessage(message);
}
else
{
RFMessage routeResponse = new RFMessage();
routeResponse.To = message.From;
routeResponse.From = Address;
routeResponse.Data = message.To; //Search Node
routeResponse.Header = 0x00; //RouteResponse FAIL
routeResponse.Root = message.Root; //TRAMPA
Node Dest = Program.NodeList.First <Node>(x => x.Address == routeResponse.To);
Dest.SendMessage(routeResponse);
}
}
inputBuffer.Remove(message);
}
}
}
