public bool Connect() { // Create a client peer to connect to remote system. The messages // will be matched using fields 41 and 11. if (_clientPeer == null) { _clientPeer = new ClientPeer(Client_NAME, new TwoBytesNboHeaderChannel( new Iso8583Ascii1987BinaryBitmapMessageFormatter(), _hostname, _port), new BasicMessagesIdentifier(FieldNos.F11_Trace)); } _clientPeer.Connect(); Thread.Sleep(1000); int retries = 0; while (retries < maxNoRetries) { lock (this) { if (_clientPeer.IsConnected) { break; } else { _clientPeer.Close(); retries++; _clientPeer.Connect(); } } Thread.Sleep(1000); } return(_clientPeer.IsConnected); }
async Task CreatePeer(IPAddress iPAddress) { var peer = new Peer(Blockchain, iPAddress); try { await peer.Connect(Port); } catch (Exception ex) { string.Format( "Exception {0} when connecting with peer {1}: \n{2}", ex.GetType(), peer.GetID(), ex.Message) .Log(LogFile); peer.FlagDispose = true; } lock (LOCK_Peers) { Peers.Add(peer); } }
public static void Run(string[] args) { Link.RequestCompleted += Link_RequestCompleted; Link.RequestErrored += Link_RequestErrored; if (args.Length > 0) { Callsign = args[0]; } GetList(Callsign, args.Length > 1 ? args[1] : string.Empty); RegisterHandlers(); client = new Peer(); client.MessageReceived += Client_HostMessageReceived; client.TCPConnected += Client_TCPConnected; var server = Link.FindServerWithMostPlayers(); if (server == null || false) { server = new GameList.ListServerData("bzflag.allejo.io", 5170); } client.Connect(server.Host, server.Port); WriteLine("Connecting to " + server.Name); while (true) { client.Update(); Thread.Sleep(100); } }
public Test() { this.thread = new JobProcessor(); this.thread.Start(); this.host1 = new Acceptor(this.thread); this.host2 = new Acceptor(this.thread); this.host2.OnAccepted += delegate(Peer peer) { peer.PipeOpen += delegate(Peer _, Pipe pipe) { pipe.PacketReceived += delegate(Packet packet) { Log <Test> .Logger.DebugFormat("receive {0}", packet.Length); }; }; }; this.host1.Start(10000); this.host2.Start(10001); Peer peer2 = Peer.CreateClient(this.host1, new TcpClient()); peer2.Connected += delegate(Peer peer) { peer.InitPipe().SendPacket(SerializeWriter.ToBinary <Test.TestMessage>(new Test.TestMessage { Y = "asd" })); }; peer2.Connect(new IPEndPoint(IPAddress.Loopback, 10001)); }
//--------------------------------------------------------------------- #endregion // DirectPlay Lobby Event Handlers /// <summary> /// Host or connect to a session based on the settings provided by the lobby /// </summary> public void LobbyLaunch() { // Create an object to retrieve the connection settings from the lobby client Lobby.ConnectionSettings settings; try { // Get settings settings = m_LobbyApp.GetConnectionSettings(m_LobbyHandle); m_SessionName = settings.ApplicationDescriptionChanged.SessionName; // If host flag is set, this application should create a new session if (0 != (settings.Flags & Lobby.ConnectionSettingsFlags.Host)) { // Host a new session m_Peer.Host(settings.ApplicationDescriptionChanged, // Application description settings.GetDeviceAddresses()); // Local device addresses // After the connection is complete, initialize a new // DirectPlay voice server. m_Connection = ConnectionType.Hosting; InitDirectPlayVoice(); } else { // Connect to an existing session m_Peer.Connect(settings.ApplicationDescriptionChanged, // Application description settings.HostAddress, // Host address settings.GetDeviceAddresses()[0], // Local device address null, // Async handle ConnectFlags.Sync); // Connect flags // After the connection is complete, initialize a new // DirectPlay voice client. m_Connection = ConnectionType.Connected; InitDirectPlayVoice(); } } catch (Exception ex) { m_Form.ShowException(ex, null, true); m_Form.Dispose(); return; } UpdateUI(); }
/// <summary> /// Do connect to server. /// </summary> /// <param name="serverAddress">Server Address. PhotonEngine.ServerAddress.</param> /// <param name="applicationName">Application Name. PhotonEngine.ApplicationName.</param> public void ConnectToServer(string serverAddress, string applicationName) { if (State == EngineState.DisconnectedState) { Peer.Connect(serverAddress, applicationName); State = EngineState.WaitingToConnectState; } }
private static void Connect(string nodeIp, string nodePort) { if (string.IsNullOrEmpty(nodeIp) || string.IsNullOrEmpty(nodePort)) { throw new ArgumentException($"Invalid host or ip"); } peer.Connect(nodeIp, int.Parse(nodePort)); }
public static Iso8583Message SendMessageToFEP(Peer peer, Iso8583Message msg) { if (msg == null) { MessageLogger.LogMessage("iso Message is null"); SetReponseMessage(msg, ResponseCode.INVALID_RESPONSE.ToString()); } int maxRetries = 3; int numberOfRetries = 1; while (numberOfRetries < maxRetries) { if (peer.IsConnected) { break; } peer.Close(); numberOfRetries++; peer.Connect(); Thread.Sleep(2000); } if (peer.IsConnected) { try { var request = new PeerRequest(peer, msg); request.Send(); //At this point, the message has been sent to the SINK for processing int serverTimeout = 60000; //60 secs request.WaitResponse(serverTimeout); if (request.Expired) { MessageLogger.LogMessage("Connection timeout."); return(SetReponseMessage(msg, ResponseCode.ISSUER_OR_SWITCH_INOPERATIVE)); //Response received too late } var response = request.ResponseMessage; return(response as Iso8583Message); } catch (Exception ex) { MessageLogger.LogError("Error sending message: " + ex.Message); return(SetReponseMessage(msg, ResponseCode.ERROR)); } } else { MessageLogger.LogMessage("\n Could not connect to the Sink Node."); return(SetReponseMessage(msg, ResponseCode.ISSUER_OR_SWITCH_INOPERATIVE.ToString())); //Issuer inoperative } }
public static bool Connect(string host) { var ret = peer.Connect(host, Server.GamePort); if (ret != ConnectAttemptResult.OK) { MessageBox.Show("Could not connect to " + host + ": " + ret.ToString(), ":(", MessageBoxButtons.OK, MessageBoxIcon.Warning); } return(ret == ConnectAttemptResult.OK); }
/// <summary> /// Host or connect to a session based on the settings provided by the lobby /// </summary> public void LobbyLaunch() { // Create an object to retrieve the connection settings from the lobby client Lobby.ConnectionSettings settings; try { // Get settings settings = myLobbyApp.GetConnectionSettings(myLobbyHandle); sessionName = settings.ApplicationDescriptionChanged.SessionName; // If host flag is set, this application should create a new session if (0 != (settings.Flags & Lobby.ConnectionSettingsFlags.Host)) { // Host a new session myPeer.Host(settings.ApplicationDescriptionChanged, // Application description settings.GetDeviceAddresses()); // Local device addresses myConnection = ConnectionType.Hosting; } else { // Connect to an existing session myPeer.Connect(settings.ApplicationDescriptionChanged, // Application description settings.HostAddress, // Host address settings.GetDeviceAddresses()[0], // Local device address null, // Async handle ConnectFlags.Sync); // Connect flags myConnection = ConnectionType.Connected; } } catch (Exception ex) { myForm.ShowException(ex, null, true); myForm.Dispose(); return; } UpdateUI(); }
/// <summary> /// Connect to the currently selected session /// </summary> public void ConnectToSession() { // Display connection dialog ConnectDialog dialog = new ConnectDialog(this); dialog.RemotePort = DefaultPort; if (DialogResult.Cancel == dialog.ShowDialog()) { return; } // Update the UI m_Form.SessionStatusLabel.Text = "Connecting..."; m_Form.Update(); // Store connection dialog choices HostInfo SelectedHost = dialog.SelectedHost; if (SelectedHost == null) { return; } // Create an application description object to hold the desired // host's instance guid. ApplicationDescription appDesc = new ApplicationDescription(); appDesc.GuidInstance = SelectedHost.GuidInstance; // Attempt to connect to the selected DirectPlay session. Once we // are connected to the session, we will receive DirectPlay messages // about session events (like players joining/exiting and received game // data). Since we're passing in the "Sync" flag, the Connect call will // block until the session is connected or the timeout expires. try { m_Peer.Connect(appDesc, // Application description SelectedHost.HostAddress, // Host address m_LocalAddress, // Local device address null, // User connection data (none) ConnectFlags.Sync); // Flags m_SessionName = SelectedHost.SessionName; m_Connection = ConnectionType.Connected; } catch (Exception ex) { m_Form.ShowException(ex, "Connect", false); return; } }
/// <summary> /// Connect client to a NetworkServer instance. /// </summary> /// <param name="address"></param> /// <param name="port"></param> public void Connect(string address = null, ushort?port = null) { ThrowIfActive(); ThrowIfSocketIsMissing(); _connectState = ConnectState.Connecting; World = new NetworkWorld(); var endPoint = SocketFactory.GetConnectEndPoint(address, port); if (logger.LogEnabled()) { logger.Log($"Client connecting to endpoint: {endPoint}"); } var socket = SocketFactory.CreateClientSocket(); var maxPacketSize = SocketFactory.MaxPacketSize; MessageHandler = new MessageHandler(World, DisconnectOnException); var dataHandler = new DataHandler(MessageHandler); Metrics = EnablePeerMetrics ? new Metrics(MetricsSize) : null; var config = PeerConfig ?? new Config(); NetworkWriterPool.Configure(maxPacketSize); _peer = new Peer(socket, maxPacketSize, dataHandler, config, LogFactory.GetLogger <Peer>(), Metrics); _peer.OnConnected += Peer_OnConnected; _peer.OnConnectionFailed += Peer_OnConnectionFailed; _peer.OnDisconnected += Peer_OnDisconnected; var connection = _peer.Connect(endPoint); if (RunInBackground) { Application.runInBackground = RunInBackground; } // setup all the handlers Player = new NetworkPlayer(connection); dataHandler.SetConnection(connection, Player); RegisterMessageHandlers(); InitializeAuthEvents(); // invoke started event after everything is set up, but before peer has connected _started.Invoke(); }
public override void SetUp() { base.SetUp(); Server = new NetServer(ServerConfiguration); ServerMessages?.Clear(); ServerMessages = new List <NetIncomingMessage>(); ServerMessageHandlerThread = CreateMessageHandlerThread(Server, HandleServerMessage); Server.Start(); ServerMessageHandlerThread.Start(); Connection = Peer.Connect(new IPEndPoint(IPAddress.Loopback, Server.Port)); }
public bool Connect(IPEndPoint endPoint) { if (Peer.Status == NetPeerStatus.NotRunning) { Open(); } NetOutgoingMessage hail = Peer.CreateMessage(); hail.Write(AppInfo.Version.ToString()); Peer.Connect(endPoint, hail); int timeout = (int)((Peer.Configuration.ConnectionTimeout + 1) * 1000); return(_connectWaitHandle.WaitOne(timeout) && Peer.ConnectionStatus == NetConnectionStatus.Connected); }
public TestPeer(bool isServer) { _config = GetConfig(isServer); IsServer = isServer; Peer = new Peer(_config); Peer.OnConnected += OnConnected; Peer.OnUnreliablePacket += OnUnreliablePacket; Peer.OnNotifyPacketLost += OnNotifyPacketLost; Peer.OnNotifyPacketDelivered += OnNotifyPacketDelivered; if (IsClient) { Peer.Connect(ServerEndPoint); } }
static Message SendMessage(Peer peer, Message msg) { int maxRetries = 3; int numberOfRetries = 1; while (numberOfRetries < maxRetries) { if (peer.IsConnected) { break; } peer.Close(); numberOfRetries++; peer.Connect(); Thread.Sleep(2000); } if (peer.IsConnected) { try { var request = new PeerRequest(peer, msg); request.Send(); //At this point, the message has been sent to the SINK for processing int serverTimeout = 30000; request.WaitResponse(serverTimeout); var response = request.ResponseMessage; return(response); } catch (Exception ex) { msg.Fields.Add(39, "06"); // ERROR MessageLogger.LogError("Error sending message " + ex.Message + " Inner Exception: " + ex.InnerException); return(msg); } } else { msg.Fields.Add(39, ResponseCode.ISSUER_OR_SWITCH_INOPERATIVE); // ERROR return(msg); } }
public static void Run(string[] args) { Console.WriteLine("Connecting to node"); var networkParams = NetworkParameters.ProdNet(); using (var blockStore = new MemoryBlockStore(networkParams)) { var chain = new BlockChain(networkParams, blockStore); var peer = new Peer(networkParams, new PeerAddress(IPAddress.Loopback), chain); peer.Connect(); new Thread(() => peer.Run(CancellationToken.None)).Start(); var blockHash = new Sha256Hash(args[0]); var future = peer.BeginGetBlock(blockHash, null, null); Console.WriteLine("Waiting for node to send us the requested block: " + blockHash); var block = peer.EndGetBlock(future); Console.WriteLine(block); peer.Disconnect(); } }
public static void Run(string[] args) { Console.WriteLine("Connecting to node"); var @params = NetworkParameters.ProdNet(); using (var blockStore = new MemoryBlockStore(@params)) { var chain = new BlockChain(@params, blockStore); var peer = new Peer(@params, new PeerAddress(IPAddress.Loopback), chain); peer.Connect(); new Thread(peer.Run).Start(); var blockHash = new Sha256Hash(args[0]); var future = peer.BeginGetBlock(blockHash, null, null); Console.WriteLine("Waiting for node to send us the requested block: " + blockHash); var block = peer.EndGetBlock(future); Console.WriteLine(block); peer.Disconnect(); } }
public void Connect(string ip, int port) { if (m_peer == null) m_peer = new Peer(); m_peer.m_ErrorHandle = (SLibrary_Warper.ResultInfo info) => { errorProcess(info.msg, info.m_Level); }; if (Marshal.SizeOf(new BTZPacket()) != NetworkDefine.pkt_size) { ResultInfo info = new ResultInfo("Not equal packetsize"); m_peer.m_ErrorHandle(info); m_peer.m_ErrorHandle = null; return; } m_peer.m_PacketProcess = (List<char> data, int size) => { IntPtr ptr = Marshal.AllocHGlobal(size); MemoryStream ms = new MemoryStream(Encoding.Default.GetBytes(data.ToArray())); //or //MemoryStream ms2 = new MemoryStream(Convert.FromBase64CharArray(data.ToArray(), 0, data.Count)); packetProcess(ms); }; unsafe { byte[] b2 = Encoding.GetEncoding(51949).GetBytes(ip); sbyte[] sb = (sbyte[])((Array)b2); fixed (sbyte* s_ip = sb) { m_peer.Connect(s_ip, port); } } }
public void ConnectClient(string address, int port, PeerDebug.Settings debugSettings = null) { if (server == null) { StatefulWorld.Instance.Initialize(); } PeerDebug debug = null; if (debugSettings != null && server == null) { debug = gameObject.AddComponent <PeerDebug>(); debug.Initialize(debugSettings); } client = new Peer(debug); client.Connect(address, port, server != null); if (server != null) { server.HasListenClient = true; } }
/// <summary> /// Join an existing session /// </summary> private void btnJoin_Click(object sender, System.EventArgs e) { FindHostsResponseInformation dpInfo; if (lstSession.SelectedItem == null) { MessageBox.Show(this, "Please select a session before clicking join.", "No session", MessageBoxButtons.OK, MessageBoxIcon.Information); return; } // Turn off all buttons btnCreate.Enabled = false; btnCancel.Enabled = false; btnJoin.Enabled = false; btnSearch.Enabled = false; amJoining = true; // Stop our secondary timer updateListTimer.Stop(); dpInfo = ((FindHostsResponseInformation)lstSession.SelectedItem); connectionWizard.SetUserInfo(); peer.Connect(dpInfo.ApplicationDesc, dpInfo.sender, dpInfo.device, null, ConnectFlags.OkToQueryForAddressing); // Now start our 'Connect' timer connectTimer.Start(); }
private static void ConnectToPeers(List <PeerInfo> peers, Torrent torrent) { foreach (PeerInfo peerInfo in peers) { Peer remotePeer = new Peer(peerInfo, torrent, PeerId.GetDefaultPeerId()); Console.WriteLine("Connecting to {0}:{1}", peerInfo.IpAddress, peerInfo.Port); remotePeer.Connected += delegate(object sender, EventArgs args) { Peer peer = sender as Peer; Console.WriteLine("Connected to peer at {0} on port {1}", peer.Info.IpAddress, (ushort)peer.Info.Port); }; remotePeer.HandshakeReceived += delegate(object sender, PeerEventArgs args) { Peer peer = sender as Peer; Console.WriteLine("Received handshake from {0}", peer.Info.IpAddress); }; remotePeer.Error += delegate(object sender, PeerEventArgs args) { Peer peer = sender as Peer; System.Diagnostics.Debug.WriteLine(string.Format("Error from {0}: {1}", peer.Info.IpAddress, args.Exception.Message)); }; remotePeer.Connect(); } }
private static void ConnectToPeers(List<PeerInfo> peers, Torrent torrent) { foreach(PeerInfo peerInfo in peers) { Peer remotePeer = new Peer(peerInfo, torrent, PeerId.GetDefaultPeerId()); Console.WriteLine("Connecting to {0}:{1}", peerInfo.IpAddress, peerInfo.Port); remotePeer.Connected += delegate(object sender, EventArgs args) { Peer peer = sender as Peer; Console.WriteLine("Connected to peer at {0} on port {1}", peer.Info.IpAddress, (ushort)peer.Info.Port); }; remotePeer.HandshakeReceived += delegate(object sender, PeerEventArgs args) { Peer peer = sender as Peer; Console.WriteLine("Received handshake from {0}", peer.Info.IpAddress); }; remotePeer.Error += delegate(object sender, PeerEventArgs args) { Peer peer = sender as Peer; System.Diagnostics.Debug.WriteLine(string.Format("Error from {0}: {1}", peer.Info.IpAddress, args.Exception.Message)); }; remotePeer.Connect(); } }
public void Connect(string Host, int Port) { Peer.Connect(Host, Port); }
public void TestMethodClientPeer() { NetworkComms.EnableLogging(); NetworkComms.Shutdown(); int theirPort = CommonHelpers.PeerPort + 2; string hash = "hash1"; VotingsUser.PeerDiscovery = true; Peer peer1 = null; TCPConnection our = null; List <Peer> allPeers = null; int reqHash = 0; int reqPeers = 0; int reqBlocks = 0; int respPeers = 0; int blocksEvent = 0; int trsEvent = 0; int blocksReqEvent = 0; int trsReqEvent = 0; //============ //прослушиваем 2 порта TCPConnection.StartListening(CommonHelpers.GetLocalEndPoint(CommonHelpers.PeerPort, true)); //мы TCPConnection.StartListening(CommonHelpers.GetLocalEndPoint(theirPort, true)); //они allPeers = new List <Peer>(); peer1 = new Peer(CommonHelpers.GetLocalEndPoint(theirPort, true), allPeers); allPeers.Add(peer1); //получаем подключение пира к нам NetworkComms.AppendGlobalConnectionEstablishHandler((c) => { our = c as TCPConnection; }); //определяем, что сообщения пришли NetworkComms.AppendGlobalIncomingPacketHandler <PeerHashMessage>(typeof(PeerHashMessage).Name, (p, c, i) => { reqHash++; }); NetworkComms.AppendGlobalIncomingPacketHandler <RequestPeersMessage>(typeof(RequestPeersMessage).Name, (p, c, i) => { reqPeers++; }); NetworkComms.AppendGlobalIncomingPacketHandler <RequestBlocksMessage>(typeof(RequestBlocksMessage).Name, (p, c, i) => { reqBlocks++; }); NetworkComms.AppendGlobalIncomingPacketHandler <PeersMessage>(typeof(PeersMessage).Name, (p, c, i) => { respPeers++; }); peer1.OnBlocksMessage += (s, e) => { blocksEvent++; }; peer1.OnTransactionsMessage += (s, e) => { trsEvent++; }; peer1.OnRequestBlocksMessage += (s, e) => { blocksReqEvent++; }; peer1.OnRequestTransactionsMessage += (s, e) => { trsReqEvent++; }; //============ //подключаемся к пиру peer1.Connect(); w(); Assert.IsTrue(peer1.Status == PeerStatus.NoHashRecieved); Assert.IsTrue(reqHash == 1); //отправляем хеш пиру our.SendObject <PeerHashMessage>(typeof(PeerHashMessage).Name, new PeerHashMessage(hash, false)); w(); Assert.IsTrue(peer1.Hash == hash); Assert.IsTrue(peer1.Status == PeerStatus.Connected); //отправляем сообщение нам peer1.SendMessage(new RequestBlocksMessage(new List <string>())); w(); Assert.IsTrue(reqBlocks == 1); //проверяем подключение peer1.CheckConnection(); w(); Assert.IsTrue(peer1.ErrorsCount == 0); //запрашиваем пиры у нас peer1.RequestPeers(10); w(); Assert.IsTrue(reqPeers == 1); //запрашиваем пиры у пира our.SendObject <RequestPeersMessage>(typeof(RequestPeersMessage).Name, new RequestPeersMessage(10)); w(); Assert.IsTrue(reqPeers == 2); Assert.IsTrue(respPeers == 1); //отправляем блоки пиру our.SendObject <BlocksMessage>(typeof(BlocksMessage).Name, new BlocksMessage()); w(); Assert.IsTrue(blocksEvent == 1); //отправляем транзакции пиру our.SendObject <TransactionsMessage>(typeof(TransactionsMessage).Name, new TransactionsMessage()); w(); Assert.IsTrue(trsEvent == 1); //запрашиваем транзакции у пира our.SendObject <RequestTransactionsMessage>(typeof(RequestTransactionsMessage).Name, new RequestTransactionsMessage()); w(); Assert.IsTrue(trsReqEvent == 1); //запрашиваем транзакции у пира our.SendObject <RequestBlocksMessage>(typeof(RequestBlocksMessage).Name, new RequestBlocksMessage()); w(); Assert.IsTrue(blocksReqEvent == 1); //отключаемся от пира peer1.DisconnectAny(); w(); Assert.IsTrue(allPeers.Count == 0); }
protected override void OnStart() { var connection = Peer.Connect(new IPEndPoint(RemoteIP, Options.Port)); Connection = new LidgrenClientConnection(this, connection); }
/// <summary> /// Connect with the specified configuration /// </summary> /// <param name="configuration"></param> public static void Connect(PNetC.ClientConfiguration configuration) { Peer.Connect(configuration); }
private void Connect(string ip, ushort port) { peer?.Disconnect(); peer.Connect(ip, port); }
public void Start() { Peer.Start(); Peer.Connect(Host); }
public RemoteServerImpl(String hostname, int port) : this(CreatePeer()) { Peer.Connect(hostname, port); }
/// <summary> /// Try connecting to a peer. If we exceed the number of connections, delay and try /// again. /// </summary> /// <exception cref="ThreadInterruptedException" /> private void TryNextPeer() { PeerAddress address = _inactives.Take(); try { var peer = new Peer(_networkParameters, address, _blockStore.GetChainHead().Height, _blockChain); Task.Factory.StartNew( () => { while (true) { try { //Log.Info("Connecting to " + peer); peer.Connect(); //Log.Info("Connected to " + peer); _peers.Add(peer); Log.Info("Addded peer to list of peers " + peer); HandleNewPeer(peer); Log.Info("Handled new peer " + peer); peer.Run(); Log.Info("Peer is running " + peer); } catch (PeerException ex) { //Do not propagate PeerException - log and try next peer. Suppress stack traces for //exceptions we expect as part of normal network behaviour. Exception cause = ex.InnerException; var exception = cause as SocketException; if (exception != null) { if (exception.SocketErrorCode == SocketError.TimedOut) Log.Info("Timeout talking to " + peer + ": " + cause.Message); else Log.Info("Could not connect to " + peer + ": " + cause.Message); } else if (cause is IOException) { Log.Info("Error talking to " + peer + ": " + cause.Message); } else { Log.Error("Unexpected exception whilst talking to " + peer, ex); } } catch (Exception exception) { Log.Error("Boom: " + peer, exception); } finally { //In all cases, disconnect and put the address back on the queue. //We will retry this peer after all other peers have been tried. peer.Disconnect(); _inactives.Add(address); //TODO: Ensure this is the logic that we expect. if (_peers.TryTake(out peer)) HandlePeerDeath(peer); } } }, TaskCreationOptions.LongRunning); } //catch (RejectedExecutionException) //{ // // Reached maxConnections, try again after a delay // // TODO - consider being smarter about retry. No need to retry // // if we reached maxConnections or if peer queue is empty. Also consider // // exponential backoff on peers and adjusting the sleep time according to the // // lowest backoff value in queue. //} catch (BlockStoreException e) { // Fatal error Log.Error("Block store corrupt?", e); _running = false; throw new Exception(e.Message, e); } // If we got here, we should retry this address because an error unrelated // to the peer has occurred. // TODO: Code is unreachable? Thread.Sleep(_connectionDelayMillis); }
/// <summary> /// Try connecting to a peer. If we exceed the number of connections, delay and try /// again. /// </summary> /// <exception cref="ThreadInterruptedException"/> private void TryNextPeer() { var address = _inactives.Take(); while (true) { try { var peer = new Peer(_params, address, _blockStore.GetChainHead().Height, _chain); _peerPool.Execute( () => { try { _log.Info("Connecting to " + peer); peer.Connect(); _peers.Add(peer); HandleNewPeer(peer); peer.Run(); } catch (PeerException ex) { // Do not propagate PeerException - log and try next peer. Suppress stack traces for // exceptions we expect as part of normal network behaviour. var cause = ex.InnerException; if (cause is SocketException) { if (((SocketException) cause).SocketErrorCode == SocketError.TimedOut) _log.Info("Timeout talking to " + peer + ": " + cause.Message); else _log.Info("Could not connect to " + peer + ": " + cause.Message); } else if (cause is IOException) { _log.Info("Error talking to " + peer + ": " + cause.Message); } else { _log.Error("Unexpected exception whilst talking to " + peer, ex); } } finally { // In all cases, disconnect and put the address back on the queue. // We will retry this peer after all other peers have been tried. peer.Disconnect(); _inactives.Add(address); if (_peers.Remove(peer)) HandlePeerDeath(peer); } }); break; } catch (RejectedExecutionException) { // Reached maxConnections, try again after a delay // TODO - consider being smarter about retry. No need to retry // if we reached maxConnections or if peer queue is empty. Also consider // exponential backoff on peers and adjusting the sleep time according to the // lowest backoff value in queue. } catch (BlockStoreException e) { // Fatal error _log.Error("Block store corrupt?", e); _running = false; throw new Exception(e.Message, e); } // If we got here, we should retry this address because an error unrelated // to the peer has occurred. Thread.Sleep(_connectionDelayMillis); } }