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