Exemple #1
0
        public void ProcessMessage(IMessage msg,
                                   ITransportHeaders reqHead,
                                   Stream reqStm,
                                   out ITransportHeaders respHead,
                                   out Stream respStm)
        {
            DBG.Info(null, "Being asked to process the serialized message!");
            //Console.WriteLine("ProcessMessage TID {0}", Thread.CurrentThread.GetHashCode());

            // Send the message across the pipe.
            PipeConnection _pipe = SendWithRetry(msg, reqHead, reqStm);

            respHead = null;
            respStm  = null;
            // Read response
            if (_pipe != null)
            {
                _pipe.BeginReadMessage();
                respHead = _pipe.ReadHeaders();
                respHead["__CustomErrorsEnabled"] = false;
                respStm = _pipe.ReadStream();
                _pipe.EndReadMessage();

                if (_pipeConnectionPool != null)
                {
                    _pipeConnectionPool.ReturnToPool(_pipe);
                }

                _pipe = null;
            }
        }
Exemple #2
0
        public void AsyncProcessRequest(IClientChannelSinkStack stack,
                                        IMessage msg,
                                        ITransportHeaders headers,
                                        Stream stream)
        {
            DBG.Info(null, "Async: Send the message across the pipe");

            PipeConnection _pipe = SendWithRetry(msg, headers, stream);

            IMethodCallMessage mcm        = (IMethodCallMessage)msg;
            MethodBase         methodBase = mcm.MethodBase;
            bool oneway = RemotingServices.IsOneWay(methodBase);

            if (oneway)
            {
                if (_pipeConnectionPool != null)
                {
                    _pipeConnectionPool.ReturnToPool(_pipe);
                }
                _pipe = null;
            }
            else
            {
                PipeConnectionCookie cookie = new PipeConnectionCookie();

                cookie.pipe      = _pipe;
                cookie.sinkStack = stack;

                //TODO Switch to use Completion port
                ThreadPool.QueueUserWorkItem(callback, cookie);
            }
        }
        public ITransportHeaders ReadHeaders()
        {
            TransportHeaders headers = new TransportHeaders();

            // read uri (and make sure that no channel specific data is present)
            String uri = ReadString();

            if (uri != "" && uri != null)
            {
                String chanuri, objuri;
                chanuri = PipeConnection.Parse(uri, out objuri);
                if (chanuri == null)
                {
                    objuri = uri;
                }
                headers[CommonTransportKeys.RequestUri] = objuri;
            }

            // read to end of headers
            ushort marker = ReadUShort();

            while (marker == HeaderMarker)
            {
                String hname  = ReadString();
                String hvalue = ReadString();

                headers[hname] = hvalue;

                marker = ReadUShort();
            }

            return(headers);
        }
 public void ReturnToPool(Object obj)
 {
     lock (_list)
     {
         PipeConnection _pipe = (PipeConnection)obj;
         _pipe.UpdateLastTimeAccessed();
         _list.Add(obj);
     }
 }
 private void WriteExceptionResponse(PipeConnection pipe, string exceptionMessage)
 {
     try
     {
         MemoryStream stream = new MemoryStream(System.Text.Encoding.ASCII.GetBytes(exceptionMessage));
         pipe.BeginWriteMessage();
         pipe.Write(stream);
         pipe.EndWriteMessage();
     }
     catch { }
 }
        public void Dispose()
        {
            StopListening(null);

            if (_pipe != null)
            {
                _pipe.Dispose();
                _pipe = null;
            }

            //TODO: Cancel listeners.
        }
Exemple #7
0
        internal PipeClientTransportSink(String url)
        {
            String objuri  = null;
            String chanuri = PipeConnection.Parse(url, out objuri);

            DBG.Info(null, "PipeClientTransportSink: creating pipe on uri: " + chanuri);
            //Console.WriteLine("PipeClientTransportSink {0}", chanuri);

            _pipeName           = chanuri;
            _pipeConnectionPool = PipeConnectionPoolManager.LookupPool(_pipeName);

            callback = new WaitCallback(this.ReceiveCallback);
        }
