public void InCompleted(SocketError socketError, int bytesTransferred)
{
if (socketError != SocketError.Success)
{
if (socketError == SocketError.ConnectionReset || socketError == SocketError.NoBufferSpaceAvailable ||
socketError == SocketError.TooManyOpenSockets)
{
m_socket.EventAcceptFailed(m_endpoint, ErrorHelper.SocketErrorToErrorCode(socketError));
Accept();
}
else
{
m_acceptedSocket.Dispose();
NetMQException exception = NetMQException.Create(socketError);
m_socket.EventAcceptFailed(m_endpoint, exception.ErrorCode);
throw exception;
}
}
else
{
// TODO: check TcpFilters
m_acceptedSocket.NoDelay = true;
// Utils.TuneTcpKeepalives(m_acceptedSocket, m_options.TcpKeepalive, m_options.TcpKeepaliveCnt, m_options.TcpKeepaliveIdle, m_options.TcpKeepaliveIntvl);
// Create the engine object for this connection.
StreamEngine engine = new StreamEngine(m_acceptedSocket, m_options, m_endpoint);
// Choose I/O thread to run connecter in. Given that we are already
// running in an I/O thread, there must be at least one available.
IOThread ioThread = ChooseIOThread(m_options.Affinity);
// Create and launch a session object.
// TODO: send null in address parameter, is unneed in this case
SessionBase session = SessionBase.Create(ioThread, false, m_socket, m_options, new Address(m_handle.LocalEndPoint));
session.IncSeqnum();
LaunchChild(session);
SendAttach(session, engine, false);
m_socket.EventAccepted(m_endpoint, m_acceptedSocket);
Accept();
}
}
/// <summary>
/// This method is called when a message receive operation has been completed.
/// </summary>
/// <param name="socketError">a SocketError value that indicates whether Success or an error occurred</param>
/// <param name="bytesTransferred">the number of bytes that were transferred</param>
public void InCompleted(SocketError socketError, int bytesTransferred)
{
if (socketError != SocketError.Success)
{
m_socket.EventAcceptFailed(m_address.ToString(), socketError.ToErrorCode());
// dispose old object
m_acceptedSocket.Handle.Dispose();
Accept();
}
else
{
m_acceptedSocket.InitOptions();
var pgmSession = new PgmSession(m_acceptedSocket, m_options);
IOThread ioThread = ChooseIOThread(m_options.Affinity);
SessionBase session = SessionBase.Create(ioThread, false, m_socket, m_options, new Address(m_handle.LocalEndPoint));
session.IncSeqnum();
LaunchChild(session);
SendAttach(session, pgmSession, false);
m_socket.EventAccepted(m_address.ToString(), m_acceptedSocket.Handle);
Accept();
}
}
/// <summary>
/// This method is called when a message receive operation has been completed.
/// </summary>
/// <param name="socketError">a SocketError value that indicates whether Success or an error occurred</param>
/// <param name="bytesTransferred">the number of bytes that were transferred</param>
public void InCompleted(SocketError socketError, int bytesTransferred)
{
Assumes.NotNull(m_address);
Assumes.NotNull(m_acceptedSocket);
Assumes.NotNull(m_acceptedSocket.Handle);
if (socketError != SocketError.Success)
{
m_socket.EventAcceptFailed(m_address.ToString(), socketError.ToErrorCode());
// dispose old object
m_acceptedSocket.Handle.Dispose();
Accept();
}
else
{
//This if-case only concerns bound PGM Subscribers after the Ethernet cable has been unplugged (Publisher on same host)
//or plugged in again (Publisher on different host).
if (m_address.InterfaceAddress != null)
{
try
{
m_acceptedSocket.Handle.SetSocketOption(PgmSocket.PgmLevel, PgmSocket.RM_ADD_RECEIVE_IF,
m_address.InterfaceAddress.GetAddressBytes());
}
catch
{
// dispose old object
m_acceptedSocket.Handle.Dispose();
Accept();
return;
}
}
m_acceptedSocket.InitOptions();
var pgmSession = new PgmSession(m_acceptedSocket, m_options);
IOThread?ioThread = ChooseIOThread(m_options.Affinity);
Assumes.NotNull(ioThread);
Assumes.NotNull(m_handle);
SessionBase session = SessionBase.Create(ioThread, false, m_socket, m_options, new Address(m_handle.LocalEndPoint));
session.IncSeqnum();
LaunchChild(session);
SendAttach(session, pgmSession, false);
m_socket.EventAccepted(m_address.ToString(), m_acceptedSocket.Handle);
Accept();
}
}
public void InCompleted(SocketError socketError, int bytesTransferred)
{
if (socketError != SocketError.Success)
{
if (socketError == SocketError.ConnectionReset || socketError == SocketError.NoBufferSpaceAvailable ||
socketError == SocketError.TooManyOpenSockets)
{
m_socket.EventAcceptFailed(m_endpoint, ErrorHelper.SocketErrorToErrorCode(socketError));
Accept();
}
else
{
m_acceptedSocket.Dispose();
NetMQException exception = NetMQException.Create(socketError);
m_socket.EventAcceptFailed(m_endpoint, exception.ErrorCode);
throw exception;
}
}
else
{
// TODO: check TcpFilters
m_acceptedSocket.NoDelay = true;
if (m_options.TcpKeepalive != -1)
{
m_acceptedSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.KeepAlive, m_options.TcpKeepalive);
if (m_options.TcpKeepaliveIdle != -1 && m_options.TcpKeepaliveIntvl != -1)
{
ByteArraySegment bytes = new ByteArraySegment(new byte[12]);
Endianness endian = BitConverter.IsLittleEndian ? Endianness.Little : Endianness.Big;
bytes.PutInteger(endian, m_options.TcpKeepalive, 0);
bytes.PutInteger(endian, m_options.TcpKeepaliveIdle, 4);
bytes.PutInteger(endian, m_options.TcpKeepaliveIntvl, 8);
m_acceptedSocket.IOControl(IOControlCode.KeepAliveValues, (byte[])bytes, null);
}
}
// Create the engine object for this connection.
StreamEngine engine = new StreamEngine(m_acceptedSocket, m_options, m_endpoint);
// Choose I/O thread to run connecter in. Given that we are already
// running in an I/O thread, there must be at least one available.
IOThread ioThread = ChooseIOThread(m_options.Affinity);
// Create and launch a session object.
// TODO: send null in address parameter, is unneed in this case
SessionBase session = SessionBase.Create(ioThread, false, m_socket, m_options, new Address(m_handle.LocalEndPoint));
session.IncSeqnum();
LaunchChild(session);
SendAttach(session, engine, false);
m_socket.EventAccepted(m_endpoint, m_acceptedSocket);
Accept();
}
}
