public TcpConnecter(IOThread ioThread,
SessionBase session, Options options,
Address addr, bool delayedStart)
: base(ioThread, options)
{
m_ioObject = new IOObject(ioThread);
m_addr = addr;
m_handle = null;
m_handleValid = false;
m_delayedStart = delayedStart;
m_timerStarted = false;
m_session = session;
m_currentReconnectIvl = m_options.ReconnectIvl;
Debug.Assert(m_addr != null);
m_endpoint = m_addr.ToString();
m_socket = session.Socket;
}
protected void SendAttach(SessionBase destination,
IEngine engine, bool incSeqnum)
{
if (incSeqnum)
destination.IncSeqnum ();
Command cmd = new Command(destination, CommandType.Attach, engine);
SendCommand (cmd);
}
protected void SendAttach(SessionBase destination, IEngine engine)
{
SendAttach(destination, engine, true);
}
public StreamEngine(Socket fd, Options options, String endpoint)
{
m_handle = fd;
// inbuf = null;
m_insize = 0;
m_inputError = false;
// outbuf = null;
m_outsize = 0;
m_handshaking = true;
m_session = null;
m_options = options;
m_plugged = false;
m_endpoint = endpoint;
m_socket = null;
m_encoder = null;
m_decoder = null;
// Put the socket into non-blocking mode.
Utils.UnblockSocket(m_handle);
// Set the socket buffer limits for the underlying socket.
if (m_options.SendBuffer != 0)
{
m_handle.SendBufferSize = m_options.SendBuffer;
}
if (m_options.ReceiveBuffer != 0)
{
m_handle.ReceiveBufferSize = m_options.ReceiveBuffer;
}
}
private void Unplug()
{
Debug.Assert(m_plugged);
m_plugged = false;
// Cancel all fd subscriptions.
if (!m_inputError)
m_ioObject.RmFd(m_handle);
// Disconnect from I/O threads poller object.
m_ioObject.Unplug();
// Disconnect from session object.
if (m_encoder != null)
m_encoder.SetMsgSource(null);
if (m_decoder != null)
m_decoder.SetMsgSink(null);
m_session = null;
}
public void Plug(IOThread ioThread,
SessionBase session)
{
Debug.Assert(!m_plugged);
m_plugged = true;
// Connect to session object.
Debug.Assert(m_session == null);
Debug.Assert(session != null);
m_session = session;
m_socket = m_session.Socket;
m_ioObject = new IOObject(null);
m_ioObject.SetHandler(this);
// Connect to I/O threads poller object.
m_ioObject.Plug(ioThread);
m_ioObject.AddFd(m_handle);
// Send the 'length' and 'flags' fields of the identity message.
// The 'length' field is encoded in the long format.
m_greetingOutputBuffer[m_outsize++] = ((byte) 0xff);
m_greetingOutputBuffer.PutLong((long) m_options.IdentitySize + 1, 1);
m_outsize += 8;
m_greetingOutputBuffer[m_outsize++] = ((byte) 0x7f);
m_outpos = new ByteArraySegment(m_greetingOutputBuffer);
m_ioObject.SetPollin(m_handle);
m_ioObject.SetPollout(m_handle);
// Flush all the data that may have been already received downstream.
InEvent();
}
private void Error()
{
Debug.Assert(m_session != null);
//m_socket.EventDisconnected(m_endpoint, m_handle);
m_session.Detach();
// Cancel all fd subscriptions.
m_ioObject.RmFd(m_handle);
// Disconnect from I/O threads poller object.
m_ioObject.Unplug();
// Disconnect from session object.
if (m_decoder != null)
m_decoder.SetMsgSink(null);
m_session = null;
Destroy();
}
public void Plug(IOThread ioThread, SessionBase session)
{
m_session = session;
m_socket = session.Socket;
m_ioObject = new IOObject(null);
m_ioObject.SetHandler(this);
m_ioObject.Plug(ioThread);
m_ioObject.AddFd(m_handle);
m_ioObject.SetPollin(m_handle);
DropSubscriptions();
// push message to the session because there is no identity message with pgm
session.PushMsg(new Msg());
}
public void Plug(IOThread ioThread, SessionBase session)
{
m_encoder.SetMsgSource(session);
AddFd(m_socket);
SetPollout(m_socket);
// get the first message from the session because we don't want to send identities
session.PullMsg();
}
public void Connect(String addr)
{
CheckContextTerminated();
// Process pending commands, if any.
ProcessCommands(0, false);
string address;
string protocol;
DecodeAddress(addr, out address, out protocol);
CheckProtocol(protocol);
if (protocol.Equals(Address.InProcProtocol))
{
// TODO: inproc connect is specific with respect to creating pipes
// as there's no 'reconnect' functionality implemented. Once that
// is in place we should follow generic pipe creation algorithm.
// Find the peer endpoint.
Ctx.Endpoint peer = FindEndpoint(addr);
// The total HWM for an inproc connection should be the sum of
// the binder's HWM and the connector's HWM.
int sndhwm;
int rcvhwm;
if (m_options.SendHighWatermark == 0 || peer.Options.ReceiveHighWatermark == 0)
{
sndhwm = 0;
}
else
{
sndhwm = m_options.SendHighWatermark + peer.Options.ReceiveHighWatermark;
}
if (m_options.ReceiveHighWatermark == 0 || peer.Options.SendHighWatermark == 0)
{
rcvhwm = 0;
}
else
{
rcvhwm = m_options.ReceiveHighWatermark + peer.Options.SendHighWatermark;
}
// Create a bi-directional pipe to connect the peers.
ZObject[] parents = { this, peer.Socket };
int[] hwms = { sndhwm, rcvhwm };
bool[] delays = { m_options.DelayOnDisconnect, m_options.DelayOnClose };
Pipe[] pipes = Pipe.PipePair(parents, hwms, delays);
// Attach local end of the pipe to this socket object.
AttachPipe(pipes[0]);
// If required, send the identity of the peer to the local socket.
if (peer.Options.RecvIdentity)
{
Msg id = new Msg();
id.InitPool(peer.Options.IdentitySize);
id.Put(peer.Options.Identity, 0, peer.Options.IdentitySize);
id.SetFlags(MsgFlags.Identity);
bool written = pipes[0].Write(ref id);
Debug.Assert(written);
pipes[0].Flush();
}
// If required, send the identity of the local socket to the peer.
if (m_options.RecvIdentity)
{
Msg id = new Msg();
id.InitPool(m_options.IdentitySize);
id.Put(m_options.Identity, 0, m_options.IdentitySize);
id.SetFlags(MsgFlags.Identity);
bool written = pipes[1].Write(ref id);
Debug.Assert(written);
pipes[1].Flush();
}
// Attach remote end of the pipe to the peer socket. Note that peer's
// seqnum was incremented in find_endpoint function. We don't need it
// increased here.
SendBind(peer.Socket, pipes[1], false);
// Save last endpoint URI
m_options.LastEndpoint = addr;
// remember inproc connections for disconnect
m_inprocs.Add(addr, pipes[0]);
return;
}
// Choose the I/O thread to run the session in.
IOThread ioThread = ChooseIOThread(m_options.Affinity);
if (ioThread == null)
{
throw NetMQException.Create("Empty IO Thread", ErrorCode.EmptyThread);
}
Address paddr = new Address(protocol, address);
// Resolve address (if needed by the protocol)
if (protocol.Equals(Address.TcpProtocol))
{
paddr.Resolved = (new TcpAddress());
paddr.Resolved.Resolve(
address, m_options.IPv4Only);
}
else if (protocol.Equals(Address.IpcProtocol))
{
paddr.Resolved = (new IpcAddress());
paddr.Resolved.Resolve(address, true);
}
else if (protocol.Equals(Address.PgmProtocol) || protocol.Equals(Address.EpgmProtocol))
{
if (m_options.SocketType == ZmqSocketType.Sub || m_options.SocketType == ZmqSocketType.Xsub)
{
Bind(addr);
return;
}
paddr.Resolved = new PgmAddress();
paddr.Resolved.Resolve(address, m_options.IPv4Only);
}
// Create session.
SessionBase session = SessionBase.Create(ioThread, true, this, m_options, paddr);
Debug.Assert(session != null);
// PGM does not support subscription forwarding; ask for all data to be
// sent to this pipe.
bool icanhasall = protocol.Equals(Address.PgmProtocol) || protocol.Equals(Address.EpgmProtocol);
if (!m_options.DelayAttachOnConnect || icanhasall)
{
// Create a bi-directional pipe.
ZObject[] parents = { this, session };
int[] hwms = { m_options.SendHighWatermark, m_options.ReceiveHighWatermark };
bool[] delays = { m_options.DelayOnDisconnect, m_options.DelayOnClose };
Pipe[] pipes = Pipe.PipePair(parents, hwms, delays);
// Attach local end of the pipe to the socket object.
AttachPipe(pipes[0], icanhasall);
// Attach remote end of the pipe to the session object later on.
session.AttachPipe(pipes[1]);
}
// Save last endpoint URI
m_options.LastEndpoint = paddr.ToString();
AddEndpoint(addr, session);
return;
}