public void AsyncProcessRequest(IClientChannelSinkStack sinkStack, IMessage msg, ITransportHeaders headers, Stream stream) { Stream compStream; Stream origStream = stream; long origPos = stream.Position; if ((checkedCompress && serverCanCompress) || (!checkedCompress && assumeCompress)) { headers[CompressionHelper.CompressKey] = CompressionHelper.CompressedFlag; compStream = CompressionHelper.CompressStream(stream); sinkStack.Push(this, new RequestState(origStream, origPos, true, msg, headers)); } else { headers[CompressionHelper.CompressKey] = CompressionHelper.CompressRequest; compStream = stream; sinkStack.Push(this, null); } try { _next.AsyncProcessRequest(sinkStack, msg, headers, compStream); } catch (Exception) { } }
/// <summary> /// Processes an asynchronous request. /// </summary> /// <param name="sinkStack">Channel sink stack</param> /// <param name="msg">Message to processed</param> /// <param name="headers">Transport headers</param> /// <param name="stream">Request stream</param> public void AsyncProcessRequest(IClientChannelSinkStack sinkStack, IMessage msg, ITransportHeaders headers, Stream stream) { stream = CreateEnvelope(stream, headers); sinkStack.Push(this, null); _nextSink.AsyncProcessRequest(sinkStack, msg, headers, stream); }
public void AsyncProcessRequest( IClientChannelSinkStack sinkStack_in, IMessage msg_in, ITransportHeaders headers_in, Stream stream_in ) { #region encrypt... headers_in[EncryptionHelper.X_ENCRYPT] = "1"; headers_in[EncryptionHelper.X_CLIENTID] = this.clientid_; stream_in = EncryptionHelper.Encrypt( stream_in, false, this.keyspath_, this.clientid_ ); #endregion sinkStack_in.Push(this, null); this.nextchannelsink_.AsyncProcessRequest( sinkStack_in, msg_in, headers_in, stream_in ); }
public void AsyncProcessRequest(IClientChannelSinkStack sinkStack, IMessage msg, ITransportHeaders headers, Stream stream) { // перенаправляем вызов следующему приемнику в стеке sinkStack.Push(this, null); _nextSink.AsyncProcessRequest(sinkStack, msg, headers, stream); }
public void AsyncProcessRequest(IClientChannelSinkStack sinkStack, IMessage msg, ITransportHeaders headers, Stream stream) { CompressSinkHelper.SetClientSupportCompressFlag(headers); stream = CompressSinkHelper.CompressStream(headers, stream); sinkStack.Push(this, null); _next.AsyncProcessRequest(sinkStack, msg, headers, stream); }
/// <summary>Requests asynchronous processing of a method call on the current sink.</summary> /// <param name="sinkStack">A stack of channel sinks.</param> /// <param name="msg">The message to process.</param> /// <param name="headers">The headers to send to the server.</param> /// <param name="stream">The stream headed to the transport sink.</param> public void AsyncProcessRequest( IClientChannelSinkStack sinkStack, IMessage msg, ITransportHeaders headers, Stream stream) { AsyncProcessingState state = null; Stream encryptedStream = null; Guid id; lock (_transactionLock) // could be a big lock... probably a faster way, but for now suffices { // Establish connection information with the server; the roundtrip will hopefully // only be done once, so we ensure that we have the necessary information. id = EnsureIDAndProvider(msg, headers); // Protect ourselves a bit. If the asynchronous call fails because the server forgot about // us, we'll be in a bit of a fix. We'll need the current arguments as we'll need // to retry the request synchronously. Store them into a state object and use // that as the state when pushing ourself onto the stack. That way, AsyncProcessResponse // have access to it. state = new AsyncProcessingState(msg, headers, ref stream, id); // Send encrypted message by encrypting the stream encryptedStream = SetupEncryptedMessage(headers, stream); } // Push ourselves onto the stack with the necessary state and forward on to the next sink sinkStack.Push(this, state); _next.AsyncProcessRequest(sinkStack, msg, headers, encryptedStream); }
/// <summary> /// Verarbeitet eine Anfragenachricht asynchron. /// </summary> /// <param name="sinkStack">Senkenstapel</param> /// <param name="msg">Remoting-Nachricht</param> /// <param name="headers">Anfrage-Header-Auflistung</param> /// <param name="stream">Anfrage-Datenstrom</param> public void AsyncProcessRequest(IClientChannelSinkStack sinkStack, IMessage msg, ITransportHeaders headers, Stream stream) { // Asynchroner Verarbeitungsstatus AsyncProcessingState state = null; // Verschlüsselter Datenstrom Stream encryptedStream = null; // Eindeutige Kennung der Sicherheitstransaktion Guid _secureTransactionID; lock (_lockObject) { // Sicherheitstransaktion starten _secureTransactionID = StartSecureTransaction(msg, headers); // Asynchronen Verarbeitungsstatus erzeugen state = new AsyncProcessingState(msg, headers, ref stream, _secureTransactionID); // Nachricht verschlüsseln encryptedStream = EncryptMessage(headers, stream); } // Aktuelle Senke auf den Senkenstapel legen (Damit ggf. die Verarbeitung der Antwort später asynchron aufgerufen werden kann) sinkStack.Push(this, state); // Nächste Kanalsenke aufrufen _next.AsyncProcessRequest(sinkStack, msg, headers, encryptedStream); }
public void AsyncProcessRequest(IClientChannelSinkStack sinkStack, IMessage msg, ITransportHeaders headers, Stream stream) { // never gets called, this sink is always first sinkStack.Push(this, null); _nextSink.AsyncProcessRequest(sinkStack, msg, headers, stream); }
/// <summary> /// Requests asynchronous processing of a method call on the current sink. /// </summary> /// <param name="sinkStack">A stack of channel sinks that called this sink.</param> /// <param name="msg">The message to process.</param> /// <param name="headers">The headers to add to the outgoing message heading to the server.</param> /// <param name="stream">The stream headed to the transport sink.</param> /// <exception cref="T:System.Security.SecurityException">The immediate caller does not have infrastructure permission. </exception> public void AsyncProcessRequest(IClientChannelSinkStack sinkStack, IMessage msg, ITransportHeaders headers, Stream stream) { // Push this onto the sink stack. sinkStack.Push(this, null); // Send the request to the client. _next.AsyncProcessRequest(sinkStack, msg, headers, stream); }
} // ProcessMessage public void AsyncProcessRequest(IClientChannelSinkStack sinkStack, IMessage msg, ITransportHeaders headers, Stream stream) { HttpWebRequest httpWebRequest = ProcessAndSend(msg, headers, stream); sinkStack.Push(this, httpWebRequest); httpWebRequest.BeginGetResponse( new AsyncCallback(this.OnHttpMessageReturn), sinkStack); } // AsyncProcessRequest
void IClientChannelSink.AsyncProcessRequest(IClientChannelSinkStack sinkStack, IMessage msg, ITransportHeaders headers, Stream stream) { // process request object state = null; ProcessRequest(msg, headers, ref stream, ref state); // push to stack (to get a call to handle response) // and forward to the next sinkStack.Push(this, state); this.nextClientChannelSink.AsyncProcessRequest(sinkStack, msg, headers, stream); }
public void AsyncProcessRequest(IClientChannelSinkStack sinkStack, IMessage msg, ITransportHeaders headers, Stream stream) { // generate a compressed stream using NZipLib stream = CompressionHelper.getCompressedStreamCopy(stream); // push onto stack and forward the request sinkStack.Push(this, null); _nextSink.AsyncProcessRequest(sinkStack, msg, headers, stream); }
/// <summary> /// Requests asynchronous processing of a method call on the current sink. /// </summary> public void AsyncProcessRequest(IClientChannelSinkStack sinkStack, IMessage msg, ITransportHeaders headers, Stream stream) { // process request object state = null; ProcessRequest(headers, ref stream); // push to stack (to get a call to handle response) // and forward to the next sinkStack.Push(this, state); this.FNextSink.AsyncProcessRequest(sinkStack, msg, headers, stream); }
public void AsyncProcessRequest(IClientChannelSinkStack sinkStack, IMessage msg, ITransportHeaders headers, Stream requestStream) { TcpConnection connection = null; bool isOneWay = RemotingServices.IsOneWay(((IMethodMessage)msg).MethodBase); try { if (headers == null) { headers = new TransportHeaders(); } headers [CommonTransportKeys.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 = TcpConnectionPool.GetConnection(_host, _port); TcpMessageIO.SendMessageStream(connection.Stream, requestStream, headers, connection.Buffer, isOneWay); connection.Stream.Flush(); if (!isOneWay) { sinkStack.Push(this, connection); ThreadPool.QueueUserWorkItem(new WaitCallback(data => { try { ReadAsyncTcpMessage(data); } catch {} }), sinkStack); } else { connection.Release(); } } catch { if (connection != null) { connection.Release(); } if (!isOneWay) { throw; } } }
public void AsyncProcessRequest(IClientChannelSinkStack sinkStack, IMessage msg, ITransportHeaders headers, Stream stream) { headers["X-Compress"] = "yes"; stream = CompressionHelper.GetCompressedStreamCopy(stream); // push onto stack and forward the request sinkStack.Push(this, null); _nextSink.AsyncProcessRequest(sinkStack, msg, headers, stream); }
public void AsyncProcessRequest( IClientChannelSinkStack stack, IMessage msg, ITransportHeaders headers, Stream stream ) { #region Add hash to stream header string hash = HashHelper.GetHash(ref stream); headers[HashHelper.C_HASH_ITEM] = hash; //Debug.WriteLine("Client Side : client request stream hash is " + hash); #endregion stack.Push(this, null); _nextSink.AsyncProcessRequest(stack, msg, headers, stream); }
public void AsyncProcessRequest (IClientChannelSinkStack sinkStack, IMessage msg, ITransportHeaders headers, Stream requestStream) { bool isOneWay = RemotingServices.IsOneWay (((IMethodMessage)msg).MethodBase); HttpWebRequest request = CreateRequest (headers); using (Stream targetStream = request.GetRequestStream ()) { CopyStream (requestStream, targetStream, 1024); } if (!isOneWay) { sinkStack.Push (this, request); request.BeginGetResponse (new AsyncCallback (AsyncProcessResponseCallback), sinkStack); } }
public void AsyncProcessRequest(IClientChannelSinkStack sinkStack, IMessage msg, ITransportHeaders headers, Stream stream) { byte[] IV; stream = EncryptionHelper.ProcessOutboundStream(stream, _encryptionAlgorithm, _encryptionKey, out IV); headers["X-Encrypt"] = "yes"; headers["X-EncryptIV"] = Convert.ToBase64String(IV); // push onto stack and forward the request sinkStack.Push(this, null); _nextSink.AsyncProcessRequest(sinkStack, msg, headers, stream); }
/// <summary> /// 异步处理请求 /// </summary> /// <param name="sinkStack"></param> /// <param name="message"></param> /// <param name="requestHeaders"></param> /// <param name="requestStream"></param> public void AsyncProcessRequest( IClientChannelSinkStack sinkStack, IMessage message, ITransportHeaders requestHeaders, Stream requestStream) { // throw new NotImplementedException(); // 尽量实现此方法,因为如果此接收器注册到接收器链当中,不排除客户端会异步调用 IMethodCallMessage callMessage = message as IMethodCallMessage; Console.WriteLine($"{DateTime.Now:yyyy-MM-dd HH:mm:ss} 开始处理异步请求:{callMessage.MethodName}"); // 只有把当前接收器压入栈中时,异步响应(AsyncProcessResponse)的时候才会被执行 sinkStack.Push(this, callMessage.MethodName); NextChannelSink.AsyncProcessRequest(sinkStack, message, requestHeaders, requestStream); }
public void AsyncProcessRequest(IClientChannelSinkStack sinkStack, IMessage msg, ITransportHeaders headers, Stream requestStream) { bool isOneWay = RemotingServices.IsOneWay(((IMethodMessage)msg).MethodBase); HttpWebRequest request = CreateRequest(headers); using (Stream targetStream = request.GetRequestStream()) { CopyStream(requestStream, targetStream, 1024); } if (!isOneWay) { sinkStack.Push(this, request); request.BeginGetResponse(new AsyncCallback(AsyncProcessResponseCallback), sinkStack); } }
public void AsyncProcessRequest(IClientChannelSinkStack sinkStack, IMessage msg, ITransportHeaders headers, Stream stream) { AsyncProcessingState state = null; Stream encryptedStream = null; Guid id; lock (_transactionLock) { id = EnsureIDAndProvider(msg, headers); state = new AsyncProcessingState(msg, headers, ref stream, id); encryptedStream = SetupEncryptedMessage(headers, stream, null); } sinkStack.Push(this, state); _next.AsyncProcessRequest(sinkStack, msg, headers, encryptedStream); }
public void AsyncProcessRequest(IClientChannelSinkStack sinkStack, IMessage msg, ITransportHeaders headers, Stream stream) { RemotingResult result = cache.GetPreviousResults(msg, headers, true); if (result == null) { _asyncMessage = msg; _asyncHeaders = headers; sinkStack.Push(this, null); _nextSink.AsyncProcessRequest(sinkStack, msg, headers, stream); } else { _asyncMessage = null; AsyncProcessResponse(sinkStack, null, result.Headers, new MemoryStream(result.Response)); } }
/// <summary> /// Verarbeitet eine Anfragenachricht asynchron. /// </summary> /// <param name="sinkStack">Senkenstapel</param> /// <param name="msg">Remoting-Nachricht</param> /// <param name="headers">Anfrage-Header-Auflistung</param> /// <param name="stream">Anfrage-Datenstrom</param> public void AsyncProcessRequest(IClientChannelSinkStack sinkStack, IMessage msg, ITransportHeaders headers, Stream stream) { // Asynchroner Verarbeitungsstatus AsyncProcessingState state = null; lock (_lockObject) { // Asynchronen Verarbeitungsstatus erzeugen state = new AsyncProcessingState(msg, headers, ref stream, new Guid()); //Methode aufrufen die Verarbeitung übernimmt DoProcessMessageBefore(msg, headers, stream); } // Aktuelle Senke auf den Senkenstapel legen (Damit ggf. die Verarbeitung der Antwort später asynchron aufgerufen werden kann) sinkStack.Push(this, state); // Nächste Kanalsenke aufrufen _next.AsyncProcessRequest(sinkStack, msg, headers, stream); }
public void AsyncProcessRequest( IClientChannelSinkStack sinkStack_in, IMessage msg_in, ITransportHeaders headers_in, Stream stream_in ) { #region compress... headers_in[CompressionHelper.X_COMPRESS] = "1"; stream_in = CompressionHelper.GetCompressedStreamCopy( stream_in ); #endregion sinkStack_in.Push(this, null); this.nextchannelsink_.AsyncProcessRequest( sinkStack_in, msg_in, headers_in, stream_in ); }
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; } } }
/// <summary> /// Requests asynchronous processing of a method call on the current sink. /// </summary> /// <param name="sinkStack">A stack of channel sinks that called this sink.</param> /// <param name="msg">The message to process.</param> /// <param name="headers">The headers to add to the outgoing message heading to the server.</param> /// <param name="stream">The stream headed to the transport sink.</param> public void AsyncProcessRequest(IClientChannelSinkStack sinkStack, IMessage msg, ITransportHeaders headers, Stream stream) { AsyncProcessingState state = null; Stream encryptedStream = null; Guid _secureTransactionID; lock (_lockObject) { // Start the secure transaction and save its identifier _secureTransactionID = StartSecureTransaction(msg, headers); // Prepare asynchronous state state = new AsyncProcessingState(msg, headers, ref stream, _secureTransactionID); // Encrypt the message encryptedStream = EncryptMessage(headers, stream); } // Push the current sink onto the sink stack so the processing of the response can be invoked asynchronously later sinkStack.Push(this, state); // Pass the message on to the next sink _next.AsyncProcessRequest(sinkStack, msg, headers, encryptedStream); }
public void AsyncProcessRequest( IClientChannelSinkStack sinkStack, IMessage msg, ITransportHeaders headers, Stream stream) { // Push this onto the sink stack. sinkStack.Push(this, null); // Send the request to the client. _next.AsyncProcessRequest(sinkStack, msg, headers, stream); }
public void AsyncProcessRequest(IClientChannelSinkStack sinkStack, IMessage msg, ITransportHeaders headers, Stream stream) { sinkStack.Push(this, null); nextClientSink.AsyncProcessRequest(sinkStack, msg, headers, stream); }
/// <summary>Requests asynchronous processing of a method call on the current sink.</summary> /// <param name="sinkStack">A stack of channel sinks.</param> /// <param name="msg">The message to process.</param> /// <param name="headers">The headers to send to the server.</param> /// <param name="stream">The stream headed to the transport sink.</param> public void AsyncProcessRequest( IClientChannelSinkStack sinkStack, IMessage msg, ITransportHeaders headers, Stream stream) { AsyncProcessingState state = null; Stream encryptedStream = null; Guid id; lock(_transactionLock) // could be a big lock... probably a faster way, but for now suffices { // Establish connection information with the server; the roundtrip will hopefully // only be done once, so we ensure that we have the necessary information. id = EnsureIDAndProvider(msg, headers); // Protect ourselves a bit. If the asynchronous call fails because the server forgot about // us, we'll be in a bit of a fix. We'll need the current arguments as we'll need // to retry the request synchronously. Store them into a state object and use // that as the state when pushing ourself onto the stack. That way, AsyncProcessResponse // have access to it. state = new AsyncProcessingState(msg, headers, ref stream, id); // Send encrypted message by encrypting the stream encryptedStream = SetupEncryptedMessage(headers, stream); } // Push ourselves onto the stack with the necessary state and forward on to the next sink sinkStack.Push(this, state); _next.AsyncProcessRequest(sinkStack, msg, headers, encryptedStream); }
public void AsyncProcessRequest(IClientChannelSinkStack sinkStack, IMessage message, ITransportHeaders headers, Stream stream) { stream = Zip.Compress(stream); sinkStack.Push(this, null); this.m_NextSink.AsyncProcessRequest(sinkStack, message, headers, stream); }
public void AsyncProcessRequest (IClientChannelSinkStack sinkStack, IMessage msg, ITransportHeaders headers, Stream requestStream) { TcpConnection connection = null; bool isOneWay = RemotingServices.IsOneWay (((IMethodMessage)msg).MethodBase); try { if (headers == null) headers = new TransportHeaders(); headers [CommonTransportKeys.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 = TcpConnectionPool.GetConnection (_host, _port); TcpMessageIO.SendMessageStream (connection.Stream, requestStream, headers, connection.Buffer); connection.Stream.Flush (); if (!isOneWay) { sinkStack.Push (this, connection); ThreadPool.QueueUserWorkItem (new WaitCallback(ReadAsyncTcpMessage), sinkStack); } else connection.Release(); } catch { if (connection != null) connection.Release(); if (!isOneWay) throw; } }