/// <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();
}