Exemple #8
0
        private void ReceiveCallback(Object state)
        {
            //Console.WriteLine("ReceiveCallback TID {0}", Thread.CurrentThread.GetHashCode());

            PipeConnectionCookie cookie = (PipeConnectionCookie)state;

            PipeConnection          _pipe     = cookie.pipe;
            IClientChannelSinkStack sinkStack = cookie.sinkStack;

            try
            {
                // Read response
                //
                _pipe.BeginReadMessage();

                ITransportHeaders responseHeaders = _pipe.ReadHeaders();
                responseHeaders["__CustomErrorsEnabled"] = false;

                Stream responseStream = _pipe.ReadStream();
                _pipe.EndReadMessage();

                if (_pipeConnectionPool != null)
                {
                    _pipeConnectionPool.ReturnToPool(_pipe);
                }

                _pipe = null;

                sinkStack.AsyncProcessResponse(responseHeaders, responseStream);
            }
            catch (Exception e)
            {
                try
                {
                    if (sinkStack != null)
                    {
                        sinkStack.DispatchException(e);
                    }
                }
                catch (Exception)
                {
                    // Fatal Error.. ignore
                }
            }
        } // ReceiveCallback
        private void ListenerMain()
        {
            // Common ThreadStart delegate
            ThreadStart ts = new ThreadStart(this.ServerMain);

            Thread.CurrentThread.IsBackground = true;

            while (true)
            {
                try
                {
                    _pipe = new PipeConnection(m_pipeName, true, m_pipeSecurityDescriptor);

                    //TODO switch to use completion ports
                    // Wait for a client to connect
                    bool connected = _pipe.WaitForConnect();

                    if (!connected)
                    {
                        throw new PipeIOException("Could not connect to the pipe - os returned " + Marshal.GetLastWin32Error());
                    }
                    else
                    {
                        //TODO Consider using ThreadPool.QueueUserWorkItem

                        Thread server = new Thread(ts);
                        server.IsBackground = true;
                        server.Start();
                    }

                    // Wait for the handler to spin up:
                    _event.WaitOne();
                }
                catch (Exception e)
                {
                    e = e;
                }
            }
        }
        ////////////////////////////////////////////////////////////

        public void CloseStaleConnections()
        {
            ArrayList _activeConnections = new ArrayList();

            foreach (Object obj in _list)
            {
                PipeConnection _pipe = (PipeConnection)obj;

                if (_pipe.IsConnectionStale() == true)
                {
                    DBG.Info(null, "Disposing of stale connection");
                    _pipe.Dispose();
                    _pipe = null;
                }
                else
                {
                    _activeConnections.Add(_pipe);
                }
            }

            _list = _activeConnections;
        }
        private void WriteClientResponse(PipeConnection pipe,
                                         ITransportHeaders headers,
                                         Stream responseStream)
        {
            String uri;
            Object oUri = headers[CommonTransportKeys.RequestUri];

            if (oUri != null)
            {
                uri = oUri.ToString();
            }
            else
            {
                uri = "";
            }

            pipe.BeginWriteMessage();
            pipe.WriteHeaders(
                uri,
                headers);

            pipe.Write(responseStream);
            pipe.EndWriteMessage();
        }
        public void Dispose()
        {
            StopListening(null);

            if (_pipe != null)
            {
                _pipe.Dispose();
                _pipe = null;
            }

            //TODO: Cancel listeners.
        }
        public PipeConnection SendWithRetry(IMessage msg, 
                                   ITransportHeaders reqHead,
                                   Stream reqStm)
        {
            IMethodCallMessage mcm = (IMethodCallMessage)msg;

            String uri = mcm.Uri;
            PipeConnection _pipe = null;

            int tryCount = _defaultRetryCount;
            long reqStmPosition = -1;

            if (reqStm.CanSeek == false)
                tryCount=1;
            else
                reqStmPosition = reqStm.Position;

            while ( tryCount>0)
            {
                try
                {
                    if (_pipeConnectionPool != null)
                    {
                        DBG.Info(null, "Look in pipe connection in pool");
                        _pipe = (PipeConnection)_pipeConnectionPool.Obtain();
                    }

                    // otherwise create a new connection
                    if (_pipe == null)
                    {
                        _pipe = new PipeConnection(_pipeName, false, IntPtr.Zero);
                    }

                    //Send with Retry
                    _pipe.BeginWriteMessage();
                    _pipe.WriteHeaders(uri, reqHead);
                    _pipe.Write(reqStm);
                    _pipe.EndWriteMessage();

                    tryCount=0;
                }
                catch(PipeIOException pe)
                {
                    pe=pe;
                    if (_pipe != null)
                    {
                        _pipe.Dispose();
                        _pipe = null;
                    }

                   tryCount--;
                   reqStm.Position = reqStmPosition;
                }
            }

            return _pipe;
        }
