134 lines
3.2 KiB
Haxe
134 lines
3.2 KiB
Haxe
package kernel.net;
|
|
|
|
import kernel.peripherals.Peripherals.Peripheral;
|
|
import kernel.net.INetworkInterface;
|
|
|
|
using tink.CoreApi;
|
|
|
|
import kernel.net.Package.NetworkID;
|
|
|
|
@:structInit typedef Route = {
|
|
interf:INetworkInterface,
|
|
cost:Int
|
|
}
|
|
|
|
/**
|
|
Manages network routing.
|
|
**/
|
|
class Routing {
|
|
/**
|
|
Depends on: Peripheral
|
|
**/
|
|
public static var instance:Routing;
|
|
|
|
public final onNewNeigbor:Signal<Int>;
|
|
|
|
private final onNewNeigborTrigger:SignalTrigger<NetworkID> = Signal.trigger();
|
|
private final routingTable:Map<NetworkID, Route> = new Map();
|
|
|
|
@:allow(kernel.Init)
|
|
private function new() {
|
|
this.onNewNeigbor = this.onNewNeigborTrigger.asSignal();
|
|
}
|
|
|
|
@:allow(kernel.Init)
|
|
private function init() {
|
|
routingTable.set(Net.instance.networkID,{interf: Loopback.instance,cost:0});
|
|
for (modem in Peripheral.instance.getModems()) {
|
|
modem.send(Net.BRODCAST_PORT, Net.instance.networkID, newRoutDiscoverPackage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
Handle incomming packages that involve route discovery.
|
|
**/
|
|
public function handleRoutePackage(pack:Package, interf:INetworkInterface):Void {
|
|
addPossibleRoute(pack.fromID,interf,0);
|
|
|
|
var shouldRespond: Bool = switch pack.type {
|
|
case RouteDiscoverResponse(routes):
|
|
for (route in routes) {
|
|
addPossibleRoute(route.id,interf,route.cost);
|
|
}
|
|
false;
|
|
case RouteDiscover(routes):
|
|
for (route in routes) {
|
|
addPossibleRoute(route.id,interf,route.cost);
|
|
}
|
|
true;
|
|
default:
|
|
Log.error("Expected RouteDiscover or RouteDiscoverResponse type");
|
|
false;
|
|
};
|
|
|
|
if (!shouldRespond){
|
|
return;
|
|
}
|
|
|
|
// Respond to peer
|
|
var response:Package = {
|
|
toID: pack.fromID,
|
|
fromID: Net.instance.networkID,
|
|
msgID: null,
|
|
type: RouteDiscoverResponse(genRouteList()),
|
|
data: null
|
|
}
|
|
|
|
interf.send(response.toID,Net.instance.networkID,response);
|
|
}
|
|
|
|
private function genRouteList(): Array<{id:NetworkID,cost:Int}> {
|
|
var routes: Array<{id:NetworkID,cost:Int}> = [];
|
|
for (k => v in this.routingTable){
|
|
routes.push({
|
|
id: k,
|
|
cost: v.cost
|
|
});
|
|
}
|
|
return routes;
|
|
}
|
|
|
|
private function newRoutDiscoverPackage():Package {
|
|
var pack:Package = {
|
|
type: RouteDiscover(genRouteList()),
|
|
toID: Net.BRODCAST_PORT,
|
|
msgID: null,
|
|
fromID: Net.instance.networkID,
|
|
data: null,
|
|
}
|
|
|
|
return pack;
|
|
}
|
|
|
|
/**
|
|
Called when a route to a client has been disoverd.
|
|
Its possible to be called multiple times with the same id but different addr.
|
|
**/
|
|
private function addPossibleRoute(toID:Int, interf:INetworkInterface, cost:Int) {
|
|
if (toID == Net.instance.networkID){
|
|
return;
|
|
}
|
|
|
|
var fullCost = cost+interf.getBaseRoutingCost();
|
|
|
|
if (this.routingTable.exists(toID)){
|
|
if (this.routingTable[toID].cost > fullCost){
|
|
Log.info("Better route: " + toID + " -> " + interf.name() + ":$"+fullCost);
|
|
this.routingTable[toID] = {interf:interf,cost:cost + interf.getBaseRoutingCost()};
|
|
}
|
|
}else{
|
|
this.routingTable[toID] = {interf:interf,cost:cost + interf.getBaseRoutingCost()};
|
|
Log.info("New route: " + toID + " -> " + interf.name() + ":$"+fullCost);
|
|
this.onNewNeigborTrigger.trigger(toID);
|
|
}
|
|
}
|
|
|
|
public function getIterfaceToId(networkID:NetworkID):INetworkInterface {
|
|
if (networkID == Net.instance.networkID) {
|
|
return Loopback.instance;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|