protected override bool XHasIn() { // We may already have a message pre-fetched. if (m_prefetched) { return(true); } // Try to read the next message. // The message, if read, is kept in the pre-fetch buffer. Pipe[] pipe = new Pipe[1]; bool isMessageAvailable = m_fq.RecvPipe(pipe, ref m_prefetchedMsg); if (!isMessageAvailable) { return(false); } Debug.Assert(pipe[0] != null); Debug.Assert(!m_prefetchedMsg.HasMore); Blob identity = pipe[0].Identity; m_prefetchedId = new Msg(); m_prefetchedId.InitPool(identity.Size); m_prefetchedId.Put(identity.Data, 0, identity.Size); m_prefetchedId.SetFlags(MsgFlags.More); m_prefetched = true; m_identitySent = false; return(true); }
protected override bool XHasIn() { // If we are in the middle of reading the messages, there are // definitely more parts available. if (m_moreIn) { return(true); } // We may already have a message pre-fetched. if (m_prefetched) { return(true); } // Try to read the next message. // The message, if read, is kept in the pre-fetch buffer. Pipe[] pipe = new Pipe[1]; bool isMessageAvailable = m_fq.RecvPipe(pipe, out m_prefetchedMsg); if (!isMessageAvailable) { return(false); } // It's possible that we receive peer's identity. That happens // after reconnection. The current implementation assumes that // the peer always uses the same identity. // TODO: handle the situation when the peer changes its identity. while (m_prefetchedMsg != null && m_prefetchedMsg.IsIdentity) { isMessageAvailable = m_fq.RecvPipe(pipe, out m_prefetchedMsg); if (!isMessageAvailable) { return(false); } } if (m_prefetchedMsg == null) { return(false); } Debug.Assert(pipe[0] != null); Blob identity = pipe[0].Identity; m_prefetchedId = new Msg(identity.Data); m_prefetchedId.SetFlags(MsgFlags.More); m_prefetched = true; m_identitySent = false; return(true); }
private bool FlagsReady() { m_tmpbuf.Reset(); // Store the flags from the wire into the message structure. int first = m_tmpbuf[0]; m_inProgress.SetFlags((MsgFlags)first & MsgFlags.More); NextStep(m_inProgress.Data, m_inProgress.Size, MessageReadyState); return(true); }
protected override bool XRecv(SendReceiveOptions flags, out Msg msg) { msg = null; if (m_prefetched) { if (!m_identitySent) { msg = m_prefetchedId; m_prefetchedId = null; m_identitySent = true; } else { msg = m_prefetchedMsg; m_prefetchedMsg = null; m_prefetched = false; } return(true); } Pipe[] pipe = new Pipe[1]; bool isMessageAvailable = m_fq.RecvPipe(pipe, out m_prefetchedMsg); if (!isMessageAvailable) { return(false); } else if (m_prefetchedMsg == null) { return(true); } Debug.Assert(pipe[0] != null); Debug.Assert(!m_prefetchedMsg.HasMore); // We have received a frame with TCP data. // Rather than sendig this frame, we keep it in prefetched // buffer and send a frame with peer's ID. Blob identity = pipe[0].Identity; msg = new Msg(identity.Data, true); msg.SetFlags(MsgFlags.More); m_prefetched = true; m_identitySent = true; return(true); }
protected override bool XSend(ref Msg msg, SendReceiveOptions flags) { // If we've sent a request and we still haven't got the reply, // we can't send another request. if (m_receivingReply) { throw NetMQException.Create("Cannot send another request", ErrorCode.EFSM); } bool isMessageSent; // First part of the request is the request identity. if (m_messageBegins) { Msg bottom = new Msg(); bottom.InitEmpty(); bottom.SetFlags(MsgFlags.More); isMessageSent = base.XSend(ref bottom, 0); if (!isMessageSent) { return(false); } m_messageBegins = false; } bool more = msg.HasMore; isMessageSent = base.XSend(ref msg, flags); if (!isMessageSent) { return(false); } // If the request was fully sent, flip the FSM into reply-receiving state. else if (!more) { m_receivingReply = true; m_messageBegins = true; } return(true); }
public virtual void PushMsg(Msg msg) { // First message to receive is identity (if required). if (!m_identityReceived) { msg.SetFlags(MsgFlags.Identity); m_identityReceived = true; if (!m_options.RecvIdentity) { return; } } if (m_pipe != null && m_pipe.Write(msg)) { return; } throw AgainException.Create(); }
public virtual bool PushMsg(ref Msg msg) { // First message to receive is identity (if required). if (!m_identityReceived) { msg.SetFlags(MsgFlags.Identity); m_identityReceived = true; if (!m_options.RecvIdentity) { msg.Close(); msg.InitEmpty(); return(true); } } if (m_pipe != null && m_pipe.Write(ref msg)) { msg.InitEmpty(); return(true); } return(false); }
protected override bool XHasIn() { // If we are in the middle of reading the messages, there are // definitely more parts available. if (m_moreIn) return true; // We may already have a message pre-fetched. if (m_prefetched) return true; // Try to read the next message. // The message, if read, is kept in the pre-fetch buffer. Pipe[] pipe = new Pipe[1]; bool isMessageAvailable = m_fq.RecvPipe(pipe, out m_prefetchedMsg); if (!isMessageAvailable) { return false; } // It's possible that we receive peer's identity. That happens // after reconnection. The current implementation assumes that // the peer always uses the same identity. // TODO: handle the situation when the peer changes its identity. while (m_prefetchedMsg != null && m_prefetchedMsg.IsIdentity) { isMessageAvailable = m_fq.RecvPipe(pipe, out m_prefetchedMsg); if (!isMessageAvailable) { return false; } } if (m_prefetchedMsg == null) { return false; } Debug.Assert(pipe[0] != null); Blob identity = pipe[0].Identity; m_prefetchedId = new Msg(identity.Data); m_prefetchedId.SetFlags(MsgFlags.More); m_prefetched = true; m_identitySent = false; return true; }
protected override bool XSend(Msg msg, SendReceiveOptions flags) { // If we've sent a request and we still haven't got the reply, // we can't send another request. if (m_receivingReply) { throw NetMQException.Create("Cannot send another request", ErrorCode.EFSM); } bool isMessageSent; // First part of the request is the request identity. if (m_messageBegins) { Msg bottom = new Msg(); bottom.SetFlags(MsgFlags.More); isMessageSent = base.XSend(bottom, 0); if (!isMessageSent) { return false; } m_messageBegins = false; } bool more = msg.HasMore; isMessageSent = base.XSend(msg, flags); if (!isMessageSent) { return false; } // If the request was fully sent, flip the FSM into reply-receiving state. else if (!more) { m_receivingReply = true; m_messageBegins = true; } return true; }
protected override bool XRecv(SendReceiveOptions flags, out Msg msg) { msg = null; if (m_prefetched) { if (!m_identitySent) { msg = m_prefetchedId; m_prefetchedId = null; m_identitySent = true; } else { msg = m_prefetchedMsg; m_prefetchedMsg = null; m_prefetched = false; } m_moreIn = msg.HasMore; return(true); } Pipe[] pipe = new Pipe[1]; bool isMessageAvailable = m_fq.RecvPipe(pipe, out msg); // It's possible that we receive peer's identity. That happens // after reconnection. The current implementation assumes that // the peer always uses the same identity. // TODO: handle the situation when the peer changes its identity. while (isMessageAvailable && msg != null && msg.IsIdentity) { isMessageAvailable = m_fq.RecvPipe(pipe, out msg); } if (!isMessageAvailable) { return(false); } else if (msg == null) { return(true); } Debug.Assert(pipe[0] != null); // If we are in the middle of reading a message, just return the next part. if (m_moreIn) { m_moreIn = msg.HasMore; } else { // We are at the beginning of a message. // Keep the message part we have in the prefetch buffer // and return the ID of the peer instead. m_prefetchedMsg = msg; m_prefetched = true; Blob identity = pipe[0].Identity; msg = new Msg(identity.Data); msg.SetFlags(MsgFlags.More); m_identitySent = true; } return(true); }
/// <summary> /// Transmit the given Msg across the message-queueing system. /// If the msg fails to immediately send, then - if DontWait is specified and no SendTimeout was set /// then throw an AgainException. /// </summary> /// <param name="msg">the Msg to transmit</param> /// <param name="flags">a SendReceiveOptions: either don't specify DontWait, or set a timeout</param> public void Send(ref Msg msg, SendReceiveOptions flags) { CheckContextTerminated(); // Check whether message passed to the function is valid. if (!msg.IsInitialised) { throw new FaultException("SocketBase.Send passed an uninitialised Msg."); } // Process pending commands, if any. ProcessCommands(0, true); // Clear any user-visible flags that are set on the message. msg.ResetFlags(MsgFlags.More); // At this point we impose the flags on the message. if ((flags & SendReceiveOptions.SendMore) > 0) { msg.SetFlags(MsgFlags.More); } // Try to send the message. bool isMessageSent = XSend(ref msg, flags); if (isMessageSent) { return; } // In case of non-blocking send we'll simply propagate // the error - including EAGAIN - up the stack. bool isDontWaitSet = (flags & SendReceiveOptions.DontWait) > 0; if (isDontWaitSet || m_options.SendTimeout == 0) { #if DEBUG string xMsg; if (isDontWaitSet && m_options.SendTimeout == 0) { xMsg = "SocketBase.Send failed, and DontWait is true AND SendTimeout is 0."; } else if (isDontWaitSet) { xMsg = "SocketBase.Send failed and DontWait is specified."; } else { xMsg = "SocketBase.Send failed and no SendTimeout is specified."; } throw new AgainException(innerException: null, message: xMsg); #else throw new AgainException(innerException: null, message: "SocketBase.Send failed"); #endif } // Compute the time when the timeout should occur. // If the timeout is infinite, don't care. int timeout = m_options.SendTimeout; long end = timeout < 0 ? 0 : (Clock.NowMs() + timeout); // Oops, we couldn't send the message. Wait for the next // command, process it and try to send the message again. // If timeout is reached in the meantime, return EAGAIN. while (true) { ProcessCommands(timeout, false); isMessageSent = XSend(ref msg, flags); if (isMessageSent) { break; } if (timeout <= 0) { continue; } timeout = (int)(end - Clock.NowMs()); if (timeout <= 0) { throw new AgainException(innerException: null, message: "SocketBase.Send failed and timeout <= 0"); } } }
public virtual void PushMsg(Msg msg) { // First message to receive is identity (if required). if (!m_identityReceived) { msg.SetFlags(MsgFlags.Identity); m_identityReceived = true; if (!m_options.RecvIdentity) { return; } } if (m_pipe != null && m_pipe.Write(msg)) { return; } throw AgainException.Create(); }
protected override bool XHasIn() { // We may already have a message pre-fetched. if (m_prefetched) return true; // Try to read the next message. // The message, if read, is kept in the pre-fetch buffer. Pipe[] pipe = new Pipe[1]; bool isMessageAvailable = m_fq.RecvPipe(pipe, out m_prefetchedMsg); if (!isMessageAvailable) { return false; } if (m_prefetchedMsg == null) { return false; } Debug.Assert(pipe[0] != null); Debug.Assert(!m_prefetchedMsg.HasMore); Blob identity = pipe[0].Identity; m_prefetchedId = new Msg(identity.Data); m_prefetchedId.SetFlags(MsgFlags.More); m_prefetched = true; m_identitySent = false; return true; }
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); }
public bool Send(Msg msg, SendRecieveOptions flags) { if (m_ctxTerminated) { ZError.ErrorNumber = (ErrorNumber.ETERM); return false; } // Check whether message passed to the function is valid. if (msg == null) { ZError.ErrorNumber = (ErrorNumber.EFAULT); throw new ArgumentException(); } // Process pending commands, if any. bool rc = ProcessCommands(0, true); if (!rc) return false; // Clear any user-visible flags that are set on the message. msg.ResetFlags(MsgFlags.More); // At this point we impose the flags on the message. if ((flags & SendRecieveOptions.SendMore) > 0) msg.SetFlags(MsgFlags.More); // Try to send the message. rc = XSend(msg, flags); if (rc) return true; if (!ZError.IsError(ErrorNumber.EAGAIN)) return false; // In case of non-blocking send we'll simply propagate // the error - including EAGAIN - up the stack. if ((flags & SendRecieveOptions.DontWait) > 0 || m_options.SendTimeout == 0) return false; // Compute the time when the timeout should occur. // If the timeout is infite, don't care. int timeout = m_options.SendTimeout; long end = timeout < 0 ? 0 : (Clock.NowMs() + timeout); // Oops, we couldn't send the message. Wait for the next // command, process it and try to send the message again. // If timeout is reached in the meantime, return EAGAIN. while (true) { if (!ProcessCommands(timeout, false)) return false; rc = XSend(msg, flags); if (rc) break; if (!ZError.IsError(ErrorNumber.EAGAIN)) return false; if (timeout > 0) { timeout = (int)(end - Clock.NowMs()); if (timeout <= 0) { ZError.ErrorNumber = (ErrorNumber.EAGAIN); return false; } } } return true; }
public void Connect(String addr) { if (m_ctxTerminated) { throw TerminatingException.Create(); } // 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(peer.Options.IdentitySize); id.Put(peer.Options.Identity, 0, peer.Options.IdentitySize); id.SetFlags(MsgFlags.Identity); bool written = pipes[0].Write(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(m_options.IdentitySize); id.Put(m_options.Identity, 0, m_options.IdentitySize); id.SetFlags(MsgFlags.Identity); bool written = pipes[1].Write(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; 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.EMTHREAD); } 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; }
protected override bool XRecv(SendReceiveOptions flags, out Msg msg) { msg = null; if (m_prefetched) { if (!m_identitySent) { msg = m_prefetchedId; m_prefetchedId = null; m_identitySent = true; } else { msg = m_prefetchedMsg; m_prefetchedMsg = null; m_prefetched = false; } m_moreIn = msg.HasMore; return true; } Pipe[] pipe = new Pipe[1]; bool isMessageAvailable = m_fq.RecvPipe(pipe, out msg); // It's possible that we receive peer's identity. That happens // after reconnection. The current implementation assumes that // the peer always uses the same identity. // TODO: handle the situation when the peer changes its identity. while (isMessageAvailable && msg != null && msg.IsIdentity) isMessageAvailable = m_fq.RecvPipe(pipe, out msg); if (!isMessageAvailable) { return false; } else if (msg == null) { return true; } Debug.Assert(pipe[0] != null); // If we are in the middle of reading a message, just return the next part. if (m_moreIn) m_moreIn = msg.HasMore; else { // We are at the beginning of a message. // Keep the message part we have in the prefetch buffer // and return the ID of the peer instead. m_prefetchedMsg = msg; m_prefetched = true; Blob identity = pipe[0].Identity; msg = new Msg(identity.Data); msg.SetFlags(MsgFlags.More); m_identitySent = true; } return true; }
public virtual bool PushMsg(Msg msg) { // First message to receive is identity (if required). if (!m_identityReceived) { msg.SetFlags(MsgFlags.Identity); m_identityReceived = true; if (!m_options.RecvIdentity) { return true; } } if (m_pipe != null && m_pipe.Write(msg)) { return true; } ZError.ErrorNumber = (ErrorNumber.EAGAIN); return false; }
public void Send(Msg msg, SendReceiveOptions flags) { if (m_ctxTerminated) { throw TerminatingException.Create(); } // Check whether message passed to the function is valid. if (msg == null) { throw NetMQException.Create(ErrorCode.EFAULT); } // Process pending commands, if any. ProcessCommands(0, true); // Clear any user-visible flags that are set on the message. msg.ResetFlags(MsgFlags.More); // At this point we impose the flags on the message. if ((flags & SendReceiveOptions.SendMore) > 0) { msg.SetFlags(MsgFlags.More); } // Try to send the message. bool isMessageSent = XSend(msg, flags); if (isMessageSent) { return; } // In case of non-blocking send we'll simply propagate // the error - including EAGAIN - up the stack. if ((flags & SendReceiveOptions.DontWait) > 0 || m_options.SendTimeout == 0) { throw AgainException.Create(); } // Compute the time when the timeout should occur. // If the timeout is infite, don't care. int timeout = m_options.SendTimeout; long end = timeout < 0 ? 0 : (Clock.NowMs() + timeout); // Oops, we couldn't send the message. Wait for the next // command, process it and try to send the message again. // If timeout is reached in the meantime, return EAGAIN. while (true) { ProcessCommands(timeout, false); isMessageSent = XSend(msg, flags); if (isMessageSent) { break; } if (timeout > 0) { timeout = (int)(end - Clock.NowMs()); if (timeout <= 0) { throw AgainException.Create(); } } } }
protected override bool XSend(Msg msg, SendRecieveOptions flags) { // If we've sent a request and we still haven't got the reply, // we can't send another request. if (m_receivingReply) { throw new InvalidOperationException("Cannot send another request"); } bool rc; // First part of the request is the request identity. if (m_messageBegins) { Msg bottom = new Msg(); bottom.SetFlags (MsgFlags.More); rc = base.XSend (bottom, 0); if (!rc) return false; m_messageBegins = false; } bool more = msg.HasMore; rc = base.XSend (msg, flags); if (!rc) return rc; // If the request was fully sent, flip the FSM into reply-receiving state. if (!more) { m_receivingReply = true; m_messageBegins = true; } return true; }
/// <summary> /// Transmit the given Msg across the message-queueing system. /// If the msg fails to immediately send, then - if DontWait is specified and no SendTimeout was set /// then throw an AgainException. /// </summary> /// <param name="msg">the Msg to transmit</param> /// <param name="flags">a SendReceiveOptions: either don't specify DontWait, or set a timeout</param> public void Send(ref Msg msg, SendReceiveOptions flags) { CheckContextTerminated(); // Check whether message passed to the function is valid. if (!msg.IsInitialised) throw new FaultException("SocketBase.Send passed an uninitialised Msg."); // Process pending commands, if any. ProcessCommands(0, true); // Clear any user-visible flags that are set on the message. msg.ResetFlags(MsgFlags.More); // At this point we impose the flags on the message. if ((flags & SendReceiveOptions.SendMore) > 0) msg.SetFlags(MsgFlags.More); // Try to send the message. bool isMessageSent = XSend(ref msg); if (isMessageSent) return; // In case of non-blocking send we'll simply propagate // the error - including EAGAIN - up the stack. bool isDontWaitSet = (flags & SendReceiveOptions.DontWait) > 0; if (isDontWaitSet || m_options.SendTimeout == 0) { #if DEBUG string xMsg; if (isDontWaitSet && m_options.SendTimeout == 0) xMsg = "SocketBase.Send failed, and DontWait is true AND SendTimeout is 0."; else if (isDontWaitSet) xMsg = "SocketBase.Send failed and DontWait is specified."; else xMsg = "SocketBase.Send failed and no SendTimeout is specified."; throw new AgainException(innerException: null, message: xMsg); #else throw new AgainException(innerException: null, message: "SocketBase.Send failed"); #endif } // Compute the time when the timeout should occur. // If the timeout is infinite, don't care. int timeout = m_options.SendTimeout; long end = timeout < 0 ? 0 : (Clock.NowMs() + timeout); // Oops, we couldn't send the message. Wait for the next // command, process it and try to send the message again. // If timeout is reached in the meantime, return EAGAIN. while (true) { ProcessCommands(timeout, false); isMessageSent = XSend(ref msg); if (isMessageSent) break; if (timeout <= 0) continue; timeout = (int)(end - Clock.NowMs()); if (timeout <= 0) throw new AgainException(innerException: null, message: "SocketBase.Send failed and timeout <= 0"); } }
public void Receive(ref Msg msg, SendReceiveOptions options) { LastOptions = options; byte[] bytes = m_frames.Dequeue(); msg.InitGC(bytes, bytes.Length); if (m_frames.Count != 0) msg.SetFlags(MsgFlags.More); }
public void Send(Msg msg, SendReceiveOptions flags) { if (m_ctxTerminated) { throw TerminatingException.Create(); } // Check whether message passed to the function is valid. if (msg == null) { throw NetMQException.Create(ErrorCode.EFAULT); } // Process pending commands, if any. ProcessCommands(0, true); // Clear any user-visible flags that are set on the message. msg.ResetFlags(MsgFlags.More); // At this point we impose the flags on the message. if ((flags & SendReceiveOptions.SendMore) > 0) msg.SetFlags(MsgFlags.More); // Try to send the message. bool isMessageSent = XSend(msg, flags); if (isMessageSent) { return; } // In case of non-blocking send we'll simply propagate // the error - including EAGAIN - up the stack. if ((flags & SendReceiveOptions.DontWait) > 0 || m_options.SendTimeout == 0) throw AgainException.Create(); // Compute the time when the timeout should occur. // If the timeout is infite, don't care. int timeout = m_options.SendTimeout; long end = timeout < 0 ? 0 : (Clock.NowMs() + timeout); // Oops, we couldn't send the message. Wait for the next // command, process it and try to send the message again. // If timeout is reached in the meantime, return EAGAIN. while (true) { ProcessCommands(timeout, false); isMessageSent = XSend(msg, flags); if (isMessageSent) break; if (timeout > 0) { timeout = (int)(end - Clock.NowMs()); if (timeout <= 0) { throw AgainException.Create(); } } } }
public virtual bool PushMsg(ref Msg msg) { // First message to receive is identity (if required). if (!m_identityReceived) { msg.SetFlags(MsgFlags.Identity); m_identityReceived = true; if (!m_options.RecvIdentity) { msg.Close(); msg.InitEmpty(); return true; } } if (m_pipe != null && m_pipe.Write(ref msg)) { msg.InitEmpty(); return true; } return false; }
protected override bool XRecv(SendReceiveOptions flags, out Msg msg) { msg = null; if (m_prefetched) { if (!m_identitySent) { msg = m_prefetchedId; m_prefetchedId = null; m_identitySent = true; } else { msg = m_prefetchedMsg; m_prefetchedMsg = null; m_prefetched = false; } return true; } Pipe[] pipe = new Pipe[1]; bool isMessageAvailable = m_fq.RecvPipe(pipe, out m_prefetchedMsg); if (!isMessageAvailable) { return false; } else if (m_prefetchedMsg == null) { return true; } Debug.Assert(pipe[0] != null); Debug.Assert(!m_prefetchedMsg.HasMore); // We have received a frame with TCP data. // Rather than sendig this frame, we keep it in prefetched // buffer and send a frame with peer's ID. Blob identity = pipe[0].Identity; msg = new Msg(identity.Data, true); msg.SetFlags(MsgFlags.More); m_prefetched = true; m_identitySent = true; return true; }