public void InEvent() { Socket fd; try { fd = Accept(); Utils.TuneTcpSocket(fd); Utils.TuneTcpKeepalives(fd, m_options.TcpKeepalive, m_options.TcpKeepaliveCnt, m_options.TcpKeepaliveIdle, m_options.TcpKeepaliveIntvl); } catch (NetMQException ex) { // If connection was reset by the peer in the meantime, just ignore it. // TODO: Handle specific errors like ENFILE/EMFILE etc. //ZError.exc (e); m_socket.EventAcceptFailed(m_endpoint, ex.ErrorCode); return; } // Create the engine object for this connection. StreamEngine engine; try { engine = new StreamEngine(fd, m_options, m_endpoint); } catch (SocketException ex) { //LOG.error("Failed to initialize StreamEngine", e.getCause()); ErrorCode errorCode = ErrorHelper.SocketErrorToErrorCode(ex.SocketErrorCode); m_socket.EventAcceptFailed(m_endpoint, errorCode); throw NetMQException.Create(errorCode); } // 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. 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, fd); }
public void InEvent() { Socket fd; try { fd = Accept(); } catch (SocketException ex) { m_socket.EventAcceptFailed(m_address.ToString(), ErrorHelper.SocketErrorToErrorCode(ex.SocketErrorCode)); return; } catch (NetMQException ex) { // If connection was reset by the peer in the meantime, just ignore it. // TODO: Handle specific errors like ENFILE/EMFILE etc. //ZError.exc (e); m_socket.EventAcceptFailed(m_address.ToString(), ex.ErrorCode); return; } PgmSocket pgmSocket = new PgmSocket(m_options, PgmSocketType.Receiver, m_address); pgmSocket.Init(fd); PgmSession pgmSession = new PgmSession(pgmSocket, 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(), fd); }
public void Connect([NotNull] 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[] highWaterMarks = { sndhwm, rcvhwm }; bool[] delays = { m_options.DelayOnDisconnect, m_options.DelayOnClose }; Pipe[] pipes = Pipe.PipePair(parents, highWaterMarks, 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) { var 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) { var 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); } var 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); }