Exemple #14
0
 public String Parse(String url, out string uri)
 {
     return(PipeConnection.Parse(url, out uri));
 }
 private void WriteExceptionResponse(PipeConnection pipe, string exceptionMessage)
 {
     try
     {
         MemoryStream stream = new MemoryStream(System.Text.Encoding.ASCII.GetBytes(exceptionMessage));
         pipe.BeginWriteMessage();
         pipe.Write(stream);
         pipe.EndWriteMessage();
     }
     catch { }
 }
        private void WriteClientResponse(PipeConnection pipe,
                                         ITransportHeaders headers,
                                         Stream responseStream)
        {
            String uri;
            Object oUri = headers[CommonTransportKeys.RequestUri];
            if (oUri != null)
            {
                uri = oUri.ToString();
            }
            else
            {
                uri = "";
            }

            pipe.BeginWriteMessage();
            pipe.WriteHeaders(
                                uri,
                                headers);

            pipe.Write(responseStream);
            pipe.EndWriteMessage();
        }
        private void ServerMain()
        {
            PipeConnection pipe = _pipe;
            _pipe = null;

            // Signal the guy to start waiting again... (w/ new event and endpoint)
            _event.Set();

            try
            {
                //TODO close the connection on a timeout
                //TODO if no activity for Nnnn milliseconds
                while (true)
                {
                    pipe.BeginReadMessage();
                    ITransportHeaders headers = pipe.ReadHeaders();
                    headers["__CustomErrorsEnabled"] = false;

                    Stream request = pipe.ReadStream();
                    pipe.EndReadMessage();

                    ServerChannelSinkStack stack = new ServerChannelSinkStack();
                    stack.Push(_transportSink, null);

                    IMessage responseMsg;
                    ITransportHeaders responseHeaders;
                    Stream responseStream;

                    ServerProcessing processing = _transportSink.NextChannelSink.ProcessMessage(stack,
                                                                    null,
                                                                    headers,
                                                                    request,
                                                                    out responseMsg,
                                                                    out responseHeaders,
                                                                    out responseStream);

                    // handle response
                    switch (processing)
                    {
                        case ServerProcessing.Complete:
                            // Send the response. Call completed synchronously.
                            stack.Pop(_transportSink);
                            WriteClientResponse(pipe, responseHeaders, responseStream);
                            break;

                        case ServerProcessing.OneWay:
                            break;

                        case ServerProcessing.Async:
                            stack.StoreAndDispatch(_transportSink, null);
                            break;
                    }
                }
            }
            catch (Exception e)
            {
                DBG.Info(null, "Terminating client connection: " + e.Message);
                WriteExceptionResponse(pipe, e.ToString());
            }
            finally
            {
                if (pipe != null)
                {
                    pipe.Dispose();
                }
               }
        }
        private void ServerMain()
        {
            PipeConnection pipe = _pipe;

            _pipe = null;

            // Signal the guy to start waiting again... (w/ new event and endpoint)
            _event.Set();

            try
            {
                //TODO close the connection on a timeout
                //TODO if no activity for Nnnn milliseconds
                while (true)
                {
                    pipe.BeginReadMessage();
                    ITransportHeaders headers = pipe.ReadHeaders();
                    headers["__CustomErrorsEnabled"] = false;

                    Stream request = pipe.ReadStream();
                    pipe.EndReadMessage();

                    ServerChannelSinkStack stack = new ServerChannelSinkStack();
                    stack.Push(_transportSink, null);

                    IMessage          responseMsg;
                    ITransportHeaders responseHeaders;
                    Stream            responseStream;

                    ServerProcessing processing = _transportSink.NextChannelSink.ProcessMessage(stack,
                                                                                                null,
                                                                                                headers,
                                                                                                request,
                                                                                                out responseMsg,
                                                                                                out responseHeaders,
                                                                                                out responseStream);

                    // handle response
                    switch (processing)
                    {
                    case ServerProcessing.Complete:
                        // Send the response. Call completed synchronously.
                        stack.Pop(_transportSink);
                        WriteClientResponse(pipe, responseHeaders, responseStream);
                        break;

                    case ServerProcessing.OneWay:
                        break;

                    case ServerProcessing.Async:
                        stack.StoreAndDispatch(_transportSink, null);
                        break;
                    }
                }
            }
            catch (Exception e)
            {
                DBG.Info(null, "Terminating client connection: " + e.Message);
                WriteExceptionResponse(pipe, e.ToString());
            }
            finally
            {
                if (pipe != null)
                {
                    pipe.Dispose();
                }
            }
        }
