/// <summary> /// when receiving a message /// </summary> /// <param name="msg"></param> internal void ReceiveMessageAsync(NodeBind src, Message msg, Route route) { // callback message sent msg.ReceiveCallback(this, route, src); // metemos el mensaje en la cola local de eventos localEvents.RaiseEvent(0, msg); }
/// <summary> /// send message to other node /// </summary> /// <param name="msg"></param> /// <param name="dest"></param> /// <param name="callback"></param> internal void SendMessageAsync(NodeBind dest, Message msg, RouteContCallback callback) { // tasks before sending msg.MessageSourceHook(this); // send by wire mailboxOut.BeginSend(localBind, dest, msg, callback); }
/// <summary> /// cada vez que llega un mensaje /// </summary> /// <param name="localNode"></param> /// <param name="src"></param> public virtual void ReceiveCallback(Node localNode, Route route, NodeBind src) { // marcamos el local endpoint del mensaje src.NodeAddress = route.remoteNodeAddress; // vincular un identificador a una ruta localNode.RouteTable.LinkRoute(route, src.NodeId); }
/// <summary> /// After each time DodoNet tries to send this message to another node, /// this callback notifies the message whether the send was successful or not. /// </summary> public virtual void SendCallback(Node localNode, Route route, NodeBind dest, bool success, Exception exception) { this.success = success; this.exception = exception; this.retryCount++; if (dest.NodeId != null) { if (success) { localNode.RouteTable.LinkRoute(route, dest.NodeId); } else { // borramos la entrada en el directorio de direcciones si // tiene identificador de nodo, se ha intentado enviar // el mensaje pero no ha podido if (dest.NodeId != null) { localNode.Directory.RemoveEntryInner(dest.NodeId); } localNode.RouteTable.UnlinkRoute(route, dest.NodeId); localNode.Directory.MarkLikeRoutedDestiny(dest.NodeId); } } }
/// <summary> /// buscar una ruta a partir del identificador remoto del nodo al que pertenece /// </summary> /// <param name="nodeId"></param> /// <returns></returns> public Route SearchRoute(NodeBind remoteNodeBind) { Route ret = null; try { // si existe nodeAddress if (remoteNodeBind.NodeAddress != null) { ret = SearchRoute(remoteNodeBind.NodeAddress); } if (ret == null) { KeyRoutePair key = null; if (tableNodeId.TryGetValue(remoteNodeBind.NodeId, out key)) { table.TryGetValue(key, out ret); } } } catch (Exception err) { Node.LogAppendLine("GetRoute: " + err.Message); } return(ret); }
internal SendItemThread(NodeBind source, NodeBind dest, Message msg, RouteContCallback cb) { this.source = source; this.dest = dest; this.msg = msg; this.cb = cb; }
public void BeginSend(NodeBind source, NodeBind dest, Message msg, RouteContCallback cb) { wgSendFrames.QueueWorkItem(new WorkItemCallback(BeginSend_tt), (object)new SendItemThread(source, dest, msg, cb), WorkItemPriority.Normal); //-- BeginSend_tt((object)new SendItemThread(source, dest, msg, cb)); }
public Node() { var nodeAddress = new NodeAddress(); var nodeId = new NodeId(); localBind = new NodeBind(nodeId, nodeAddress); _Initialize(); }
public OverlayReply SendRequest(OverlayRequest request, NodeBind dest) { OverlayReply ret = null; RequestAsyncResult rar = BeginSendRequest(request, dest, null, null) as RequestAsyncResult; rar.AsyncWaitHandle.WaitOne(2000); ret = rar.Reply; return(ret); }
/// <summary> /// resuelve un nombre, se le pasa un objeto NodeBind sin direccion /// física y devuelve la dirección física correspondiente con el nodeId /// del objeto NodeBind pasado /// </summary> /// <param name="nodeId"></param> /// <returns></returns> public NodeBind Resolve(NodeId nodeId) { NodeBind ret = null; try { if (tableInner.ContainsKey(nodeId)) { DirectoryEntry entry = new DirectoryEntry(); if (tableInner.TryGetValue(nodeId, out entry)) { if (entry.RoutedBySeed) { ret = entry.SeedBind; } else { ret = entry.NodeBind; } } } else if (localNode.Sessions.ExistsByNodeId(nodeId)) { // buscamos en las sesiones propias y sino en las resoluciones propias ISessionRequest session = localNode.Sessions.GetSession(nodeId); ret = session.NodeBindApplicant; } else { // ISessionRequest[] seeds = localNode.Seeds.CloneArray(); // foreach (ISessionRequest seed in seeds) // IEnumerator<KeyValuePair<string, ISessionRequest>> seed = localNode.Seeds.GetArray(); foreach (ISessionRequest seed in localNode.Seeds.GetArray()) { ResolveRequest rreq = new ResolveRequest(nodeId, localNode); ResolveReply reply = (ResolveReply)localNode.SendRequest(rreq, seed.NodeBindRemote); if (reply != null) { if (reply.resolvedOk) { DirectoryEntry entry = new DirectoryEntry(seed.NodeBindRemote, reply.resolvedNodeBind); localNode.Directory.AddEntryInner(entry); ret = reply.resolvedNodeBind; } } } } } catch (Exception e) { Node.LogAppendLine(e); } return(ret); }
internal bool NodeFailed(NodeBind nodeFailed) { bool ret = false; try { ret |= directory.NodeFailed(nodeFailed); } catch { } return(ret); }
public override void SendCallback(Node localNode, Route route, NodeBind dest, bool success, Exception exception) { if (Payload is HttpRequest) { localNode.RequestReplyWebTable.Enqueue(route, this); } if (CloseConnection) { localNode.RouteTable.RemoveRoute(route); } }
public override bool Equals(object obj) { bool ret = false; NodeBind tmp = obj as NodeBind; if (tmp != null) { ret = NodeAddress == tmp.NodeAddress; ret |= NodeId == tmp.NodeId; } return(ret); }
/// <summary> /// Busca la dirección correspondiente al identificador pedido, suele ser una /// peticion externa /// </summary> /// <param name="nodeId"></param> /// <returns></returns> public NodeBind ResolveOuter(NodeId nodeId) { NodeBind ret = null; try { ret = Resolve(nodeId); } catch (Exception e) { Console.WriteLine("Error en ResolveOuter {0}", e.Message); } return(ret); }
public void SendReply(OverlayReply reply, NodeBind dest) { numSentReply++; RequestReplyTable.AddReply(dest, reply); // create transporter message var m = new DodoMessage(reply) { Source = localBind, Destiny = dest }; // put in wire ResumeRouting(m); }
public IAsyncResult BeginSendRequest(OverlayRequest request, NodeBind dest, AsyncCallback callback, object state) { request.Async = new RequestAsyncResult(request, callback, state); // create transporter message var m = new DodoMessage(request) { Source = localBind, Destiny = dest }; ResumeRouting(m); return((IAsyncResult)request.Async); }
public void SendReply(HttpReply reply, NodeBind dest, bool closeConnection) { numSentReply++; RequestReplyTable.AddReply(dest, reply); WebMessage m = new WebMessage() { Source = localBind, Destiny = dest, Payload = reply, CloseConnection = closeConnection }; // put in wire ResumeRouting(m); }
/// <summary> /// fallo en el nodo siguiente /// </summary> /// <param name="nodeBind"></param> /// <returns></returns> public bool NodeFailed(NodeBind nodeFailed) { bool ret = false; try { lock (sync) { ret = tableInner.Remove(nodeFailed.NodeId); } } catch (Exception err) { Node.LogAppendLine(err); } return(ret); }
public override void ArrivedAtDestination(Node overlayNode, Message msg) { ResolveReply reply = new ResolveReply(this); NodeBind nodeBind = overlayNode.Directory.ResolveOuter(requestNodeId); if (nodeBind != null) { reply.resolvedNodeBind = nodeBind; reply.resolvedOk = true; } else { reply.resolvedOk = false; } overlayNode.SendReply(reply, msg.Source); }
public override void ReceiveCallback(Node localNode, Route route, NodeBind src) { if (Payload is HttpReply) { var reply = (HttpReply)Payload; var msg = localNode.RequestReplyWebTable.Dequeue(route); var request = (HttpRequest)msg.Payload; reply.Request = request; switch (reply.Code) { case Codes.TEMPORARY_REDIRECT: request.Url = reply.Location; localNode.ResumeRouting(msg); // desechamos este mensaje directamente Dispose(); break; } } }
public IAsyncResult BeginSendRequest(HttpRequest request, AsyncCallback callback, object state) { var dest = new NodeBind(request.Url); request.Async = new RequestAsyncResult(request, callback, state); // create transporter message var m = new WebMessage() { Source = localBind, Destiny = dest, CloseConnection = false }; m.Payload = request; ResumeRouting(m); return((IAsyncResult)request.Async); }
/// <summary> /// mandar keepalive /// </summary> /// <param name="dest"></param> internal object BeginSendKeepAlive_tt(object state) { bool success = true; Route route = null; Exception exception = null; // recoger argumentos object[] states = state as object[]; NodeBind source = states[0] as NodeBind; NodeBind dest = states[1] as NodeBind; SendCtrlCallback cb = states[2] as SendCtrlCallback; try { route = localNode.RouteTable.GetRoute(dest.NodeAddress); Packet packet = new Packet(TypePacket.KeepAlive); AddPacketQueueOut(route, packet, true); } catch (Exception err) { exception = err; success = false; // llamamos al método para // localNode.NodeFailed(dest); } finally { try { // llamamos al callback if (cb != null) { cb(route, success, exception); } } catch { } } return(null); }
/// <summary> /// destino para enrutar /// </summary> /// <returns></returns> public NodeBind ResolveByRoute(NodeId nodeId) { NodeBind ret = null; try { DirectoryEntry entry = new DirectoryEntry(); if (tableInner.TryGetValue(nodeId, out entry)) { ret = entry.SeedBind; } else { foreach (ISessionRequest s in localNode.Seeds.GetArray()) { ret = s.NodeBindRemote; break; } } } catch { } return(ret); }
public DirectoryEntry(NodeBind seedBind, NodeBind nodeBind) { this.seedBind = seedBind; this.nodeBind = nodeBind; }
public SessionReply InitializeSession(SessionRequest session, NodeBind dest) { return(null); }
public override void Deserialization(Node localNode, Route route, IHttpMessage httpMessage) { Source = new NodeBind(null, route.remoteNodeAddress); Destiny = localNode.localBind; Payload = (OverlayMessage)httpMessage; }
// Add a node to the message path public void AddToPath(NodeBind nextHop) { Path += nextHop + ", "; }
/// <summary> /// mandar keep-alive para verificar si la sesión esta conectada al seed /// </summary> /// <param name="dest"></param> /// <param name="auth"></param> public void SendKeepAlive(NodeBind dest, string auth) { }
/// <summary> /// mandar keepalive a una dirección física /// </summary> /// <param name="dest"></param> public void SendKeepAlive(NodeBind dest) { }
public Node(NodeBind localBind) { this.localBind = localBind; _Initialize(); }