diff options
Diffstat (limited to '')
-rw-r--r-- | src/jaegertracing/thrift/lib/haxe/src/org/apache/thrift/server/TSimpleServer.hx | 141 |
1 files changed, 141 insertions, 0 deletions
diff --git a/src/jaegertracing/thrift/lib/haxe/src/org/apache/thrift/server/TSimpleServer.hx b/src/jaegertracing/thrift/lib/haxe/src/org/apache/thrift/server/TSimpleServer.hx new file mode 100644 index 000000000..0600744d3 --- /dev/null +++ b/src/jaegertracing/thrift/lib/haxe/src/org/apache/thrift/server/TSimpleServer.hx @@ -0,0 +1,141 @@ +/* + * 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. + */ + +package org.apache.thrift.server; + +import org.apache.thrift.*; +import org.apache.thrift.protocol.*; +import org.apache.thrift.transport.*; +import org.apache.thrift.meta_data.*; + +// Simple single-threaded server for testing +class TSimpleServer extends TServer { + + private var stop : Bool = false; + + //stops just after input transport returns EOF + //useful for limited scenarios, like embeding into php server + public var runOnce : Bool = false; + + public function new( processor : TProcessor, + serverTransport : TServerTransport, + transportFactory : TTransportFactory = null, + protocolFactory : TProtocolFactory = null, + logger : Dynamic->Void = null) { + super( processor, serverTransport, + transportFactory, transportFactory, + protocolFactory, protocolFactory, + logger); + } + + + public override function Serve() : Void + { + try + { + serverTransport.Listen(); + } + catch (ttx : TTransportException) + { + logDelegate(ttx); + return; + } + + // Fire the preServe server event when server is up, + // but before any client connections + if (serverEventHandler != null) { + serverEventHandler.preServe(); + } + + while( ! stop) + { + var client : TTransport = null; + var inputTransport : TTransport = null; + var outputTransport : TTransport = null; + var inputProtocol : TProtocol = null; + var outputProtocol : TProtocol = null; + var connectionContext : Dynamic = null; + try + { + client = serverTransport.Accept(); + if (client != null) { + inputTransport = inputTransportFactory.getTransport( client); + outputTransport = outputTransportFactory.getTransport( client); + inputProtocol = inputProtocolFactory.getProtocol( inputTransport); + outputProtocol = outputProtocolFactory.getProtocol( outputTransport); + + // Recover event handler (if any) and fire createContext + // server event when a client connects + if (serverEventHandler != null) { + connectionContext = serverEventHandler.createContext(inputProtocol, outputProtocol); + } + + // Process client requests until client disconnects + while( true) { + // Fire processContext server event + // N.B. This is the pattern implemented in C++ and the event fires provisionally. + // That is to say it may be many minutes between the event firing and the client request + // actually arriving or the client may hang up without ever makeing a request. + if (serverEventHandler != null) { + serverEventHandler.processContext(connectionContext, inputTransport); + } + + //Process client request (blocks until transport is readable) + if( ! processor.process( inputProtocol, outputProtocol)) { + break; + } + } + } + } + catch( ttx : TTransportException) + { + // Usually a client disconnect, expected + if(runOnce && ttx.errorID == TTransportException.END_OF_FILE) { + //input returns eof, exit + //follows lib/cpp/src/thrift/server/TServerFramework.cpp + Stop(); + } + } + catch( pex : TProtocolException) + { + logDelegate('$pex ${pex.errorID} ${pex.errorMsg}'); // Unexpected + } + catch( e : Dynamic) + { + logDelegate(e); // Unexpected + } + + if(client != null && !runOnce) + { + client.close(); + } + + // Fire deleteContext server event after client disconnects + if (serverEventHandler != null) { + serverEventHandler.deleteContext(connectionContext, inputProtocol, outputProtocol); + } + } + } + + public override function Stop() : Void + { + stop = true; + serverTransport.Close(); + } +} |