Exemple #19
0
        public PipeConnection SendWithRetry(IMessage msg,
                                            ITransportHeaders reqHead,
                                            Stream reqStm)
        {
            IMethodCallMessage mcm = (IMethodCallMessage)msg;

            String         uri   = mcm.Uri;
            PipeConnection _pipe = null;

            int  tryCount       = _defaultRetryCount;
            long reqStmPosition = -1;

            if (reqStm.CanSeek == false)
            {
                tryCount = 1;
            }
            else
            {
                reqStmPosition = reqStm.Position;
            }

            while (tryCount > 0)
            {
                try
                {
                    if (_pipeConnectionPool != null)
                    {
                        DBG.Info(null, "Look in pipe connection in pool");
                        _pipe = (PipeConnection)_pipeConnectionPool.Obtain();
                    }

                    // otherwise create a new connection
                    if (_pipe == null)
                    {
                        _pipe = new PipeConnection(_pipeName, false, IntPtr.Zero);
                    }

                    //Send with Retry
                    _pipe.BeginWriteMessage();
                    _pipe.WriteHeaders(uri, reqHead);
                    _pipe.Write(reqStm);
                    _pipe.EndWriteMessage();

                    tryCount = 0;
                }
                catch (PipeIOException pe)
                {
                    pe = pe;
                    if (_pipe != null)
                    {
                        _pipe.Dispose();
                        _pipe = null;
                    }


                    tryCount--;
                    reqStm.Position = reqStmPosition;
                }
            }

            return(_pipe);
        }
        private void ListenerMain()
        {
            // Common ThreadStart delegate
            ThreadStart ts = new ThreadStart(this.ServerMain);

            Thread.CurrentThread.IsBackground = true;

            while(true)
            {
                try
                {
                    _pipe  = new PipeConnection(m_pipeName, true, m_pipeSecurityDescriptor);

                    //TODO switch to use completion ports
                    // Wait for a client to connect
                    bool connected = _pipe.WaitForConnect();

                    if (!connected)
                    {
                        throw new PipeIOException("Could not connect to the pipe - os returned " + Marshal.GetLastWin32Error());
                    }
                    else
                    {
                        //TODO Consider using ThreadPool.QueueUserWorkItem

                        Thread server = new Thread(ts);
                        server.IsBackground = true;
                        server.Start();
                    }

                    // Wait for the handler to spin up:
                    _event.WaitOne();
                }
                catch(Exception e)
                {
                    e=e;
                }

            }
        }