public void ProcessMessage(IMessage msg, ITransportHeaders requestHeaders, Stream requestStream, out ITransportHeaders responseHeaders, out Stream responseStream) { UnixConnection connection = null; try { if (requestHeaders == null) { requestHeaders = new TransportHeaders(); } requestHeaders["__RequestUri"] = ((IMethodMessage)msg).Uri; connection = UnixConnectionPool.GetConnection(this._path); UnixMessageIO.SendMessageStream(connection.Stream, requestStream, requestHeaders, connection.Buffer); connection.Stream.Flush(); if (UnixMessageIO.ReceiveMessageStatus(connection.Stream, connection.Buffer) != MessageStatus.MethodMessage) { throw new RemotingException("Unknown response message from server"); } responseStream = UnixMessageIO.ReceiveMessageStream(connection.Stream, out responseHeaders, connection.Buffer); } finally { if (connection != null) { connection.Release(); } } }
private void ReadAsyncUnixMessage(object data) { ITransportHeaders transportHeader; IClientChannelSinkStack clientChannelSinkStack = (IClientChannelSinkStack)data; UnixConnection unixConnection = (UnixConnection)clientChannelSinkStack.Pop(this); try { if (UnixMessageIO.ReceiveMessageStatus(unixConnection.Stream, unixConnection.Buffer) != MessageStatus.MethodMessage) { throw new RemotingException("Unknown response message from server"); } Stream stream = UnixMessageIO.ReceiveMessageStream(unixConnection.Stream, out transportHeader, unixConnection.Buffer); unixConnection.Release(); unixConnection = null; clientChannelSinkStack.AsyncProcessResponse(transportHeader, stream); } catch { if (unixConnection != null) { unixConnection.Release(); } throw; } }
public void ProcessMessages() { byte[] numArray = new byte[256]; this._stream = new BufferedStream(new NetworkStream(this._client)); try { try { bool flag = false; while (!flag) { MessageStatus messageStatu = UnixMessageIO.ReceiveMessageStatus(this._stream, numArray); if (messageStatu == MessageStatus.MethodMessage) { this._sink.InternalProcessMessage(this, this._stream); } else if (messageStatu == MessageStatus.CancelSignal || messageStatu == MessageStatus.Unknown) { flag = true; } } } catch (Exception exception) { } } finally { this._stream.Close(); this._client.Close(); this._serverChannel.ReleaseConnection(Thread.CurrentThread); } }
public void AsyncProcessResponse (IServerResponseChannelSinkStack sinkStack, object state, IMessage msg, ITransportHeaders headers, Stream responseStream) { ClientConnection connection = (ClientConnection)state; NetworkStream stream = new NetworkStream (connection.Client); UnixMessageIO.SendMessageStream (stream, responseStream, headers, connection.Buffer); stream.Flush (); stream.Close (); }
public void AsyncProcessRequest(IClientChannelSinkStack sinkStack, IMessage msg, ITransportHeaders headers, Stream requestStream) { UnixConnection connection = null; bool isOneWay = RemotingServices.IsOneWay(((IMethodMessage)msg).MethodBase); try { if (headers == null) { headers = new TransportHeaders(); } headers ["__RequestUri"] = ((IMethodMessage)msg).Uri; // Sends the stream using a connection from the pool // and creates a WorkItem that will wait for the // response of the server connection = UnixConnectionPool.GetConnection(_path); UnixMessageIO.SendMessageStream(connection.Stream, requestStream, headers, connection.Buffer); connection.Stream.Flush(); if (!isOneWay) { sinkStack.Push(this, connection); ThreadPool.QueueUserWorkItem(new WaitCallback(data => { try { ReadAsyncUnixMessage(data); } catch {} }), sinkStack); } else { connection.Release(); } } catch { if (connection != null) { connection.Release(); } if (!isOneWay) { throw; } } }
private void ReadAsyncUnixMessage(object data) { // This method is called by a new thread to asynchronously // read the response to a request // The stack was provided as state data in QueueUserWorkItem IClientChannelSinkStack stack = (IClientChannelSinkStack)data; // The first sink in the stack is this sink. Pop it and // get the status data, which is the UnixConnection used to send // the request UnixConnection connection = (UnixConnection)stack.Pop(this); try { ITransportHeaders responseHeaders; // Read the response, blocking if necessary MessageStatus status = UnixMessageIO.ReceiveMessageStatus(connection.Stream, connection.Buffer); if (status != MessageStatus.MethodMessage) { throw new RemotingException("Unknown response message from server"); } Stream responseStream = UnixMessageIO.ReceiveMessageStream(connection.Stream, out responseHeaders, connection.Buffer); // Free the connection, so it can be reused connection.Release(); connection = null; // Ok, proceed with the other sinks stack.AsyncProcessResponse(responseHeaders, responseStream); } catch { if (connection != null) { connection.Release(); } throw; } }
public void ProcessMessages() { byte[] buffer = new byte[256]; _stream = new BufferedStream(new NetworkStream(_client)); try { bool end = false; while (!end) { MessageStatus type = UnixMessageIO.ReceiveMessageStatus(_stream, buffer); switch (type) { case MessageStatus.MethodMessage: _sink.InternalProcessMessage(this, _stream); break; case MessageStatus.Unknown: case MessageStatus.CancelSignal: end = true; break; } } } catch (Exception) { // Console.WriteLine (ex); } finally { try { _serverChannel.ReleaseConnection(Thread.CurrentThread); _stream.Close(); _client.Close(); } catch { } } }
internal void InternalProcessMessage(ClientConnection connection, Stream stream) { ITransportHeaders transportHeader; ITransportHeaders transportHeader1; Stream stream1; IMessage message; Stream stream2 = UnixMessageIO.ReceiveMessageStream(stream, out transportHeader, connection.Buffer); ServerChannelSinkStack serverChannelSinkStack = new ServerChannelSinkStack(); serverChannelSinkStack.Push(this, connection); switch (this.next_sink.ProcessMessage(serverChannelSinkStack, null, transportHeader, stream2, out message, out transportHeader1, out stream1)) { case ServerProcessing.Complete: { UnixMessageIO.SendMessageStream(stream, stream1, transportHeader1, connection.Buffer); stream.Flush(); break; } } }
internal void InternalProcessMessage(ClientConnection connection, Stream stream) { // Reads the headers and the request stream Stream requestStream; ITransportHeaders requestHeaders; requestStream = UnixMessageIO.ReceiveMessageStream(stream, out requestHeaders, connection.Buffer); /* try { * PeerCred cred = connection.Client.PeerCredential; * requestHeaders["__uid"] = cred.UserID; * } catch (Exception e) { * Console.WriteLine ("Couldn't get the peer cred: " + e); * } */ // Pushes the connection object together with the sink. This information // will be used for sending the response in an async call. ServerChannelSinkStack sinkStack = new ServerChannelSinkStack(); sinkStack.Push(this, connection); ITransportHeaders responseHeaders; Stream responseStream; IMessage responseMsg; ServerProcessing proc = next_sink.ProcessMessage(sinkStack, null, requestHeaders, requestStream, out responseMsg, out responseHeaders, out responseStream); switch (proc) { case ServerProcessing.Complete: UnixMessageIO.SendMessageStream(stream, responseStream, responseHeaders, connection.Buffer); stream.Flush(); break; case ServerProcessing.Async: case ServerProcessing.OneWay: break; } }
public void AsyncProcessRequest(IClientChannelSinkStack sinkStack, IMessage msg, ITransportHeaders headers, Stream requestStream) { UnixConnection connection = null; bool flag = RemotingServices.IsOneWay(((IMethodMessage)msg).MethodBase); try { if (headers == null) { headers = new TransportHeaders(); } headers["__RequestUri"] = ((IMethodMessage)msg).Uri; connection = UnixConnectionPool.GetConnection(this._path); UnixMessageIO.SendMessageStream(connection.Stream, requestStream, headers, connection.Buffer); connection.Stream.Flush(); if (flag) { connection.Release(); } else { sinkStack.Push(this, connection); ThreadPool.QueueUserWorkItem(new WaitCallback(this.ReadAsyncUnixMessage), sinkStack); } } catch { if (connection != null) { connection.Release(); } if (!flag) { throw; } } }