Subversion Repositories SmartDukaan

/**
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements. See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership. The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License. You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied. See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 * Contains some contributions under the Thrift Software License.
 * Please see doc/old-thrift-license.txt in the Thrift distribution for
 * details.
 */

using System;
using Thrift.Transport;
using Thrift.Protocol;

namespace Thrift.Server
{
        /// <summary>
        /// Simple single-threaded server for testing
        /// </summary>
        public class TSimpleServer : TServer
        {
                private bool stop = false;

                public TSimpleServer(TProcessor processor,
                                                  TServerTransport serverTransport)
                        :base(processor, serverTransport, new TTransportFactory(), new TTransportFactory(), new TBinaryProtocol.Factory(), new TBinaryProtocol.Factory(), DefaultLogDelegate)
                {
                }

                public TSimpleServer(TProcessor processor,
                                                        TServerTransport serverTransport,
                                                        LogDelegate logDel)
                        : base(processor, serverTransport, new TTransportFactory(), new TTransportFactory(), new TBinaryProtocol.Factory(), new TBinaryProtocol.Factory(), logDel)
                {
                }

                public TSimpleServer(TProcessor processor,
                                                  TServerTransport serverTransport,
                                                  TTransportFactory transportFactory)
                        :base(processor,
                                 serverTransport,
                                 transportFactory,
                                 transportFactory,
                                 new TBinaryProtocol.Factory(),
                                 new TBinaryProtocol.Factory(),
                             DefaultLogDelegate)
                {
                }

                public TSimpleServer(TProcessor processor,
                                                  TServerTransport serverTransport,
                                                  TTransportFactory transportFactory,
                                                  TProtocolFactory protocolFactory)
                        :base(processor,
                                 serverTransport,
                                 transportFactory,
                                 transportFactory,
                                 protocolFactory,
                                 protocolFactory,
                                 DefaultLogDelegate)
                {
                }

                public override void Serve()
                {
                        try
                        {
                                serverTransport.Listen();
                        }
                        catch (TTransportException ttx)
                        {
                                logDelegate(ttx.ToString());
                                return;
                        }

                        while (!stop)
                        {
                                TTransport client = null;
                                TTransport inputTransport = null;
                                TTransport outputTransport = null;
                                TProtocol inputProtocol = null;
                                TProtocol outputProtocol = null;
                                try
                                {
                                        client = serverTransport.Accept();
                                        if (client != null)
                                        {
                                                inputTransport = inputTransportFactory.GetTransport(client);
                                                outputTransport = outputTransportFactory.GetTransport(client);
                                                inputProtocol = inputProtocolFactory.GetProtocol(inputTransport);
                                                outputProtocol = outputProtocolFactory.GetProtocol(outputTransport);
                                                while (processor.Process(inputProtocol, outputProtocol)) { }
                                        }
                                }
                                catch (TTransportException ttx)
                                {
                                        // Client died, just move on
                                        if (stop)
                                        {
                                                logDelegate("TSimpleServer was shutting down, caught " + ttx.GetType().Name);
                                        }
                                }
                                catch (Exception x)
                                {
                                        logDelegate(x.ToString());
                                }

                                if (inputTransport != null)
                                {
                                        inputTransport.Close();
                                }

                                if (outputTransport != null)
                                {
                                        outputTransport.Close();
                                }
                        }

                        if (stop)
                        {
                                try
                                {
                                        serverTransport.Close();
                                }
                                catch (TTransportException ttx)
                                {
                                        logDelegate("TServerTranport failed on close: " + ttx.Message);
                                }
                                stop = false;
                        }
                }

                public override void Stop()
                {
                        stop = true;
                        serverTransport.Close();
                }
        }
}