public void Should_allocate_by_speed_post_merge() { ulong[] totalDifficulties = { 1, 3, 2 }; int[] averageSpeed = { 5, 8, 10 }; PublicKey[] publicKeys = { TestItem.PublicKeyA, TestItem.PublicKeyB, TestItem.PublicKeyC }; PeerInfo[] peers = new PeerInfo[3]; INodeStatsManager _nodeStatsManager = Substitute.For <INodeStatsManager>(); for (int i = 0; i < 3; i++) { ISyncPeer syncPeer = Substitute.For <ISyncPeer>(); syncPeer.IsInitialized.Returns(true); Node node = new Node(publicKeys[i], "192.168.1.18", i); syncPeer.Node.Returns(node); syncPeer.TotalDifficulty.Returns(new UInt256(totalDifficulties[i])); peers[i] = new PeerInfo(syncPeer); peers[i].HeadNumber.Returns(1); INodeStats nodeStats = Substitute.For <INodeStats>(); nodeStats.GetAverageTransferSpeed(Arg.Any <TransferSpeedType>()).Returns(averageSpeed[i]); _nodeStatsManager.GetOrAdd(peers[i].SyncPeer.Node).Returns(nodeStats); } IPoSSwitcher poSSwitcher = Substitute.For <IPoSSwitcher>(); poSSwitcher.TerminalTotalDifficulty.Returns(new UInt256(1)); poSSwitcher.HasEverReachedTerminalBlock().Returns(true); IBeaconPivot beaconPivot = Substitute.For <IBeaconPivot>(); IPeerAllocationStrategy mergePeerAllocationStrategy = (new MergeBlocksSyncPeerAllocationStrategyFactory(poSSwitcher, beaconPivot, Substitute.For <ILogManager>())).Create(new BlocksRequest()); IBlockTree _blockTree = Substitute.For <IBlockTree>(); PeerInfo? info = mergePeerAllocationStrategy.Allocate(null, peers, _nodeStatsManager, _blockTree); Assert.AreEqual(info, peers[2]); // peer with highest highest speed }
public Persister ReadPersist(PeerInfo peer) { lock (_lockObject) { return(Peer.MyState.PersistedStates.FirstOrDefault(p => p.Key == peer.Id).Value); } }
protected override async Task Dispatch( PeerInfo peerInfo, HeadersSyncBatch batch, CancellationToken cancellationToken) { ISyncPeer peer = peerInfo.SyncPeer; batch.ResponseSourcePeer = peerInfo; batch.MarkSent(); try { batch.Response = await peer.GetBlockHeaders(batch.StartNumber, batch.RequestSize, 0, cancellationToken); } catch (TimeoutException) { if (Logger.IsDebug) { Logger.Debug($"{batch} - request block header timeout {batch.RequestTime:F2}"); } return; } if (batch.RequestTime > 1000) { if (Logger.IsDebug) { Logger.Debug($"{batch} - peer is slow {batch.RequestTime:F2}"); } } }
public void Persist(PeerInfo peer) { lock (_lockObject) { Peer.MyState.PersistedStates[peer.Id] = peer.PersistedState; } }
protected override async Task Dispatch(PeerInfo peerInfo, BodiesSyncBatch batch, CancellationToken cancellationToken) { ISyncPeer peer = peerInfo.SyncPeer; batch.ResponseSourcePeer = peerInfo; batch.MarkSent(); var hashes = batch.Infos.Where(i => i != null).Select(i => i !.BlockHash).ToArray(); Task <BlockBody[]> getBodiesTask = peer.GetBlockBodies(hashes, cancellationToken); await getBodiesTask.ContinueWith( (t, state) => { BodiesSyncBatch batchLocal = (BodiesSyncBatch)state !; if (t.IsCompletedSuccessfully) { if (batchLocal.RequestTime > 1000) { if (Logger.IsDebug) { Logger.Debug($"{batchLocal} - peer is slow {batchLocal.RequestTime:F2}"); } } batchLocal.Response = t.Result; } }, batch); }
public void onReceiveClosest(PeerInfo pInfo) { if (mCurrentTargetGUID != pInfo.getGUID && mPreviousGUID != pInfo.getGUID) { mPreviousGUID = pInfo.getGUID; IPEndPoint remotePoint = new IPEndPoint(IPAddress.Parse(pInfo.getIP()), pInfo.getPORT()); UDPResponder responder = new UDPResponder(remotePoint, mOwner.getRoutingTable.MyInfo.getPORT()); responder.sendRequestClosest(mOwner.getGUID, mCurrentTargetGUID); } else { if (mCurrentTargetGUID != pInfo.getGUID) { //IPEndPoint remotePoint = new IPEndPoint(IPAddress.Parse(pInfo.getIP()), pInfo.getPORT()); //UDPResponder responder = new UDPResponder(remotePoint, mOwner.getRoutingTable.MyInfo.getPORT()); //responder.sendRequestJoin(mCurrentTargetGUID, mOwner.getRoutingTable.MyInfo); mOwner.addPeerInfo(pInfo); } else { //IPEndPoint remotePoint = new IPEndPoint(IPAddress.Parse(pInfo.getIP()), pInfo.getPORT()); //UDPResponder responder = new UDPResponder(remotePoint, mOwner.getRoutingTable.MyInfo.getPORT()); //responder.sendRequestJoin(mOwner.getRoutingTable.MyInfo.getGUID, mOwner.getRoutingTable.MyInfo); mOwner.addPeerInfo(pInfo); } } }
/// <summary> /// Searches for Bluetooth peers /// </summary> /// <param name="options"></param> public async void discoverDevices(string options) { try { PeerFinder.Start(); discoveredPeers = await PeerFinder.FindAllPeersAsync(); PeerInfo[] peerInfo = new PeerInfo[discoveredPeers.Count]; for (int i = 0; i < discoveredPeers.Count; i++) { var peer = discoveredPeers[i]; //TODO It seems PeerInformation.HostName property sometimes returns null. Check what is the cause. string hostName = peer.HostName == null ? "Unknown host" : peer.HostName.DisplayName; peerInfo[i] = new PeerInfo(peer.DisplayName, hostName); } this.DispatchCommandResult(discoveredPeers.Count > 0 ? new PluginResult(PluginResult.Status.OK, JsonHelper.Serialize(peerInfo)) : new PluginResult(PluginResult.Status.ERROR, "No devices were found")); } catch (Exception) { this.DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, "Error occurred while discovering devices")); } }
public void Can_write_report_update_with_allocations() { ISyncPeer syncPeer = Substitute.For <ISyncPeer>(); IEthSyncPeerPool syncPeerPool = Substitute.For <IEthSyncPeerPool>(); PeerInfo peer1 = new PeerInfo(syncPeer); peer1.IsInitialized = false; PeerInfo peer2 = new PeerInfo(syncPeer); peer2.IsInitialized = true; PeerInfo[] peers = new PeerInfo[] { peer1, peer2 }; syncPeerPool.PeerCount.Returns(peers.Length); syncPeerPool.AllPeers.Returns(peers); syncPeerPool.Allocations.Returns(peers.Select(p => new SyncPeerAllocation(p, "desc"))); SyncPeersReport report = new SyncPeersReport(syncPeerPool, Substitute.For <INodeStatsManager>(), NoErrorLimboLogs.Instance); report.Write(); peer1.IsInitialized = true; report.Write(); }
protected override async Task Dispatch(PeerInfo peerInfo, WitnessBlockSyncBatch request, CancellationToken cancellationToken) { ISyncPeer peer = peerInfo.SyncPeer; if (peer.TryGetSatelliteProtocol <IWitnessPeer>("wit", out var witnessProtocolHandler) && witnessProtocolHandler != null) { var getNodeDataTask = witnessProtocolHandler.GetBlockWitnessHashes(request.BlockHash, cancellationToken); await getNodeDataTask.ContinueWith( (t, state) => { if (t.IsFaulted) { if (Logger.IsTrace) { Logger.Error("DEBUG/ERROR Error after dispatching the state sync request", t.Exception); } } WitnessBlockSyncBatch batchLocal = (WitnessBlockSyncBatch)state !; if (t.IsCompletedSuccessfully) { batchLocal.Response = t.Result; } }, request, cancellationToken); } else { if (Logger.IsError) { Logger.Error($"Couldn't get witness protocol from {peer.Node}."); } } }
public async Task Can_sync_with_peer_when_it_times_out_on_full_batch() { BlockDownloader blockDownloader = new BlockDownloader(_blockTree, TestBlockValidator.AlwaysValid, TestSealValidator.AlwaysValid, NullSyncReport.Instance, new InMemoryReceiptStorage(), RopstenSpecProvider.Instance, LimboLogs.Instance); ISyncPeer syncPeer = Substitute.For <ISyncPeer>(); syncPeer.GetBlockHeaders(Arg.Any <long>(), Arg.Any <int>(), Arg.Any <int>(), Arg.Any <CancellationToken>()) .Returns(async ci => await _responseBuilder.BuildHeaderResponse(ci.ArgAt <long>(0), ci.ArgAt <int>(1), Response.AllCorrect | Response.TimeoutOnFullBatch)); syncPeer.GetBlocks(Arg.Any <IList <Keccak> >(), Arg.Any <CancellationToken>()) .Returns(ci => _responseBuilder.BuildBlocksResponse(ci.ArgAt <IList <Keccak> >(0), Response.AllCorrect | Response.TimeoutOnFullBatch)); PeerInfo peerInfo = new PeerInfo(syncPeer); peerInfo.TotalDifficulty = UInt256.MaxValue; peerInfo.HeadNumber = SyncBatchSize.Max * 2 + 32; await blockDownloader.DownloadHeaders(peerInfo, SyncModeSelector.FullSyncThreshold, CancellationToken.None).ContinueWith(t => { }); await blockDownloader.DownloadHeaders(peerInfo, SyncModeSelector.FullSyncThreshold, CancellationToken.None); Assert.AreEqual(Math.Max(0, peerInfo.HeadNumber - SyncModeSelector.FullSyncThreshold), _blockTree.BestSuggestedHeader.Number); peerInfo.HeadNumber *= 2; await blockDownloader.DownloadBlocks(peerInfo, 0, CancellationToken.None).ContinueWith(t => { }); await blockDownloader.DownloadBlocks(peerInfo, 0, CancellationToken.None); Assert.AreEqual(Math.Max(0, peerInfo.HeadNumber), _blockTree.BestSuggestedHeader.Number); }
public void Can_keep_changing_in_fast_sync() { IEthSyncPeerPool syncPeerPool = Substitute.For <IEthSyncPeerPool>(); ISyncPeer syncPeer = Substitute.For <ISyncPeer>(); syncPeer.TotalDifficultyOnSessionStart.Returns((UInt256)(1024 * 1024)); PeerInfo peerInfo1 = new PeerInfo(syncPeer) { HeadNumber = 0, IsInitialized = true }; syncPeerPool.AllPeers.Returns(new[] { peerInfo1 }); syncPeerPool.UsefulPeers.Returns(new[] { peerInfo1 }); syncPeerPool.PeerCount.Returns(1); SyncConfig syncConfig = new SyncConfig(); syncConfig.FastSync = true; ISyncProgressResolver syncProgressResolver = Substitute.For <ISyncProgressResolver>(); SyncModeSelector selector = new SyncModeSelector(syncProgressResolver, syncPeerPool, syncConfig, LimboLogs.Instance); Assert.AreEqual(SyncMode.Headers, selector.Current); (long BestRemote, long BestLocalHeader, long BestLocalFullBlock, long BestLocalState, SyncMode ExpectedState, string Description)[] states =
private static IPeer CreatePeer(string ip = NetworkTestConstants.FakeIpEndpoint) { var peerMock = new Mock <IPeer>(); var keyPair = CryptoHelper.GenerateKeyPair(); var pubkey = keyPair.PublicKey.ToHex(); var peerInfo = new PeerInfo { Pubkey = pubkey, ProtocolVersion = KernelConstants.ProtocolVersion, ConnectionTime = TimestampHelper.GetUtcNow().Seconds, IsInbound = true }; if (!IpEndpointHelper.TryParse(ip, out var endpoint)) { throw new Exception($"Endpoint {ip} could not be parsed."); } peerMock.Setup(p => p.RemoteEndpoint).Returns(endpoint); peerMock.Setup(p => p.Info).Returns(peerInfo); return(peerMock.Object); }
public async Task Throws_on_incorrect_receipts_root() { InMemoryReceiptStorage inMemoryReceiptStorage = new InMemoryReceiptStorage(); BlockDownloader blockDownloader = new BlockDownloader(_blockTree, TestBlockValidator.AlwaysValid, TestSealValidator.AlwaysValid, NullSyncReport.Instance, inMemoryReceiptStorage, RopstenSpecProvider.Instance, LimboLogs.Instance); ISyncPeer syncPeer = Substitute.For <ISyncPeer>(); Task <BlockHeader[]> buildHeadersResponse = null; syncPeer.GetBlockHeaders(Arg.Any <long>(), Arg.Any <int>(), Arg.Any <int>(), Arg.Any <CancellationToken>()) .Returns(ci => buildHeadersResponse = _responseBuilder.BuildHeaderResponse(ci.ArgAt <long>(0), ci.ArgAt <int>(1), Response.AllCorrect)); Task <BlockBody[]> buildBlocksResponse = null; syncPeer.GetBlocks(Arg.Any <IList <Keccak> >(), Arg.Any <CancellationToken>()) .Returns(ci => buildBlocksResponse = _responseBuilder.BuildBlocksResponse(ci.ArgAt <IList <Keccak> >(0), Response.AllCorrect | Response.WithTransactions)); syncPeer.GetReceipts(Arg.Any <IList <Keccak> >(), Arg.Any <CancellationToken>()) .Returns(ci => _responseBuilder.BuildReceiptsResponse(buildHeadersResponse.Result, buildBlocksResponse.Result, Response.IncorrectReceiptRoot).Result); PeerInfo peerInfo = new PeerInfo(syncPeer) { TotalDifficulty = UInt256.MaxValue, HeadNumber = 1 }; await blockDownloader.DownloadHeaders(peerInfo, SyncModeSelector.FullSyncThreshold, CancellationToken.None); peerInfo.HeadNumber *= 2; Func <Task> action = async() => await blockDownloader.DownloadBlocks(peerInfo, 0, CancellationToken.None, BlockDownloader.DownloadOptions.DownloadWithReceipts); action.Should().Throw <EthSynchronizationException>(); }
protected override async Task Dispatch( PeerInfo peerInfo, HeadersSyncBatch batch, CancellationToken cancellationToken) { ISyncPeer peer = peerInfo.SyncPeer; batch.ResponseSourcePeer = peerInfo; batch.MarkSent(); Task <BlockHeader[]> getHeadersTask = peer.GetBlockHeaders(batch.StartNumber, batch.RequestSize, 0, cancellationToken); await getHeadersTask.ContinueWith( (t, state) => { HeadersSyncBatch batchLocal = (HeadersSyncBatch)state !; if (t.IsCompletedSuccessfully) { if (batchLocal.RequestTime > 1000) { if (Logger.IsDebug) { Logger.Debug($"{batchLocal} - peer is slow {batchLocal.RequestTime:F2}"); } } batchLocal.Response = t.Result; } }, batch); }
public void Cannot_allocate_subcontext_of_sleeping() { PeerInfo peerInfo = new PeerInfo(Substitute.For <ISyncPeer>()); peerInfo.PutToSleep(AllocationContexts.Blocks, DateTime.MinValue); peerInfo.CanBeAllocated(AllocationContexts.Bodies).Should().BeFalse(); }
private void addNew(string newIP) { int port = NetworkManager.DEFAULT_PORT; string[] serverPort = newIP.Split(':'); if (serverPort.Length > 1) { ushort newPort = 0; if (ushort.TryParse(serverPort[1], out newPort)) { port = newPort; } } PeerInfo newInfo = new PeerInfo(serverPort[0], port); //bool alreadyExists = false; //foreach (ContactInfo info in DiagManager.Instance.CurSettings.ContactList) //{ // if (info.UUID == newID) // { // alreadyExists = true; // break; // } //} DiagManager.Instance.CurSettings.PeerList.Add(newInfo); DiagManager.Instance.SaveSettings(DiagManager.Instance.CurSettings); MenuManager.Instance.ReplaceMenu(new PeersMenu(action)); }
public async Task Can_cancel_adding_headers() { BlockDownloader blockDownloader = new BlockDownloader(_blockTree, new SlowHeaderValidator(), TestSealValidator.AlwaysValid, NullSyncReport.Instance, new InMemoryReceiptStorage(), RopstenSpecProvider.Instance, LimboLogs.Instance); ISyncPeer syncPeer = Substitute.For <ISyncPeer>(); syncPeer.GetBlockHeaders(Arg.Any <long>(), Arg.Any <int>(), Arg.Any <int>(), Arg.Any <CancellationToken>()) .Returns(ci => _responseBuilder.BuildHeaderResponse(ci.ArgAt <long>(0), ci.ArgAt <int>(1), Response.AllCorrect)); syncPeer.GetBlocks(Arg.Any <IList <Keccak> >(), Arg.Any <CancellationToken>()) .Returns(ci => _responseBuilder.BuildBlocksResponse(ci.ArgAt <IList <Keccak> >(0), Response.AllCorrect)); PeerInfo peerInfo = new PeerInfo(syncPeer); peerInfo.TotalDifficulty = UInt256.MaxValue; peerInfo.HeadNumber = 1000; CancellationTokenSource cancellation = new CancellationTokenSource(); cancellation.CancelAfter(1000); Task task = blockDownloader.DownloadHeaders(peerInfo, SyncModeSelector.FullSyncThreshold, cancellation.Token); await task.ContinueWith(t => Assert.True(t.IsCanceled, "headers")); peerInfo.HeadNumber *= 2; cancellation = new CancellationTokenSource(); cancellation.CancelAfter(1000); task = blockDownloader.DownloadHeaders(peerInfo, SyncModeSelector.FullSyncThreshold, cancellation.Token); await task.ContinueWith(t => Assert.True(t.IsCanceled, "blocks")); }
protected override async Task Dispatch( PeerInfo bestPeer, BlocksRequest?blocksRequest, CancellationToken cancellation) { if (blocksRequest == null) { if (Logger.IsWarn) { Logger.Warn($"NULL received for dispatch in {nameof(BlockDownloader)}"); } return; } if (!_blockTree.CanAcceptNewBlocks) { return; } CancellationTokenSource linkedCancellation = CancellationTokenSource.CreateLinkedTokenSource( cancellation, _allocationWithCancellation.Cancellation.Token); try { SyncEvent?.Invoke(this, new SyncEventArgs(bestPeer.SyncPeer, Synchronization.SyncEvent.Started)); if ((blocksRequest.Options & DownloaderOptions.WithBodies) == DownloaderOptions.WithBodies) { if (Logger.IsDebug) { Logger.Debug("Downloading bodies"); } await DownloadBlocks(bestPeer, blocksRequest, linkedCancellation.Token).ContinueWith(t => HandleSyncRequestResult(t, bestPeer)); if (Logger.IsDebug) { Logger.Debug("Finished downloading bodies"); } } else { if (Logger.IsDebug) { Logger.Debug("Downloading headers"); } await DownloadHeaders(bestPeer, blocksRequest, linkedCancellation.Token).ContinueWith(t => HandleSyncRequestResult(t, bestPeer)); if (Logger.IsDebug) { Logger.Debug("Finished downloading headers"); } } } finally { _allocationWithCancellation.Dispose(); linkedCancellation.Dispose(); } }
private void btnBootstrap_Click(object sender, EventArgs e) { PeerInfo peer1 = new PeerInfo(); peer1.Id = PeerId.CalculateId("peer1"); peer1.EndPoint = new IPEndPoint(GetHostAddresses(txtBootstrapIP.Text), Convert.ToInt32(txtPort.Text)); client.BootstrapPeers.Add(peer1); }
public void SyncWithPeer(PeerInfo peerIp, int timeout) { _syncer = new Syncer(Id); _remoteEndpoint = _syncer.SyncWithPeer(peerIp, timeout, _udpClient); _peer = peerIp; IsTunnelEstablished = true; StartPinger(); }
void OnDeletedPeer(PeerInfo peer) { if (peers.Contains(peer)) { peers.Remove(peer); } this.Invoke(new dgvUpdate(ReBindDataSource)); }
public void WaitForSyncFromPeer(PeerInfo peerIp, int timeout) { _syncer = new Syncer(Id); _remoteEndpoint = _syncer.WaitForSyncFromPeer(peerIp, timeout, _udpClient); _peer = peerIp; IsTunnelEstablished = true; StartCheckerForPings(); }
public PeerFileSlice(string fileName, PeerInfo owner, int startIndex, int endIndex, byte[] fileSlice) { Name = fileName; Owner = owner; this.StartIndex = startIndex; this.EndIndex = endIndex; Slice = fileSlice; }
public void ConnectToPeer(PeerInfo peerInfo) { // Called by ReconnectToPeer and Setup in PhotonApplication if (Server.ConnectToServerTcp(peerInfo.MasterEndPoint, "Master", peerInfo) == false) { Log.Warn("Connection refused"); } }
public void ReconnectToPeer(PeerInfo peerInfo) { peerInfo.NumTries++; if (peerInfo.NumTries < peerInfo.MaxTries) { var timer = new Timer(o => ConnectToPeer(peerInfo), null, peerInfo.ConnectRetryIntervalSeconds * 1000, 0); } }
public OutboundPhotonPeer(PhotonApplication application , PeerInfo peerInfo) : base(application) { _application = application; _peerInfo = peerInfo; SetPrivateCustomTypeCache(new TypeCache().GetCache()); }
private static PeerInfo BuildPeer(bool initialized) { ISyncPeer syncPeer = Substitute.For <ISyncPeer>(); PeerInfo peer = new PeerInfo(syncPeer); syncPeer.IsInitialized.Returns(initialized); return(peer); }
public PeerInfo Allocate(PeerInfo currentPeer, IEnumerable <PeerInfo> peers, INodeStatsManager nodeStatsManager, IBlockTree blockTree) { IPeerAllocationStrategy strategy = _priority ? _fastest : _slowest; peers = _minNumber == null ? peers : peers.Where(p => p.HeadNumber > _minNumber); PeerInfo allocated = strategy.Allocate(currentPeer, peers, nodeStatsManager, blockTree); return(allocated); }
/// <summary> /// Do connect to the peer. /// </summary> /// <param name="peerInfo">MGF.Implementation.PeerInfo.</param> public void ConnectToPeer(PeerInfo peerInfo) { var outbound = new OutboundPhotonPeer(Server, peerInfo); if (outbound.ConnectTcp(peerInfo.MasterEndPoint, peerInfo.ApplicationName, TypeCache.SerializePeerInfo(peerInfo)) == false) { Log.Warn("Connection refused"); } }
public void Can_allocate() { PeerInfo peerInfo = new PeerInfo(Substitute.For <ISyncPeer>()); peerInfo.IsAllocated(_contexts).Should().BeFalse(); peerInfo.TryAllocate(_contexts); peerInfo.IsAllocated(_contexts).Should().BeTrue(); peerInfo.CanBeAllocated(_contexts).Should().BeFalse(); }
public static IPeer CreateFromPeerInfo(PeerInfo info) { using (info) { return new Peer { EndPoint = info.EndPoint.ToString() }; } }
private void _listener_ReceivedPeerInfo(IPEndPoint peerEP, byte[] challenge, BinaryID recvHMAC, bool isReply) { if (PeerDiscovered != null) { BinaryID foundNetworkID = null; lock (_trackedNetworkIDs) { foreach (BinaryID networkID in _trackedNetworkIDs) { using (HMACSHA256 hmacSHA256 = new HMACSHA256(networkID.ID)) { BinaryID computedHmac = new BinaryID(hmacSHA256.ComputeHash(challenge)); if (computedHmac.Equals(recvHMAC)) { foundNetworkID = networkID; break; } } } } if (foundNetworkID != null) { PeerInfo peerInfo = new PeerInfo(peerEP, foundNetworkID); bool peerInCache; if (_peerInfoCache.Contains(peerInfo)) { PeerInfo existingPeerInfo = _peerInfoCache[_peerInfoCache.IndexOf(peerInfo)]; if (existingPeerInfo.IsExpired()) { peerInCache = false; _peerInfoCache.Remove(existingPeerInfo); } else { peerInCache = true; } } else { peerInCache = false; } if (!peerInCache) { _peerInfoCache.Add(peerInfo); PeerDiscovered(this, peerEP, foundNetworkID); } if (!isReply) ThreadPool.QueueUserWorkItem(AnnounceAsync, new object[] { foundNetworkID, new IPAddress[] { peerEP.Address }, 1, true }); } } }
static DataGridViewRow GetPeerListRow(PeerInfo peer) { DataGridViewRow row = new DataGridViewRow(); DataGridViewTextBoxCell cellHost = new DataGridViewTextBoxCell(); DataGridViewTextBoxCell cellPort = new DataGridViewTextBoxCell(); DataGridViewTextBoxCell cellShare = new DataGridViewTextBoxCell(); cellHost.Value = peer.Host; cellPort.Value = peer.Port; cellShare.Value = peer.Share; row.Cells.Add(cellHost); row.Cells.Add(cellPort); row.Cells.Add(cellShare); row.Tag = peer; return row; }
/// <summary> /// Searches for Bluetooth peers /// </summary> /// <param name="options"></param> public async void discoverDevices(string options) { try { discoveredPeers = await PeerFinder.FindAllPeersAsync(); PeerInfo[] peerInfo = new PeerInfo[discoveredPeers.Count]; for (int i = 0; i < discoveredPeers.Count; i++) { var peer = discoveredPeers[i]; //TODO It seems PeerInformation.HostName property sometimes returns null. Check what is the cause. string hostName = peer.HostName == null ? "Unknown host" : peer.HostName.DisplayName; peerInfo[i] = new PeerInfo(peer.DisplayName, hostName); } this.DispatchCommandResult(discoveredPeers.Count > 0 ? new PluginResult(PluginResult.Status.OK, JsonHelper.Serialize(peerInfo)) : new PluginResult(PluginResult.Status.ERROR, "No devices were found")); } catch (Exception) { this.DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, "Error occurred while discovering devices")); } }
public bool Equals(PeerInfo obj) { if (ReferenceEquals(null, obj)) return false; if (ReferenceEquals(this, obj)) return true; if (!_peerEP.Equals(obj._peerEP)) return false; if (!_networkID.Equals(obj._networkID)) return false; return true; }