void OnServiceInstanceDiscovered(object sender, ServiceInstanceDiscoveryEventArgs e)
{
try
{
var msg = e.Message;
// Is it our service?
var qsn = ServiceName + ".local";
if (!e.ServiceInstanceName.EndsWith(qsn))
{
return;
}
var addresses = GetAddresses(msg)
.Where(a => a.PeerId != LocalPeer.Id)
.ToArray();
if (addresses.Length > 0)
{
PeerDiscovered?.Invoke(this, new Peer {
Id = addresses[0].PeerId, Addresses = addresses
});
}
}
catch (Exception ex)
{
log.Error("OnServiceInstanceDiscovered error", ex);
// eat it
}
}
/// <inheritdoc />
public Task StartAsync()
{
_log.Debug("Starting");
if (Addresses == null)
{
_log.Warn("No bootstrap addresses");
return(Task.CompletedTask);
}
var peers = Addresses
.Where(a => a.HasPeerId)
.GroupBy(
a => a.PeerId,
a => a,
(key, g) => new Peer {
Id = key, Addresses = g.ToList()
});
foreach (var peer in peers)
{
try
{
PeerDiscovered?.Invoke(this, peer);
}
catch (Exception e)
{
_log.Error(e);
}
}
return(Task.CompletedTask);
}
/// <summary>
/// Register that a peer has been discovered.
/// </summary>
/// <param name="peer">
/// The newly discovered peer.
/// </param>
/// <returns>
/// The registered peer.
/// </returns>
/// <remarks>
/// If the peer already exists, then the existing peer is updated with supplied
/// information and is then returned. Otherwise, the <paramref name="peer"/>
/// is added to known peers and is returned.
/// <para>
/// If the peer already exists, then a union of the existing and new addresses
/// is used. For all other information the <paramref name="peer"/>'s information
/// is used if not <b>null</b>.
/// </para>
/// <para>
/// If peer does not already exist, then the <see cref="PeerDiscovered"/> event
/// is raised.
/// </para>
/// </remarks>
public Peer RegisterPeer(Peer peer)
{
if (peer.Id == null)
{
throw new ArgumentNullException("peer.ID");
}
if (peer.Id == LocalPeer.Id)
{
throw new ArgumentException("Cannot register self.");
}
var isNew = false;
var p = otherPeers.AddOrUpdate(peer.Id.ToBase58(),
(id) =>
{
isNew = true;
return(peer);
},
(id, existing) =>
{
if (!Object.ReferenceEquals(existing, peer))
{
existing.AgentVersion = peer.AgentVersion ?? existing.AgentVersion;
existing.ProtocolVersion = peer.ProtocolVersion ?? existing.ProtocolVersion;
existing.PublicKey = peer.PublicKey ?? existing.PublicKey;
existing.Latency = peer.Latency ?? existing.Latency;
existing.Addresses = existing
.Addresses
.Union(peer.Addresses)
.ToList();
}
return(existing);
});
if (isNew)
{
if (log.IsDebugEnabled)
{
log.Debug($"New peer registerd {p}");
foreach (var a in p.Addresses)
{
log.Debug($" at {a}");
}
}
PeerDiscovered?.Invoke(this, p);
}
return(p);
}
/// <summary>
/// Register that a peer's address has been discovered.
/// </summary>
/// <param name="address">
/// An address to the peer. It must end with the peer ID.
/// </param>
/// <param name="cancel">
/// Is used to stop the task. When cancelled, the <see cref="TaskCanceledException"/> is raised.
/// </param>
/// <returns>
/// A task that represents the asynchronous operation. The task's result
/// is the <see cref="Peer"/> that is registered.
/// </returns>
/// <exception cref="Exception">
/// The <see cref="BlackList"/> or <see cref="WhiteList"/> policies forbid it.
/// Or the "p2p/ipfs" protocol name is missing.
/// </exception>
/// <remarks>
/// If the <paramref name="address"/> is not already known, then it is
/// added to the <see cref="KnownPeerAddresses"/>.
/// </remarks>
public async Task <Peer> RegisterPeerAsync(MultiAddress address, CancellationToken cancel = default(CancellationToken))
{
var peerId = address.PeerId;
if (peerId == LocalPeer.Id)
{
throw new Exception("Cannot register to self.");
}
if (!await IsAllowedAsync(address, cancel))
{
throw new Exception($"Communication with '{address}' is not allowed.");
}
var isNew = false;
var p = otherPeers.AddOrUpdate(peerId.ToBase58(),
(id) => {
log.Debug("new peer " + peerId);
isNew = true;
return(new Peer
{
Id = id,
Addresses = new List <MultiAddress> {
address
}
});
},
(id, peer) =>
{
peer.Addresses = peer.Addresses.ToList();
var addrs = (List <MultiAddress>)peer.Addresses;
if (!addrs.Contains(address))
{
addrs.Add(address);
}
return(peer);
});
if (isNew)
{
PeerDiscovered?.Invoke(this, p);
}
return(p);
}
void OnServiceInstanceDiscovered(object sender, ServiceInstanceDiscoveryEventArgs e)
{
var msg = e.Message;
// Is it our service?
var qsn = ServiceName + ".local";
if (!e.ServiceInstanceName.EndsWith(qsn))
{
return;
}
foreach (var address in GetAddresses(msg))
{
if (LocalPeer.Id == address.PeerId)
{
continue;
}
PeerDiscovered?.Invoke(this, new PeerDiscoveredEventArgs {
Address = address
});
}
}
void OnPeerDiscovered(PeerDiscoveredEventArgs e)
{
PeerDiscovered?.Invoke(this, e);
}
private unsafe void DiscoveredPeerHandler(byte *peerUtf8Ptr, int peerLength)
{
ReadOnlySpan <byte> peerUtf8 = new ReadOnlySpan <byte>(peerUtf8Ptr, peerLength);
PeerDiscovered?.Invoke(peerUtf8);
}
