private void PingNode(ISwimNode activeNode)
{
if (activeNode == _swimProtocolProvider.Node)
{
_logger.LogWarning("Node is trying to message itself. Drop it on the floor");
return;
}
var ulid = Ulid.NewUlid();
lock (_activeNodeLock)
{
ActiveNodeData = new NodeData
{
PingCorrelationId = ulid,
ReceivedAck = false
};
}
var ping = new PingMessage(ulid)
{
SourceNode = _swimProtocolProvider.Node
};
var pingSigned = _swimProtocolProvider.SignMessage(ping);
var messages = GetBroadcastMessages().ToList();
messages.Insert(0, pingSigned);
_swimProtocolProvider.SendMessage(activeNode, messages);
}
public SwimProtocolProvider(ITorClient torClient, IOnionServiceClient onionServiceClient, ISwimNode node, ILogger <SwimProtocolProvider> logger)
{
Node = node;
_torClient = torClient;
_onionServiceClient = onionServiceClient;
_logger = logger;
}
public void SendMessage(ISwimNode dest, MessageBase message)
{
var signedMessage = SignMessage(message);
SendMessage(dest, new List <SignedSwimMessage> {
signedMessage
});
}
public void SendMessage(ISwimNode dest, CompositeMessage message)
{
_ = Task.Factory.StartNew(async() =>
{
var uri = new Uri(new Uri(dest.Endpoint), "membership/messages");
_ = await _torClient.PostAsync(uri, new StringContent(JsonConvert.SerializeObject(message), Encoding.UTF8, "application/json"), new System.Threading.CancellationToken());
});
}
public void SendMessage(ISwimNode dest, CompositeMessage message)
{
Task.Run(async() =>
{
using (HttpClient client = new HttpClient())
{
var destPublicKey = Core.API.Onion.Utilities.ConvertV3OnionHostnameToEd25518PublicKey(dest.Hostname);
var shortPub = new byte[] { destPublicKey[0], destPublicKey[0] };
var destPort = BitConverter.ToUInt16(shortPub);
client.BaseAddress = new Uri($"http://localhost:{destPort}");
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
using (var request = new HttpRequestMessage(HttpMethod.Post, "api/messages"))
{
var content = JsonConvert.SerializeObject(message, Formatting.Indented);
var buffer = Encoding.UTF8.GetBytes(content);
request.Content = new StringContent(content, Encoding.UTF8, "application/json");
try
{
Debug.WriteLine($"Sent: {content}");
using (var response = await client.SendAsync(request))
{
var stream = await response.Content.ReadAsStreamAsync();
/*
* if (response.IsSuccessStatusCode)
* {
* //var result = Util.DeserializeJsonFromStream<JObject>(stream);
* //return Task.FromResult(result).Result;
* }
*
* var contentResult = await Util.StreamToStringAsync(stream);
* throw new ApiException
* {
* StatusCode = (int)response.StatusCode,
* Content = contentResult
* };
*/
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
}
});
}
public void RemoveNode(ISwimNode node)
{
if (node == null)
{
return;
}
lock (_nodesLock)
{
var nodesFiltered = _nodes.Where(x => x.Endpoint != node.Endpoint);
_nodes = new ConcurrentQueue <ISwimNode>(nodesFiltered);
}
_nodeRepository.Delete(node);
}
public void MarkNodeSuspicious(ISwimNode node)
{
lock (_nodesLock)
{
if (node == null)
{
return;
}
var suspiciousNode = _nodes.FirstOrDefault(x => x.Endpoint == node.Endpoint);
suspiciousNode?.SetStatus(SwimNodeStatus.Suspicious);
_nodeRepository.Upsert(node);
}
}
public void AddNode(ISwimNode node)
{
if (node == null)
{
return;
}
if (node.Endpoint == _swimProtocolProvider.Node.Endpoint)
{
return;
}
lock (_nodesLock)
{
if (_nodes.All(x => x.Endpoint != node.Endpoint))
{
_nodes.Enqueue(node);
}
}
}
public SuspectMessage(Ulid correlationId, ISwimNode sourceNode, ISwimNode subjectNode) => (CorrelationId, SourceNode, SubjectNode, MessageType) = (correlationId, sourceNode, subjectNode, MessageType.Suspect);
public void SendMessage(ISwimNode dest, IEnumerable <SignedSwimMessage> messages)
{
var compositeMessage = new CompositeMessage(messages);
SendMessage(dest, compositeMessage);
}
public PingReqMessage(Ulid correlationId, ISwimNode subjectNode, ISwimNode sourceNode) => (CorrelationId, SubjectNode, SourceNode, MessageType) = (correlationId, subjectNode, sourceNode, MessageType.PingReq);
public bool Delete(ISwimNode node)
{
return(Delete(node.Hostname));
}
public bool Upsert(ISwimNode node)
{
return(_repository.Upsert(node, "nodes"));
}
public SwimProtocolProvider(ISwimNode node, ITestOutputHelper output)
{
_output = output;
Node = node;
}
public DeadMessage(Ulid correlationId, ISwimNode sourceNode, ISwimNode subjectNode) => (CorrelationId, SourceNode, SubjectNode, MessageType) = (correlationId, sourceNode, subjectNode, MessageType.Dead);
public AckMessage(Ulid correlationId, ISwimNode sourceNode) => (CorrelationId, SourceNode, MessageType) = (correlationId, sourceNode, MessageType.Ack);
public AliveMessage(Ulid correlationId, ISwimNode sourceNode, ISwimNode subjectNode) => (CorrelationId, SourceNode, SubjectNode, MessageType) = (correlationId, sourceNode, subjectNode, MessageType.Alive);
