update source to Ceph Pacific 16.2.2

[ceph.git] / ceph / src / jaegertracing / thrift / lib / haxe / src / org / apache / thrift / server / TSimpleServer.hx

diff --git a/ceph/src/jaegertracing/thrift/lib/haxe/src/org/apache/thrift/server/TSimpleServer.hx b/ceph/src/jaegertracing/thrift/lib/haxe/src/org/apache/thrift/server/TSimpleServer.hx
new file mode 100644 (file)
index 0000000..0600744
--- /dev/null
+++ b/ceph/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();
+    }
+}