diff options
Diffstat (limited to 'src/jaegertracing/thrift/test/haxe')
22 files changed, 2806 insertions, 0 deletions
diff --git a/src/jaegertracing/thrift/test/haxe/Makefile.am b/src/jaegertracing/thrift/test/haxe/Makefile.am new file mode 100644 index 000000000..6c0483e9e --- /dev/null +++ b/src/jaegertracing/thrift/test/haxe/Makefile.am @@ -0,0 +1,104 @@ +# +# 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. +# + +THRIFTCMD = $(THRIFT) --gen haxe -r +THRIFTTEST = $(top_srcdir)/test/ThriftTest.thrift + +BIN_CPP = bin/Main-debug +BIN_PHP = bin/php/Main-debug.php +BIN_PHP_WEB = bin/php-web-server/Main-debug.php + +gen-haxe/thrift/test/ThriftTest.hx: $(THRIFTTEST) + $(THRIFTCMD) $(THRIFTTEST) + +all-local: $(BIN_CPP) $(BIN_PHP) $(BIN_PHP_WEB) + +$(BIN_CPP): \ + src/*.hx \ + ../../lib/haxe/src/org/apache/thrift/**/*.hx \ + gen-haxe/thrift/test/ThriftTest.hx + $(HAXE) --cwd . cpp.hxml + +$(BIN_PHP): \ + src/*.hx \ + ../../lib/haxe/src/org/apache/thrift/**/*.hx \ + gen-haxe/thrift/test/ThriftTest.hx + $(HAXE) --cwd . php.hxml + +$(BIN_PHP_WEB): \ + src/*.hx \ + ../../lib/haxe/src/org/apache/thrift/**/*.hx \ + gen-haxe/thrift/test/ThriftTest.hx + $(HAXE) --cwd . php-web-server.hxml + + + +#TODO: other haxe targets +# $(HAXE) --cwd . csharp +# $(HAXE) --cwd . flash +# $(HAXE) --cwd . java +# $(HAXE) --cwd . javascript +# $(HAXE) --cwd . neko +# $(HAXE) --cwd . python # needs Haxe 3.2.0 + + +clean-local: + $(RM) -r gen-haxe bin + +.NOTPARALLEL: + +check: check_cpp \ + check_php \ + check_php_web + +check_cpp: $(BIN_CPP) + timeout 20 $(BIN_CPP) server & + sleep 1 + $(BIN_CPP) client + sleep 10 + +check_php: $(BIN_PHP) + timeout 20 php -f $(BIN_PHP) server & + sleep 1 + php -f $(BIN_PHP) client + sleep 10 + +check_php_web: $(BIN_PHP_WEB) $(BIN_CPP) + timeout 20 php -S 127.0.0.1:9090 router.php & + sleep 1 + $(BIN_CPP) client --transport http + sleep 10 + + +EXTRA_DIST = \ + src \ + cpp.hxml \ + csharp.hxml \ + flash.hxml \ + java.hxml \ + javascript.hxml \ + neko.hxml \ + php.hxml \ + python.hxml \ + router.php \ + project.hide \ + php-web-server.hxml \ + TestClientServer.hxproj \ + make_all.bat \ + make_all.sh diff --git a/src/jaegertracing/thrift/test/haxe/TestClientServer.hxproj b/src/jaegertracing/thrift/test/haxe/TestClientServer.hxproj new file mode 100644 index 000000000..6696d80c2 --- /dev/null +++ b/src/jaegertracing/thrift/test/haxe/TestClientServer.hxproj @@ -0,0 +1,67 @@ +<?xml version="1.0" encoding="utf-8"?> +<project version="2"> + <!-- Output SWF options --> + <output> + <movie outputType="Application" /> + <movie input="" /> + <movie path="bin/TestClientServer" /> + <movie fps="30" /> + <movie width="800" /> + <movie height="600" /> + <movie version="1" /> + <movie minorVersion="0" /> + <movie platform="C++" /> + <movie background="#FFFFFF" /> + </output> + <!-- Other classes to be compiled into your SWF --> + <classpaths> + <class path="src" /> + <class path="gen-haxe" /> + <class path="../../lib/haxe/src" /> + </classpaths> + <!-- Build options --> + <build> + <option directives="" /> + <option flashStrict="False" /> + <option noInlineOnDebug="False" /> + <option mainClass="Main" /> + <option enabledebug="False" /> + <option additional="" /> + </build> + <!-- haxelib libraries --> + <haxelib> + <!-- example: <library name="..." /> --> + </haxelib> + <!-- Class files to compile (other referenced classes will automatically be included) --> + <compileTargets> + <!-- example: <compile path="..." /> --> + </compileTargets> + <!-- Paths to exclude from the Project Explorer tree --> + <hiddenPaths> + <hidden path="obj" /> + <hidden path="cpp.hxml" /> + <hidden path="csharp.hxml" /> + <hidden path="flash.hxml" /> + <hidden path="java.hxml" /> + <hidden path="javascript.hxml" /> + <hidden path="make_all.bat" /> + <hidden path="make_all.sh" /> + <hidden path="Makefile.am" /> + <hidden path="neko.hxml" /> + <hidden path="php.hxml" /> + <hidden path="project.hide" /> + <hidden path="python.hxml" /> + </hiddenPaths> + <!-- Executed before build --> + <preBuildCommand>thrift -r -gen haxe ../ThriftTest.thrift</preBuildCommand> + <!-- Executed after build --> + <postBuildCommand alwaysRun="False" /> + <!-- Other project options --> + <options> + <option showHiddenPaths="False" /> + <option testMovie="Unknown" /> + <option testMovieCommand="" /> + </options> + <!-- Plugin storage --> + <storage /> +</project>
\ No newline at end of file diff --git a/src/jaegertracing/thrift/test/haxe/cpp.hxml b/src/jaegertracing/thrift/test/haxe/cpp.hxml new file mode 100644 index 000000000..6adb52d7e --- /dev/null +++ b/src/jaegertracing/thrift/test/haxe/cpp.hxml @@ -0,0 +1,41 @@ +# +# 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. +# + +#integrate files to classpath +-cp src +-cp gen-haxe +-cp ../../lib/haxe/src + +#this class wil be used as entry point for your app. +-main Main + +#CPP target +-cpp bin + +#To produce 64 bit binaries the file should define the HXCPP_M64 compile variable: +#-D HXCPP_M64 + +#Add debug information +-debug + +#dead code elimination : remove unused code +#"-dce no" : do not remove unused code +#"-dce std" : remove unused code in the std lib (default) +#"-dce full" : remove all unused code +-dce full
\ No newline at end of file diff --git a/src/jaegertracing/thrift/test/haxe/csharp.hxml b/src/jaegertracing/thrift/test/haxe/csharp.hxml new file mode 100644 index 000000000..295c017e7 --- /dev/null +++ b/src/jaegertracing/thrift/test/haxe/csharp.hxml @@ -0,0 +1,38 @@ +# +# 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. +# + +#integrate files to classpath +-cp src +-cp gen-haxe +-cp ../../lib/haxe/src + +#this class wil be used as entry point for your app. +-main Main + +#CSHARP target +-cs bin/Tutorial.exe + +#Add debug information +-debug + +#dead code elimination : remove unused code +#"-dce no" : do not remove unused code +#"-dce std" : remove unused code in the std lib (default) +#"-dce full" : remove all unused code +-dce full
\ No newline at end of file diff --git a/src/jaegertracing/thrift/test/haxe/flash.hxml b/src/jaegertracing/thrift/test/haxe/flash.hxml new file mode 100644 index 000000000..a1f0568ad --- /dev/null +++ b/src/jaegertracing/thrift/test/haxe/flash.hxml @@ -0,0 +1,41 @@ +# +# 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. +# + +#integrate files to classpath +-cp src +-cp gen-haxe +-cp ../../lib/haxe/src + +#this class wil be used as entry point for your app. +-main Main + +#Flash target +-swf bin/Tutorial.swf + +#Add debug information +-debug + +# we need some goodies from sys.net +# --macro allowPackage("sys") + +#dead code elimination : remove unused code +#"-dce no" : do not remove unused code +#"-dce std" : remove unused code in the std lib (default) +#"-dce full" : remove all unused code +-dce full
\ No newline at end of file diff --git a/src/jaegertracing/thrift/test/haxe/java.hxml b/src/jaegertracing/thrift/test/haxe/java.hxml new file mode 100644 index 000000000..c615565a9 --- /dev/null +++ b/src/jaegertracing/thrift/test/haxe/java.hxml @@ -0,0 +1,38 @@ +# +# 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. +# + +#integrate files to classpath +-cp src +-cp gen-haxe +-cp ../../lib/haxe/src + +#this class wil be used as entry point for your app. +-main Main + +#Java target +-java bin/Tutorial.jar + +#Add debug information +-debug + +#dead code elimination : remove unused code +#"-dce no" : do not remove unused code +#"-dce std" : remove unused code in the std lib (default) +#"-dce full" : remove all unused code +-dce full
\ No newline at end of file diff --git a/src/jaegertracing/thrift/test/haxe/javascript.hxml b/src/jaegertracing/thrift/test/haxe/javascript.hxml new file mode 100644 index 000000000..b2b3876cf --- /dev/null +++ b/src/jaegertracing/thrift/test/haxe/javascript.hxml @@ -0,0 +1,44 @@ +# +# 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. +# + +#integrate files to classpath +-cp src +-cp gen-haxe +-cp ../../lib/haxe/src + +#this class wil be used as entry point for your app. +-main Main + +#JavaScript target +-js bin/Tutorial.js + +#You can use -D source-map-content (requires Haxe 3.1+) to have the .hx +#files directly embedded into the map file, this way you only have to +#upload it, and it will be always in sync with the compiled .js even if +#you modify your .hx files. +-D source-map-content + +#Generate source map and add debug information +-debug + +#dead code elimination : remove unused code +#"-dce no" : do not remove unused code +#"-dce std" : remove unused code in the std lib (default) +#"-dce full" : remove all unused code +-dce full
\ No newline at end of file diff --git a/src/jaegertracing/thrift/test/haxe/make_all.bat b/src/jaegertracing/thrift/test/haxe/make_all.bat new file mode 100644 index 000000000..eaeba890d --- /dev/null +++ b/src/jaegertracing/thrift/test/haxe/make_all.bat @@ -0,0 +1,68 @@ +@echo off +rem /* +rem * Licensed to the Apache Software Foundation (ASF) under one +rem * or more contributor license agreements. See the NOTICE file +rem * distributed with this work for additional information +rem * regarding copyright ownership. The ASF licenses this file +rem * to you under the Apache License, Version 2.0 (the +rem * "License"); you may not use this file except in compliance +rem * with the License. You may obtain a copy of the License at +rem * +rem * http://www.apache.org/licenses/LICENSE-2.0 +rem * +rem * Unless required by applicable law or agreed to in writing, +rem * software distributed under the License is distributed on an +rem * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +rem * KIND, either express or implied. See the License for the +rem * specific language governing permissions and limitations +rem * under the License. +rem */ + +setlocal +if "%HOMEDRIVE%"=="" goto MISSINGVARS +if "%HOMEPATH%"=="" goto MISSINGVARS +if "%HAXEPATH%"=="" goto NOTINSTALLED + +set path=%HAXEPATH%;%HAXEPATH%\..\neko;%path% + +rem # invoke Thrift comnpiler +thrift -r -gen haxe ..\ThriftTest.thrift +if errorlevel 1 goto STOP + +rem # invoke Haxe compiler for all targets +for %%a in (*.hxml) do ( + rem * filter Python, as it is not supported by Haxe 3.1.3 (but will be in 3.1.4) + if not "%%a"=="python.hxml" ( + echo -------------------------- + echo Building %%a ... + echo -------------------------- + haxe --cwd . %%a + ) +) + + +echo. +echo done. +pause +goto eof + +:NOTINSTALLED +echo FATAL: Either Haxe is not installed, or the HAXEPATH variable is not set. +pause +goto eof + +:MISSINGVARS +echo FATAL: Unable to locate home folder. +echo. +echo Both HOMEDRIVE and HOMEPATH need to be set to point to your Home folder. +echo The current values are: +echo HOMEDRIVE=%HOMEDRIVE% +echo HOMEPATH=%HOMEPATH% +pause +goto eof + +:STOP +pause +goto eof + +:eof diff --git a/src/jaegertracing/thrift/test/haxe/make_all.sh b/src/jaegertracing/thrift/test/haxe/make_all.sh new file mode 100755 index 000000000..eb2c9c2c7 --- /dev/null +++ b/src/jaegertracing/thrift/test/haxe/make_all.sh @@ -0,0 +1,41 @@ +#!/bin/sh +# +# 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. +# + +# invoke Thrift comnpiler +../../compiler/cpp/thrift -r -gen haxe ../ThriftTest.thrift + +# output folder +if [ ! -d bin ]; then + mkdir bin +fi + +# invoke Haxe compiler +for target in *.hxml; do + echo -------------------------- + echo Building ${target} ... + echo -------------------------- + if [ ! -d bin/${target} ]; then + mkdir bin/${target} + fi + haxe --cwd . ${target} +done + + +#eof diff --git a/src/jaegertracing/thrift/test/haxe/neko.hxml b/src/jaegertracing/thrift/test/haxe/neko.hxml new file mode 100644 index 000000000..6161f6977 --- /dev/null +++ b/src/jaegertracing/thrift/test/haxe/neko.hxml @@ -0,0 +1,38 @@ +# +# 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. +# + +#integrate files to classpath +-cp src +-cp gen-haxe +-cp ../../lib/haxe/src + +#this class wil be used as entry point for your app. +-main Main + +#neko target +-neko bin/Tutorial.n + +#Add debug information +-debug + +#dead code elimination : remove unused code +#"-dce no" : do not remove unused code +#"-dce std" : remove unused code in the std lib (default) +#"-dce full" : remove all unused code +-dce full
\ No newline at end of file diff --git a/src/jaegertracing/thrift/test/haxe/php-web-server.hxml b/src/jaegertracing/thrift/test/haxe/php-web-server.hxml new file mode 100644 index 000000000..395a8521e --- /dev/null +++ b/src/jaegertracing/thrift/test/haxe/php-web-server.hxml @@ -0,0 +1,43 @@ +# +# 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. +# + +#integrate files to classpath +-cp src +-cp gen-haxe +-cp ../../lib/haxe/src + +#this class wil be used as entry point for your app. +-main Main + +#PHP target +-php bin/php-web-server/ +--php-front Main-debug.php + +#defines +-D phpwebserver + + +#Add debug information +-debug + +#dead code elimination : remove unused code +#"-dce no" : do not remove unused code +#"-dce std" : remove unused code in the std lib (default) +#"-dce full" : remove all unused code +-dce full diff --git a/src/jaegertracing/thrift/test/haxe/php.hxml b/src/jaegertracing/thrift/test/haxe/php.hxml new file mode 100644 index 000000000..965189843 --- /dev/null +++ b/src/jaegertracing/thrift/test/haxe/php.hxml @@ -0,0 +1,40 @@ +# +# 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. +# + +#integrate files to classpath +-cp src +-cp gen-haxe +-cp ../../lib/haxe/src + +#this class wil be used as entry point for your app. +-main Main + +#PHP target +-php bin/php/ +--php-front Main-debug.php + + +#Add debug information +-debug + +#dead code elimination : remove unused code +#"-dce no" : do not remove unused code +#"-dce std" : remove unused code in the std lib (default) +#"-dce full" : remove all unused code +-dce full diff --git a/src/jaegertracing/thrift/test/haxe/project.hide b/src/jaegertracing/thrift/test/haxe/project.hide new file mode 100644 index 000000000..a1c09bac3 --- /dev/null +++ b/src/jaegertracing/thrift/test/haxe/project.hide @@ -0,0 +1,76 @@ +{ + "type" : 0 + ,"target" : 4 + ,"name" : "Apache Thrift cross-platform test client/server" + ,"main" : null + ,"projectPackage" : "" + ,"company" : "Apache Software Foundation (ASF)" + ,"license" : "Apache License, Version 2.0" + ,"url" : "http://www.apache.org/licenses/LICENSE-2.0" + ,"targetData" : [ + { + "pathToHxml" : "flash.hxml" + ,"runActionType" : 1 + ,"runActionText" : "bin/Tutorial.swf" + } + ,{ + "pathToHxml" : "javascript.hxml" + ,"runActionType" : 1 + ,"runActionText" : "bin\\index.html" + } + ,{ + "pathToHxml" : "neko.hxml" + ,"runActionType" : 2 + ,"runActionText" : "neko bin/Tutorial.n" + } + ,{ + "pathToHxml" : "php.hxml" + } + ,{ + "pathToHxml" : "cpp.hxml" + ,"runActionType" : 2 + ,"runActionText" : "bin/Main-debug.exe client --protocol json" + } + ,{ + "pathToHxml" : "java.hxml" + } + ,{ + "pathToHxml" : "csharp.hxml" + } + ,{ + "pathToHxml" : "python.hxml" + ,"runActionType" : 2 + ,"runActionText" : "python bin/Tutorial.py" + } + ] + ,"files" : [ + { + "path" : "src\\TestClient.hx" + ,"useTabs" : true + ,"indentSize" : 4 + ,"foldedRegions" : [ + + ] + ,"activeLine" : 188 + } + ,{ + "path" : "src\\TestServer.hx" + ,"useTabs" : true + ,"indentSize" : 4 + ,"foldedRegions" : [ + + ] + ,"activeLine" : 88 + } + ] + ,"activeFile" : "src\\TestClient.hx" + ,"openFLTarget" : null + ,"openFLBuildMode" : "Debug" + ,"runActionType" : null + ,"runActionText" : null + ,"buildActionCommand" : null + ,"hiddenItems" : [ + + ] + ,"showHiddenItems" : false +}
\ No newline at end of file diff --git a/src/jaegertracing/thrift/test/haxe/python.hxml b/src/jaegertracing/thrift/test/haxe/python.hxml new file mode 100644 index 000000000..f2c19fa93 --- /dev/null +++ b/src/jaegertracing/thrift/test/haxe/python.hxml @@ -0,0 +1,38 @@ +# +# 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. +# + +#integrate files to classpath +-cp src +-cp gen-haxe +-cp ../../lib/haxe/src + +#this class wil be used as entry point for your app. +-main Main + +#Python target +-python bin/Tutorial.py + +#Add debug information +-debug + +#dead code elimination : remove unused code +#"-dce no" : do not remove unused code +#"-dce std" : remove unused code in the std lib (default) +#"-dce full" : remove all unused code +-dce full
\ No newline at end of file diff --git a/src/jaegertracing/thrift/test/haxe/router.php b/src/jaegertracing/thrift/test/haxe/router.php new file mode 100644 index 000000000..e34135cc9 --- /dev/null +++ b/src/jaegertracing/thrift/test/haxe/router.php @@ -0,0 +1,31 @@ +<?php +/* + * 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 thrift + */ + + + +//router file to run testing web server + +//set_time_limit(1); + +require_once dirname(__FILE__) . '/bin/php-web-server/Main-debug.php'; + + diff --git a/src/jaegertracing/thrift/test/haxe/src/Arguments.hx b/src/jaegertracing/thrift/test/haxe/src/Arguments.hx new file mode 100644 index 000000000..cc1074987 --- /dev/null +++ b/src/jaegertracing/thrift/test/haxe/src/Arguments.hx @@ -0,0 +1,335 @@ +/* + * 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; + +import org.apache.thrift.*; +import org.apache.thrift.protocol.*; +import org.apache.thrift.transport.*; +import org.apache.thrift.server.*; +import org.apache.thrift.meta_data.*; +import haxe.io.Path; + +using StringTools; + + +enum ProtocolType { + binary; + json; + compact; +} + +enum EndpointTransport { + socket; + http; +} + +enum ServerType { + simple; + /* + threadpool; + threaded; + nonblocking; + */ +} + + +class Arguments +{ + public var printHelpOnly(default,null) : Bool = false; + + public var server(default,null) : Bool = false; + public var servertype(default,null) : ServerType = simple; + + public var host(default,null) : String = "localhost"; + public var port(default,null) : Int = 9090; + + public var protocol(default,null) : ProtocolType = binary; + public var transport(default,null) : EndpointTransport = socket; + public var framed(default,null) : Bool = false; + public var buffered(default,null) : Bool = false; + + public var numIterations(default,null) : Int = 1; + public var numThreads(default,null) : Int = 1; + public var skipSpeedTest(default,null) : Bool = false; + + + public function new() { + #if sys + #if !phpwebserver + try { + ParseArgs(); + } catch (e : String) { + trace(GetHelp()); + throw e; + } + #else + //forcing server + server = true; + transport = http; + #end + #else + trace("WN: Platform does not support program arguments, using defaults."); + #end + } + + #if sys + + private static function GetHelp() : String { + var sProg = Path.withoutDirectory( Sys.executablePath()); + return "\n" + +sProg+" [client|server] [options]\n" + +"\n" + +"Modus: Either client or server, the default is client.\n" + +"\n" + +"Common options:\n" + +" -h [ --help ] produce help message\n" + +" --port arg (=9090) Port number to listen / connect to\n" + /* not supported yet + +" --domain-socket arg Unix Domain Socket (e.g. /tmp/ThriftTest.thrift)\n" + +" --named-pipe arg Windows Named Pipe (e.g. MyThriftPipe)\n" + */ + +" --protocol arg (=binary) protocol: binary, compact, json\n" + /* not supported yet + +" --ssl Encrypted Transport using SSL\n" + */ + +"\n" + +"Server only options:\n" + +" --transport arg (=sockets) Transport: buffered, framed, http, anonpipe\n" + /* not supported yet + +" --processor-events processor-events\n" + +" --server-type arg (=simple) type of server, \"simple\", \"thread-pool\", \n" + +" \"threaded\", or \"nonblocking\"\n" + +" -n [ --workers ] arg (=4) Number of thread pools workers. Only valid for \n" + +" thread-pool server type\n" + */ + +"\n" + +"Client only options:\n" + +" --host arg (=localhost) Host to connect\n" + +" --transport arg (=sockets) Transport: buffered, framed, http, evhttp\n" + /* not supported yet + +" --anon-pipes hRead hWrite Windows Anonymous Pipes pair (handles)\n" + */ + +" -n [ --testloops ] arg (=1) Number of Tests\n" + +" -t [ --threads ] arg (=1) Number of Test threads\n" + +" --skip-speed-test Skip the speed test\n" + +"\n" + +"All arguments are optional.\n" + ; + } + + + private function ParseArgs() : Void { + + var args = Sys.args().copy(); + if( (args == null) || (args.length <= 0)) { + server = false; + numThreads = 1; + return; + } + + var arg = args.shift(); + if ( arg == "client") { + server = false; + numThreads = 1; + } + else if ( arg == "server") { + server = true; + numThreads = 4; + } + else if ( (arg == "-h") || (arg == "--help")) { + // -h [ --help ] produce help message + Sys.println( GetHelp()); + printHelpOnly = true; + return; + } + else { + throw "First argument must be 'server' or 'client'"; + } + + + while( args.length > 0) { + arg = args.shift(); + + if ( (arg == "-h") || (arg == "--help")) { + // -h [ --help ] produce help message + Sys.println( GetHelp()); + printHelpOnly = true; + return; + } + else if (arg == "--port") { + // --port arg (=9090) Port number to listen + arg = args.shift(); + var tmp = Std.parseInt(arg); + if( tmp != null) { + port = tmp; + } else { + throw "Invalid port number "+arg; + } + } + else if (arg == "--domain-socket") { + // --domain-socket arg Unix Domain Socket (e.g. /tmp/ThriftTest.thrift) + throw "domain sockets not supported yet"; + } + else if (arg == "--named-pipe") { + // --named-pipe arg Windows Named Pipe (e.g. MyThriftPipe) + throw "named pipes not supported yet"; + } + else if (arg == "--protocol") { + // --protocol arg (=binary) protocol: binary, compact, json + arg = args.shift(); + if( arg == "binary") { + protocol = binary; + } else if( arg == "compact") { + protocol = compact; + } else if( arg == "json") { + protocol = json; + } else { + InvalidArg(arg); + } + } + else if (arg == "--ssl") { + // --ssl Encrypted Transport using SSL + throw "SSL not supported yet"; + } + else { + //Server only options: + if( server) { + ParseServerArgument( arg, args); + } else { + ParseClientArgument( arg, args); + } + } + } + } + + + private function ParseServerArgument( arg : String, args : Array<String>) : Void { + if (arg == "--transport") { + // --transport arg (=sockets) Transport: buffered, framed, http, anonpipe + arg = args.shift(); + if( arg == "buffered") { + buffered = true; + } else if( arg == "framed") { + framed = true; + } else if( arg == "http") { + transport = http; + } else if( arg == "anonpipe") { + throw "Anon pipes transport not supported yet"; + } else { + InvalidArg(arg); + } + } + else if (arg == "--processor-events") { + throw "Processor events not supported yet"; + } + else if (arg == "--server-type") { + // --server-type arg (=simple) type of server, + // one of "simple", "thread-pool", "threaded", "nonblocking" + arg = args.shift(); + if( arg == "simple") { + servertype = simple; + } else if( arg == "thread-pool") { + throw arg+" server not supported yet"; + } else if( arg == "threaded") { + throw arg+" server not supported yet"; + } else if( arg == "nonblocking") { + throw arg+" server not supported yet"; + } else { + InvalidArg(arg); + } + } + else if ((arg == "-n") || (arg == "--workers")) { + // -n [ --workers ] arg (=4) Number of thread pools workers. Only valid for + // thread-pool server type + arg = args.shift(); + var tmp = Std.parseInt(arg); + if( tmp != null) { + numThreads = tmp; + } else{ + throw "Invalid number "+arg; + } + } + else { + InvalidArg(arg); + } + } + + + private function ParseClientArgument( arg : String, args : Array<String>) : Void { + if (arg == "--host") { + // --host arg (=localhost) Host to connect + host = args.shift(); + } + else if (arg == "--transport") { + // --transport arg (=sockets) Transport: buffered, framed, http, evhttp + arg = args.shift(); + if( arg == "buffered") { + buffered = true; + } else if( arg == "framed") { + framed = true; + } else if( arg == "http") { + transport = http; + } else if( arg == "evhttp") { + throw "evhttp transport not supported yet"; + } else { + InvalidArg(arg); + } + } + else if (arg == "--anon-pipes") { + // --anon-pipes hRead hWrite Windows Anonymous Pipes pair (handles) + throw "Anon pipes transport not supported yet"; + } + else if ((arg == "-n") || (arg == "--testloops")) { + // -n [ --testloops ] arg (=1) Number of Tests + arg = args.shift(); + var tmp = Std.parseInt(arg); + if( tmp != null) { + numIterations = tmp; + } else { + throw "Invalid number "+arg; + } + } + else if ((arg == "-t") || (arg == "--threads")) { + // -t [ --threads ] arg (=1) Number of Test threads + arg = args.shift(); + var tmp = Std.parseInt(arg); + if( tmp != null) { + numThreads = tmp; + } else { + throw "Invalid number "+arg; + } + } + else if (arg == "--skip-speed-test") { + // --skip-speed-test Skip the speed test + skipSpeedTest = true; + } + else { + InvalidArg(arg); + } + } + + + #end + + + private function InvalidArg( arg : String) : Void { + throw 'Invalid argument $arg'; + } +} diff --git a/src/jaegertracing/thrift/test/haxe/src/Main.hx b/src/jaegertracing/thrift/test/haxe/src/Main.hx new file mode 100644 index 000000000..9eb828f1f --- /dev/null +++ b/src/jaegertracing/thrift/test/haxe/src/Main.hx @@ -0,0 +1,83 @@ +/* + * 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; + +import org.apache.thrift.*; +import org.apache.thrift.protocol.*; +import org.apache.thrift.transport.*; +import org.apache.thrift.server.*; +import org.apache.thrift.meta_data.*; + +import thrift.test.*; // generated code + +class Main +{ + static function main() { + #if phpwebserver + initPhpWebServer(); + //check method + if(php.Web.getMethod() != 'POST') { + Sys.println('http endpoint for thrift test server'); + return; + } + #end + + try { + var args = new Arguments(); + + if( args.printHelpOnly) + return; + + if (args.server) + TestServer.Execute(args); + else + TestClient.Execute(args); + + trace("Completed."); + } catch (e : String) { + trace(e); + } + } + + #if phpwebserver + private static function initPhpWebServer() + { + //remap trace to error log + haxe.Log.trace = function(v:Dynamic, ?infos:haxe.PosInfos) + { + // handle trace + var newValue : Dynamic; + if (infos != null && infos.customParams!=null) { + var extra:String = ""; + for( v in infos.customParams ) + extra += "," + v; + newValue = v + extra; + } + else { + newValue = v; + } + var msg = infos != null ? infos.fileName + ':' + infos.lineNumber + ': ' : ''; + Sys.stderr().writeString('${msg}${newValue}\n'); + } + } + #end + +} diff --git a/src/jaegertracing/thrift/test/haxe/src/TestClient.hx b/src/jaegertracing/thrift/test/haxe/src/TestClient.hx new file mode 100644 index 000000000..853319e23 --- /dev/null +++ b/src/jaegertracing/thrift/test/haxe/src/TestClient.hx @@ -0,0 +1,937 @@ +/* + * 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; + +import haxe.Int32; +import haxe.Int64; +import haxe.io.Bytes; +import haxe.Timer; +import haxe.ds.IntMap; +import haxe.ds.StringMap; +import haxe.ds.ObjectMap; + +import org.apache.thrift.*; +import org.apache.thrift.helper.*; +import org.apache.thrift.protocol.*; +import org.apache.thrift.transport.*; +import org.apache.thrift.server.*; +import org.apache.thrift.meta_data.*; + +#if cpp +import cpp.vm.Thread; +#else +// no thread support (yet) +#end + +import thrift.test.*; // generated code + + +using StringTools; + +class TestResults { + private var successCnt : Int = 0; + private var errorCnt : Int = 0; + private var failedTests : String = ""; + private var print_direct : Bool = false; + + public static var EXITCODE_SUCCESS = 0x00; // no errors bits set + // + public static var EXITCODE_FAILBIT_BASETYPES = 0x01; + public static var EXITCODE_FAILBIT_STRUCTS = 0x02; + public static var EXITCODE_FAILBIT_CONTAINERS = 0x04; + public static var EXITCODE_FAILBIT_EXCEPTIONS = 0x08; + // + public static var EXITCODE_ALL_FAILBITS = 0x0F; + // + private var testsExecuted : Int = 0; + private var testsFailed : Int = 0; + private var currentTest : Int = 0; + + + public function new(direct : Bool) { + print_direct = direct; + } + + public function StartTestGroup( groupBit : Int) : Void { + currentTest = groupBit; + testsExecuted |= groupBit; + } + + public function Expect( expr : Bool, msg : String) : Void { + if ( expr) { + ++successCnt; + } else { + ++errorCnt; + testsFailed |= currentTest; + failedTests += "\n " + msg; + if( print_direct) { + trace('FAIL: $msg'); + } + } + } + + public function CalculateExitCode() : Int { + var notExecuted : Int = EXITCODE_ALL_FAILBITS & (~testsExecuted); + return testsFailed | notExecuted; + } + + public function PrintSummary() : Void { + var total = successCnt + errorCnt; + var sp = Math.round((1000 * successCnt) / total) / 10; + var ep = Math.round((1000 * errorCnt) / total) / 10; + + trace('==========================='); + trace('Tests executed $total'); + trace('Tests succeeded $successCnt ($sp%)'); + trace('Tests failed $errorCnt ($ep%)'); + if ( errorCnt > 0) + { + trace('==========================='); + trace('FAILED TESTS: $failedTests'); + } + trace('==========================='); + } +} + + +class TestClient { + + public static function Execute(args : Arguments) : Void + { + var exitCode = 0xFF; + try + { + var difft = Timer.stamp(); + + if ( args.numThreads > 1) { + #if cpp + exitCode = MultiThreadClient(args); + #else + trace('Threads not supported/implemented for this platform.'); + exitCode = SingleThreadClient(args); + #end + } else { + exitCode = SingleThreadClient(args); + } + + difft = Math.round( 1000 * (Timer.stamp() - difft)) / 1000; + trace('total test time: $difft seconds'); + } + catch (e : TException) + { + trace('TException: $e'); + exitCode = 0xFF; + } + catch (e : Dynamic) + { + trace('Exception: $e'); + exitCode = 0xFF; + } + + #if sys + Sys.exit( exitCode); + #end + } + + + public static function SingleThreadClient(args : Arguments) : Int + { + var rslt = new TestResults(true); + RunClient(args,rslt); + rslt.PrintSummary(); + return rslt.CalculateExitCode(); + } + + + #if cpp + public static function MultiThreadClient(args : Arguments) : Int + { + var threads = new List<Thread>(); + for( test in 0 ... args.numThreads) { + threads.add( StartThread( args)); + } + var exitCode : Int = 0; + for( thread in threads) { + exitCode |= Thread.readMessage(true); + } + return exitCode; + } + #end + + #if cpp + private static function StartThread(args : Arguments) : Thread { + var thread = Thread.create( + function() : Void { + var rslt = new TestResults(false); + var main : Thread = Thread.readMessage(true); + try + { + RunClient(args,rslt); + } + catch (e : TException) + { + rslt.Expect( false, '$e'); + trace('$e'); + } + catch (e : Dynamic) + { + rslt.Expect( false, '$e'); + trace('$e'); + } + main.sendMessage( rslt.CalculateExitCode()); + }); + + thread.sendMessage(Thread.current()); + return thread; + } + #end + + + public static function RunClient(args : Arguments, rslt : TestResults) + { + var transport : TTransport = null; + switch (args.transport) + { + case socket: + transport = new TSocket(args.host, args.port); + case http: + var uri = 'http://${args.host}:${args.port}'; + trace('- http client : ${uri}'); + transport = new THttpClient(uri); + default: + throw "Unhandled transport"; + } + + // optional: layered transport + if ( args.framed) { + trace("- framed transport"); + transport = new TFramedTransport(transport); + } + if ( args.buffered) { + trace("- buffered transport"); + transport = new TBufferedTransport(transport); + } + + // protocol + var protocol : TProtocol = null; + switch( args.protocol) + { + case binary: + trace("- binary protocol"); + protocol = new TBinaryProtocol(transport); + case json: + trace("- json protocol"); + protocol = new TJSONProtocol(transport); + case compact: + trace("- compact protocol"); + protocol = new TCompactProtocol(transport); + } + + // some quick and basic unit tests + HaxeBasicsTest( args, rslt); + ModuleUnitTests( args, rslt); + + // now run the test code + trace('- ${args.numIterations} iterations'); + for( i in 0 ... args.numIterations) { + ClientTest( transport, protocol, args, rslt); + } + } + + + public static function HaxeBasicsTest( args : Arguments, rslt : TestResults) : Void + { + // We need to test a few basic things used in the ClientTest + // Anything else beyond this scope should go into /lib/haxe/ instead + rslt.StartTestGroup( TestResults.EXITCODE_FAILBIT_BASETYPES); + + var map32 = new IntMap<Int32>(); + var map64 = new Int64Map<Int32>(); + + rslt.Expect( map32.keys().hasNext() == map64.keys().hasNext(), "Int64Map<Int32> Test #1"); + rslt.Expect( map32.exists( 4711) == map64.exists( Int64.make(47,11)), "Int64Map<Int32> Test #2"); + rslt.Expect( map32.remove( 4711) == map64.remove( Int64.make(47,11)), "Int64Map<Int32> Test #3"); + rslt.Expect( map32.get( 4711) == map64.get( Int64.make(47,11)), "Int64Map<Int32> Test #4"); + + map32.set( 42, 815); + map64.set( Int64.make(0,42), 815); + map32.set( -517, 23); + map64.set( Int64.neg(Int64.make(0,517)), 23); + map32.set( 0, -123); + map64.set( Int64.make(0,0), -123); + + //trace('map32 = $map32'); + //trace('map64 = $map64'); + + rslt.Expect( map32.keys().hasNext() == map64.keys().hasNext(), "Int64Map<Int32> Test #10"); + rslt.Expect( map32.exists( 4711) == map64.exists( Int64.make(47,11)), "Int64Map<Int32> Test #11"); + rslt.Expect( map32.exists( -517) == map64.exists( Int64.neg(Int64.make(0,517))), "Int64Map<Int32> Test #12"); + rslt.Expect( map32.exists( 42) == map64.exists( Int64.make(0,42)), "Int64Map<Int32> Test #13"); + rslt.Expect( map32.exists( 0) == map64.exists( Int64.make(0,0)), "Int64Map<Int32> Test #14"); + rslt.Expect( map32.get( 4711) == map64.get( Int64.make(47,11)), "Int64Map<Int32> Test #15"); + rslt.Expect( map32.get( -517) == map64.get( Int64.neg(Int64.make(0,517))), "Int64Map<Int32> Test #16"); + rslt.Expect( map32.get( 42) == map64.get( Int64.make(0,42)), "Int64Map<Int32> Test #Int64.make(-5,17)"); + rslt.Expect( map32.get( 0) == map64.get( Int64.make(0,0)), "Int64Map<Int32> Test #18"); + rslt.Expect( map32.remove( 4711) == map64.remove( Int64.make(47,11)), "Int64Map<Int32> Test #19"); + rslt.Expect( map32.remove( -517) == map64.remove( Int64.neg(Int64.make(0,517))), "Int64Map<Int32> Test #20"); + rslt.Expect( map32.exists( 4711) == map64.exists( Int64.make(47,11)), "Int64Map<Int32> Test #21"); + rslt.Expect( map32.exists( -517) == map64.exists( Int64.neg(Int64.make(0,517))), "Int64Map<Int32> Test #22"); + rslt.Expect( map32.exists( 42) == map64.exists( Int64.make(0,42)), "Int64Map<Int32> Test #23"); + rslt.Expect( map32.exists( 0) == map64.exists( Int64.make(0,0)), "Int64Map<Int32> Test #24"); + rslt.Expect( map32.get( 4711) == map64.get( Int64.make(47,11)), "Int64Map<Int32> Test #25"); + rslt.Expect( map32.get( -517) == map64.get( Int64.neg(Int64.make(0,517))), "Int64Map<Int32> Test #26"); + rslt.Expect( map32.get( 42) == map64.get( Int64.make(0,42)), "Int64Map<Int32> Test #27"); + rslt.Expect( map32.get( 0) == map64.get( Int64.make(0,0)), "Int64Map<Int32> Test #28"); + + map32.set( 42, 1); + map64.set( Int64.make(0,42), 1); + map32.set( -517, -2); + map64.set( Int64.neg(Int64.make(0,517)), -2); + map32.set( 0, 3); + map64.set( Int64.make(0,0), 3); + + var c32 = 0; + var ksum32 = 0; + for (key in map32.keys()) { + ++c32; + ksum32 += key; + } + var c64 = 0; + var ksum64 = Int64.make(0,0); + for (key in map64.keys()) { + ++c64; + ksum64 = Int64.add( ksum64, key); + } + rslt.Expect( c32 == c64, "Int64Map<Int32> Test #30"); + rslt.Expect( '$ksum64' == '$ksum32', '$ksum64 == $ksum32 Test #31'); + + //compare without spaces because differ in php and cpp + var s32 = map32.toString().replace(' ', ''); + var s64 = map64.toString().replace(' ', ''); + rslt.Expect( s32 == s64, "Int64Map<Int32>.toString(): " + ' ("$s32" == "$s64") Test #32'); + + map32.remove( 42); + map64.remove( Int64.make(0,42)); + map32.remove( -517); + map64.remove( Int64.neg(Int64.make(0,517))); + map32.remove( 0); + map64.remove( Int64.make(0,0)); + + rslt.Expect( map32.keys().hasNext() == map64.keys().hasNext(), "Int64Map<Int32> Test #90"); + rslt.Expect( map32.exists( 4711) == map64.exists( Int64.make(47,11)), "Int64Map<Int32> Test #91"); + rslt.Expect( map32.exists( -517) == map64.exists( Int64.neg(Int64.make(0,517))), "Int64Map<Int32> Test #92"); + rslt.Expect( map32.exists( 42) == map64.exists( Int64.make(0,42)), "Int64Map<Int32> Test #93"); + rslt.Expect( map32.exists( 0) == map64.exists( Int64.make(0,0)), "Int64Map<Int32> Test #94"); + rslt.Expect( map32.get( 4711) == map64.get( Int64.make(47,11)), "Int64Map<Int32> Test #95"); + rslt.Expect( map32.get( -517) == map64.get( Int64.make(-5,17)), "Int64Map<Int32> Test #96"); + rslt.Expect( map32.get( 42) == map64.get( Int64.make(0,42)), "Int64Map<Int32> Test #97"); + rslt.Expect( map32.get( 0) == map64.get( Int64.make(0, 0)), "Int64Map<Int32> Test #98"); + } + + + // core module unit tests + public static function ModuleUnitTests( args : Arguments, rslt : TestResults) : Void { + #if debug + + try { + BitConverter.UnitTest(); + rslt.Expect( true, 'BitConverter.UnitTest Test #100'); + } + catch( e : Dynamic) { + rslt.Expect( false, 'BitConverter.UnitTest: $e Test #100'); + } + + try { + ZigZag.UnitTest(); + rslt.Expect( true, 'ZigZag.UnitTest Test #101'); + } + catch( e : Dynamic) { + rslt.Expect( false, 'ZigZag.UnitTest: $e Test #101'); + } + + #end + } + + + public static function BytesToHex(data : Bytes) : String { + var hex = ""; + for ( i in 0 ... data.length) { + hex += StringTools.hex( data.get(i), 2); + } + return hex; + } + + public static function PrepareTestData(randomDist : Bool) : Bytes { + var retval = Bytes.alloc(0x100); + var initLen : Int = (retval.length > 0x100 ? 0x100 : retval.length); + + // linear distribution, unless random is requested + if (!randomDist) { + for (i in 0 ... initLen) { + retval.set(i, i % 0x100); + } + return retval; + } + + // random distribution + for (i in 0 ... initLen) { + retval.set(i, 0); + } + for (i in 1 ... initLen) { + while( true) { + var nextPos = Std.random(initLen); + if (retval.get(nextPos) == 0) { + retval.set( nextPos, i % 0x100); + break; + } + } + } + return retval; + } + + + public static function ClientTest( transport : TTransport, protocol : TProtocol, + args : Arguments, rslt : TestResults) : Void + { + var client = new ThriftTestImpl(protocol,protocol); + try + { + if (!transport.isOpen()) + { + transport.open(); + } + } + catch (e : TException) + { + rslt.Expect( false, 'unable to open transport: $e'); + return; + } + catch (e : Dynamic) + { + rslt.Expect( false, 'unable to open transport: $e'); + return; + } + + var start = Date.now(); + + rslt.StartTestGroup( TestResults.EXITCODE_FAILBIT_EXCEPTIONS); + + // if arg == "Xception" throw Xception with errorCode = 1001 and message = arg + trace('testException("Xception")'); + try { + client.testException("Xception"); + rslt.Expect( false, 'testException("Xception") should throw'); + } + catch (e : Xception) + { + rslt.Expect( e.message == "Xception", 'testException("Xception") - e.message == "Xception"'); + rslt.Expect( e.errorCode == 1001, 'testException("Xception") - e.errorCode == 1001'); + } + catch (e : TException) + { + rslt.Expect( false, 'testException("Xception") - ${e} : ${e.errorMsg}'); + } + catch (e : Dynamic) + { + rslt.Expect( false, 'testException("Xception") - $e'); + } + + // if arg == "TException" throw TException + trace('testException("TException")'); + try { + client.testException("TException"); + rslt.Expect( false, 'testException("TException") should throw'); + } + catch (e : TException) + { + rslt.Expect( true, 'testException("TException") - $e : ${e.errorMsg}'); + } + catch (e : Dynamic) + { + rslt.Expect( false, 'testException("TException") - $e'); + } + + // reopen the transport, just in case the server closed his end + if (transport.isOpen()) + transport.close(); + transport.open(); + + // else do not throw anything + trace('testException("bla")'); + try { + client.testException("bla"); + rslt.Expect( true, 'testException("bla") should not throw'); + } + catch (e : TException) + { + rslt.Expect( false, 'testException("bla") - ${e} : ${e.errorMsg}'); + } + catch (e : Dynamic) + { + rslt.Expect( false, 'testException("bla") - $e'); + } + + rslt.StartTestGroup( TestResults.EXITCODE_FAILBIT_BASETYPES); + + trace('testVoid()'); + client.testVoid(); + trace(' = void'); + rslt.Expect(true,"testVoid()"); // bump counter + + trace('testBool(${true})'); + var b = client.testBool(true); + trace(' = $b'); + rslt.Expect(b, '$b == "${true}"'); + trace('testBool(${false})'); + b = client.testBool(false); + trace(' = $b'); + rslt.Expect( ! b, '$b == "${false}"'); + + trace('testString("Test")'); + var s = client.testString("Test"); + trace(' = "$s"'); + rslt.Expect(s == "Test", '$s == "Test"'); + + trace('testByte(1)'); + var i8 = client.testByte(1); + trace(' = $i8'); + rslt.Expect(i8 == 1, '$i8 == 1'); + + trace('testI32(-1)'); + var i32 = client.testI32(-1); + trace(' = $i32'); + rslt.Expect(i32 == -1, '$i32 == -1'); + + trace('testI64(-34359738368)'); + var i64 = client.testI64( Int64.make( 0xFFFFFFF8, 0x00000000)); // -34359738368 + trace(' = $i64'); + rslt.Expect( Int64.compare( i64, Int64.make( 0xFFFFFFF8, 0x00000000)) == 0, + Int64.toStr(i64) +" == "+Int64.toStr(Int64.make( 0xFFFFFFF8, 0x00000000))); + + // edge case: the largest negative Int64 has no positive Int64 equivalent + trace('testI64(-9223372036854775808)'); + i64 = client.testI64( Int64.make( 0x80000000, 0x00000000)); // -9223372036854775808 + trace(' = $i64'); + rslt.Expect( Int64.compare( i64, Int64.make( 0x80000000, 0x00000000)) == 0, + Int64.toStr(i64) +" == "+Int64.toStr(Int64.make( 0x80000000, 0x00000000))); + + trace('testDouble(5.325098235)'); + var dub = client.testDouble(5.325098235); + trace(' = $dub'); + rslt.Expect(dub == 5.325098235, '$dub == 5.325098235'); + + var binOut = PrepareTestData(true); + trace('testBinary('+BytesToHex(binOut)+')'); + try { + var binIn = client.testBinary(binOut); + trace('testBinary() = '+BytesToHex(binIn)); + rslt.Expect( binIn.length == binOut.length, '${binIn.length} == ${binOut.length}'); + var len = ((binIn.length < binOut.length) ? binIn.length : binOut.length); + for (ofs in 0 ... len) { + if (binIn.get(ofs) != binOut.get(ofs)) { + rslt.Expect( false, 'testBinary('+BytesToHex(binOut)+'): content mismatch at offset $ofs'); + } + } + } + catch (e : TApplicationException) { + trace('testBinary('+BytesToHex(binOut)+'): '+e.errorMsg); // may not be supported by the server + } + + + rslt.StartTestGroup( TestResults.EXITCODE_FAILBIT_STRUCTS); + + trace('testStruct({"Zero", 1, -3, -5})'); + var o = new Xtruct(); + o.string_thing = "Zero"; + o.byte_thing = 1; + o.i32_thing = -3; + o.i64_thing = Int64.make(0,-5); + var i = client.testStruct(o); + trace(' = {"' + i.string_thing + '", ' + i.byte_thing +', ' + + i.i32_thing +', '+ Int64.toStr(i.i64_thing) + '}'); + rslt.Expect( i.string_thing == o.string_thing, "i.string_thing == o.string_thing"); + rslt.Expect( i.byte_thing == o.byte_thing, "i.byte_thing == o.byte_thing"); + rslt.Expect( i.i32_thing == o.i32_thing, "i.i64_thing == o.i64_thing"); + rslt.Expect( i.i32_thing == o.i32_thing, "i.i64_thing == o.i64_thing"); + + trace('testNest({1, {\"Zero\", 1, -3, -5}, 5})'); + var o2 = new Xtruct2(); + o2.byte_thing = 1; + o2.struct_thing = o; + o2.i32_thing = 5; + var i2 = client.testNest(o2); + i = i2.struct_thing; + trace(" = {" + i2.byte_thing + ", {\"" + i.string_thing + "\", " + + i.byte_thing + ", " + i.i32_thing + ", " + Int64.toStr(i.i64_thing) + "}, " + + i2.i32_thing + "}"); + rslt.Expect( i2.byte_thing == o2.byte_thing, "i2.byte_thing == o2.byte_thing"); + rslt.Expect( i2.i32_thing == o2.i32_thing, "i2.i32_thing == o2.i32_thing"); + rslt.Expect( i.string_thing == o.string_thing, "i.string_thing == o.string_thing"); + rslt.Expect( i.byte_thing == o.byte_thing, "i.byte_thing == o.byte_thing"); + rslt.Expect( i.i32_thing == o.i32_thing, "i.i32_thing == o.i32_thing"); + rslt.Expect( Int64.compare( i.i64_thing, o.i64_thing) == 0, "i.i64_thing == o.i64_thing"); + + + rslt.StartTestGroup( TestResults.EXITCODE_FAILBIT_CONTAINERS); + + var mapout = new IntMap< haxe.Int32>(); + for ( j in 0 ... 5) + { + mapout.set(j, j - 10); + } + trace("testMap({"); + var first : Bool = true; + for( key in mapout.keys()) + { + if (first) + { + first = false; + } + else + { + trace(", "); + } + trace(key + " => " + mapout.get(key)); + } + trace("})"); + + var mapin = client.testMap(mapout); + + trace(" = {"); + first = true; + for( key in mapin.keys()) + { + if (first) + { + first = false; + } + else + { + trace(", "); + } + trace(key + " => " + mapin.get(key)); + rslt.Expect( mapin.get(key) == mapout.get(key), ' mapin.get($key) == mapout.get($key)'); + } + trace("}"); + for( key in mapout.keys()) + { + rslt.Expect(mapin.exists(key), 'mapin.exists($key)'); + } + + var listout = new List<Int>(); + for (j in -2 ... 3) + { + listout.add(j); + } + trace("testList({"); + first = true; + for( j in listout) + { + if (first) + { + first = false; + } + else + { + trace(", "); + } + trace(j); + } + trace("})"); + + var listin = client.testList(listout); + + trace(" = {"); + first = true; + for( j in listin) + { + if (first) + { + first = false; + } + else + { + trace(", "); + } + trace(j); + } + trace("}"); + + rslt.Expect(listin.length == listout.length, "listin.length == listout.length"); + var literout = listout.iterator(); + var literin = listin.iterator(); + while( literin.hasNext()) { + rslt.Expect(literin.next() == literout.next(), "literin[i] == literout[i]"); + } + + //set + var setout = new IntSet(); + for (j in -2 ... 3) + { + setout.add(j); + } + trace("testSet({"); + first = true; + for( j in setout) + { + if (first) + { + first = false; + } + else + { + trace(", "); + } + trace(j); + } + trace("})"); + + var setin = client.testSet(setout); + + trace(" = {"); + first = true; + for( j in setin) + { + if (first) + { + first = false; + } + else + { + trace(", "); + } + trace(j); + rslt.Expect(setout.contains(j), 'setout.contains($j)'); + } + trace("}"); + rslt.Expect(setin.size == setout.size, "setin.length == setout.length"); + + + rslt.StartTestGroup( TestResults.EXITCODE_FAILBIT_BASETYPES); + + trace("testEnum(ONE)"); + var ret = client.testEnum(Numberz.ONE); + trace(" = " + ret); + rslt.Expect(ret == Numberz.ONE, '$ret == Numberz.ONE'); + + trace("testEnum(TWO)"); + ret = client.testEnum(Numberz.TWO); + trace(" = " + ret); + rslt.Expect(ret == Numberz.TWO, '$ret == Numberz.TWO'); + + trace("testEnum(THREE)"); + ret = client.testEnum(Numberz.THREE); + trace(" = " + ret); + rslt.Expect(ret == Numberz.THREE, '$ret == Numberz.THREE'); + + trace("testEnum(FIVE)"); + ret = client.testEnum(Numberz.FIVE); + trace(" = " + ret); + rslt.Expect(ret == Numberz.FIVE, '$ret == Numberz.FIVE'); + + trace("testEnum(EIGHT)"); + ret = client.testEnum(Numberz.EIGHT); + trace(" = " + ret); + rslt.Expect(ret == Numberz.EIGHT, '$ret == Numberz.EIGHT'); + + trace("testTypedef(309858235082523)"); + var uid = client.testTypedef( Int64.make( 0x119D0, 0x7E08671B)); // 309858235082523 + trace(" = " + uid); + rslt.Expect( Int64.compare( uid, Int64.make( 0x119D0, 0x7E08671B)) == 0, + Int64.toStr(uid)+" == "+Int64.toStr(Int64.make( 0x119D0, 0x7E08671B))); + + + rslt.StartTestGroup( TestResults.EXITCODE_FAILBIT_CONTAINERS); + + trace("testMapMap(1)"); + var mm = client.testMapMap(1); + trace(" = {"); + for( key in mm.keys()) + { + trace(key + " => {"); + var m2 = mm.get(key); + for( k2 in m2.keys()) + { + trace(k2 + " => " + m2.get(k2) + ", "); + } + trace("}, "); + } + trace("}"); + + var pos = mm.get(4); + var neg = mm.get(-4); + rslt.Expect( (pos != null) && (neg != null), "(pos != null) && (neg != null)"); + for (i in 1 ... 5) { + rslt.Expect( pos.get(i) == i, 'pos.get($i) == $i'); + rslt.Expect( neg.get(-i) == -i, 'neg.get(-$i) == -$i'); + } + rslt.Expect( ! pos.exists(0), '!pos.exists(0)'); + rslt.Expect( ! neg.exists(-0), '!neg.exists(-0)'); + rslt.Expect( ! pos.exists(42), '!pos.exists(42)'); + rslt.Expect( ! neg.exists(-42), '!neg.exists(-42)'); + + + rslt.StartTestGroup( TestResults.EXITCODE_FAILBIT_STRUCTS); + + var insane = new Insanity(); + insane.userMap = new IntMap< Int64>(); + insane.userMap.set( Numberz.FIVE, Int64.make(0,5000)); + var truck = new Xtruct(); + truck.string_thing = "Truck"; + truck.byte_thing = 8; + truck.i32_thing = 8; + truck.i64_thing = Int64.make(0,8); + insane.xtructs = new List<Xtruct>(); + insane.xtructs.add(truck); + trace("testInsanity()"); + var whoa = client.testInsanity(insane); + trace(" = {"); + for( key in whoa.keys()) + { + var val = whoa.get(key); + trace(key + " => {"); + + for( k2 in val.keys()) + { + var v2 = val.get(k2); + + trace(k2 + " => {"); + var userMap = v2.userMap; + + trace("{"); + if (userMap != null) + { + for( k3 in userMap.keys()) + { + trace(k3 + " => " + userMap.get(k3) + ", "); + } + } + else + { + trace("null"); + } + trace("}, "); + + var xtructs = v2.xtructs; + + trace("{"); + if (xtructs != null) + { + for( x in xtructs) + { + trace("{\"" + x.string_thing + "\", " + + x.byte_thing + ", " + x.i32_thing + ", " + + x.i32_thing + "}, "); + } + } + else + { + trace("null"); + } + trace("}"); + + trace("}, "); + } + trace("}, "); + } + trace("}"); + + + /** + * So you think you've got this all worked, out eh? + * + * Creates a the returned map with these values and prints it out: + * { 1 => { 2 => argument, + * 3 => argument, + * }, + * 2 => { 6 => <empty Insanity struct>, }, + * } + * @return map<UserId, map<Numberz,Insanity>> - a map with the above values + */ + + var first_map = whoa.get(Int64.make(0,1)); + var second_map = whoa.get(Int64.make(0,2)); + rslt.Expect( (first_map != null) && (second_map != null), "(first_map != null) && (second_map != null)"); + if ((first_map != null) && (second_map != null)) + { + var crazy2 = first_map.get(Numberz.TWO); + var crazy3 = first_map.get(Numberz.THREE); + var looney = second_map.get(Numberz.SIX); + rslt.Expect( (crazy2 != null) && (crazy3 != null) && (looney != null), + "(crazy2 != null) && (crazy3 != null) && (looney != null)"); + + var crz2iter = crazy2.xtructs.iterator(); + var crz3iter = crazy3.xtructs.iterator(); + rslt.Expect( crz2iter.hasNext() && crz3iter.hasNext(), "crz2iter.hasNext() && crz3iter.hasNext()"); + var goodbye2 = crz2iter.next(); + var goodbye3 = crz3iter.next(); + rslt.Expect( ! (crz2iter.hasNext() || crz3iter.hasNext()), "! (crz2iter.hasNext() || crz3iter.hasNext())"); + + rslt.Expect( Int64.compare( crazy2.userMap.get(Numberz.FIVE), insane.userMap.get(Numberz.FIVE)) == 0, "crazy2.userMap[5] == insane.userMap[5]"); + rslt.Expect( truck.string_thing == goodbye2.string_thing, "truck.string_thing == goodbye2.string_thing"); + rslt.Expect( truck.byte_thing == goodbye2.byte_thing, "truck.byte_thing == goodbye2.byte_thing"); + rslt.Expect( truck.i32_thing == goodbye2.i32_thing, "truck.i32_thing == goodbye2.i32_thing"); + rslt.Expect( Int64.compare( truck.i64_thing, goodbye2.i64_thing) == 0, "truck.i64_thing == goodbye2.i64_thing"); + + rslt.Expect( Int64.compare( crazy3.userMap.get(Numberz.FIVE), insane.userMap.get(Numberz.FIVE)) == 0, "crazy3.userMap[5] == insane.userMap[5]"); + rslt.Expect( truck.string_thing == goodbye3.string_thing, "truck.string_thing == goodbye3.string_thing"); + rslt.Expect( truck.byte_thing == goodbye3.byte_thing, "truck.byte_thing == goodbye3.byte_thing"); + rslt.Expect( truck.i32_thing == goodbye3.i32_thing, "truck.i32_thing == goodbye3.i32_thing"); + rslt.Expect( Int64.compare( truck.i64_thing, goodbye3.i64_thing) == 0, "truck.i64_thing == goodbye3.i64_thing"); + + rslt.Expect( ! looney.isSet(1), "! looney.isSet(1)"); + rslt.Expect( ! looney.isSet(2), "! looney.isSet(2)"); + } + + var arg0 = 1; + var arg1 = 2; + var arg2 = Int64.make( 0x7FFFFFFF,0xFFFFFFFF); + var multiDict = new IntMap< String>(); + multiDict.set(1, "one"); + var arg4 = Numberz.FIVE; + var arg5 = Int64.make(0,5000000); + trace("Test Multi(" + arg0 + "," + arg1 + "," + arg2 + "," + multiDict + "," + arg4 + "," + arg5 + ")"); + var multiResponse = client.testMulti(arg0, arg1, arg2, multiDict, arg4, arg5); + trace(" = Xtruct(byte_thing:" + multiResponse.byte_thing + ",string_thing:" + multiResponse.string_thing + + ",i32_thing:" + multiResponse.i32_thing + + ",i64_thing:" + Int64.toStr(multiResponse.i64_thing) + ")"); + + rslt.Expect( multiResponse.string_thing == "Hello2", 'multiResponse.String_thing == "Hello2"'); + rslt.Expect( multiResponse.byte_thing == arg0, 'multiResponse.Byte_thing == arg0'); + rslt.Expect( multiResponse.i32_thing == arg1, 'multiResponse.I32_thing == arg1'); + rslt.Expect( Int64.compare( multiResponse.i64_thing, arg2) == 0, 'multiResponse.I64_thing == arg2'); + + + rslt.StartTestGroup( 0); + + trace("Test Oneway(1)"); + client.testOneway(1); + + if( ! args.skipSpeedTest) { + trace("Test Calltime()"); + var difft = Timer.stamp(); + for ( k in 0 ... 1000) { + client.testVoid(); + } + difft = Math.round( 1000 * (Timer.stamp() - difft)) / 1000; + trace('$difft ms per testVoid() call'); + } + } +} diff --git a/src/jaegertracing/thrift/test/haxe/src/TestMacro.hx b/src/jaegertracing/thrift/test/haxe/src/TestMacro.hx new file mode 100644 index 000000000..a6207606a --- /dev/null +++ b/src/jaegertracing/thrift/test/haxe/src/TestMacro.hx @@ -0,0 +1,40 @@ +/* + * 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 ; + +import haxe.macro.Context; +import haxe.macro.Expr; + +/**** + * If you call the Thrift compiler this way (e.g. by changing the prebuild command) + * + * thrift -r -gen haxe:buildmacro=TestMacro.handle() ../ThriftTest.thrift + * + * the TestMacro.handle() function implemented below is called for each generated class + * and interface. Use "thrift --help" to get more info about other available options. + */ +class TestMacro +{ + public static function handle( ) : Array< Field> { + trace('TestMacro called for ' + Context.getLocalType()); + return Context.getBuildFields(); + } + +} diff --git a/src/jaegertracing/thrift/test/haxe/src/TestServer.hx b/src/jaegertracing/thrift/test/haxe/src/TestServer.hx new file mode 100644 index 000000000..450c8f28c --- /dev/null +++ b/src/jaegertracing/thrift/test/haxe/src/TestServer.hx @@ -0,0 +1,131 @@ +/* + * 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; + +import org.apache.thrift.*; +import org.apache.thrift.protocol.*; +import org.apache.thrift.transport.*; +import org.apache.thrift.server.*; +import org.apache.thrift.meta_data.*; + +import thrift.test.*; // generated code + + +class TestServer +{ + public static function Execute(args : Arguments) : Void + { + try + { + // Transport + var transport : TServerTransport = null; + switch( args.transport) { + case socket: + trace("- socket port "+args.port); + transport = new TServerSocket( args.port); + case http: + trace("- http"); + #if !phpwebserver + throw "HTTP server not implemented yet"; + //transport = new THttpServer( targetHost); + #else + transport = new TWrappingServerTransport( + new TStreamTransport( + new TFileStream("php://input", Read), + new TFileStream("php://output", Append) + ) + ); + + #end + default: + throw "Unhandled transport"; + } + + // optional: layered transport + var transfactory : TTransportFactory = null; + if ( args.framed) { + trace("- framed transport"); + transfactory = new TFramedTransportFactory(); + } + if ( args.buffered) { + trace("- buffered transport"); + transfactory = new TBufferedTransportFactory(); + } + + // protocol + var protfactory : TProtocolFactory = null; + switch( args.protocol) + { + case binary: + trace("- binary protocol"); + protfactory = new TBinaryProtocolFactory(); + case json: + trace("- json protocol"); + protfactory = new TJSONProtocolFactory(); + case compact: + trace("- compact protocol"); + protfactory = new TCompactProtocolFactory(); + } + + + // Processor + var handler = new TestServerHandler(); + var processor = new ThriftTestProcessor(handler); + + // Simple Server + var server : TServer = null; + switch( args.servertype) + { + case simple: + var simpleServer = new TSimpleServer( processor, transport, transfactory, protfactory); + #if phpwebserver + simpleServer.runOnce = true; + #end + server = simpleServer; + + default: + throw "Unhandled server type"; + } + + + /* + // Server event handler + if( args.serverEvents) { + var events = new TestServerEventHandler(); + server.setEventHandler(serverEvents); + handler.server = serverEngine; + } + */ + + // Run it + server.Serve(); + trace("done."); + + } + catch (x : TException) + { + trace('$x ${x.errorID} ${x.errorMsg}'); + } + catch (x : Dynamic) + { + trace('$x'); + } + } +} diff --git a/src/jaegertracing/thrift/test/haxe/src/TestServerEventHandler.hx b/src/jaegertracing/thrift/test/haxe/src/TestServerEventHandler.hx new file mode 100644 index 000000000..d17567c2f --- /dev/null +++ b/src/jaegertracing/thrift/test/haxe/src/TestServerEventHandler.hx @@ -0,0 +1,53 @@ +/* + * 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; + +import org.apache.thrift.*; +import org.apache.thrift.protocol.*; +import org.apache.thrift.transport.*; +import org.apache.thrift.server.*; +import org.apache.thrift.meta_data.*; + +import thrift.test.*; // generated code + + +class TestServerEventHandler : TServerEventHandler +{ + public int callCount = 0; + public void preServe() + { + callCount++; + } + public Object createContext(Thrift.Protocol.TProtocol input, Thrift.Protocol.TProtocol output) + { + callCount++; + return null; + } + public void deleteContext(Object serverContext, Thrift.Protocol.TProtocol input, Thrift.Protocol.TProtocol output) + { + callCount++; + } + public void processContext(Object serverContext, Thrift.Transport.TTransport transport) + { + callCount++; + } +} + +
\ No newline at end of file diff --git a/src/jaegertracing/thrift/test/haxe/src/TestServerHandler.hx b/src/jaegertracing/thrift/test/haxe/src/TestServerHandler.hx new file mode 100644 index 000000000..b8a2590d5 --- /dev/null +++ b/src/jaegertracing/thrift/test/haxe/src/TestServerHandler.hx @@ -0,0 +1,479 @@ +/* + * 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; + +import org.apache.thrift.*; +import org.apache.thrift.protocol.*; +import org.apache.thrift.transport.*; +import org.apache.thrift.server.*; +import org.apache.thrift.meta_data.*; +import org.apache.thrift.helper.*; + +import haxe.Int32; +import haxe.Int64; +import haxe.io.Bytes; +import haxe.ds.IntMap; +import haxe.ds.StringMap; +import haxe.ds.ObjectMap; + +import thrift.test.*; // generated code + + +class TestServerHandler implements ThriftTest { + + public var server:TServer; + + public function new() { + } + + /** + * Prints "testVoid()" and returns nothing. + */ + public function testVoid():Void + { + trace("testVoid()"); + } + + /** + * Prints 'testBool("%s")' where '%s' with thing as 'true' or 'false' + * @param bool thing - the bool data to print + * @return bool - returns the bool 'thing' + * + * @param thing + */ + public function testBool(thing : Bool) : Bool + { + trace('testBool($thing)'); + return thing; + } + + /** + * Prints 'testString("%s")' with thing as '%s' + * @param string thing - the string to print + * @return string - returns the string 'thing' + * + * @param thing + */ + public function testString(thing:String):String + { + trace("teststring(\"" + thing + "\")"); + return thing; + } + + /** + * Prints 'testByte("%d")' with thing as '%d' + * @param byte thing - the byte to print + * @return byte - returns the byte 'thing' + * + * @param thing + */ + public function testByte(thing:haxe.Int32):haxe.Int32 + { + trace("testByte(" + thing + ")"); + return thing; + } + + /** + * Prints 'testI32("%d")' with thing as '%d' + * @param i32 thing - the i32 to print + * @return i32 - returns the i32 'thing' + * + * @param thing + */ + public function testI32(thing:haxe.Int32):haxe.Int32 + { + trace("testI32(" + thing + ")"); + return thing; + } + + /** + * Prints 'testI64("%d")' with thing as '%d' + * @param i64 thing - the i64 to print + * @return i64 - returns the i64 'thing' + * + * @param thing + */ + public function testI64(thing:haxe.Int64):haxe.Int64 + { + trace("testI64(" + thing + ")"); + return thing; + } + + /** + * Prints 'testDouble("%f")' with thing as '%f' + * @param double thing - the double to print + * @return double - returns the double 'thing' + * + * @param thing + */ + public function testDouble(thing:Float):Float + { + trace("testDouble(" + thing + ")"); + return thing; + } + + /** + * Prints 'testBinary("%s")' where '%s' is a hex-formatted string of thing's data + * @param binary thing - the binary data to print + * @return binary - returns the binary 'thing' + * + * @param thing + */ + public function testBinary(thing : haxe.io.Bytes) : haxe.io.Bytes + { + var hex = ""; + for ( i in 0 ... thing.length) { + hex += StringTools.hex( thing.get(i), 2); + } + trace('testBinary($hex)'); + return thing; + } + + /** + * Prints 'testStruct("{%s}")' where thing has been formatted + * into a string of comma separated values + * @param Xtruct thing - the Xtruct to print + * @return Xtruct - returns the Xtruct 'thing' + * + * @param thing + */ + public function testStruct(thing:Xtruct):Xtruct + { + trace("testStruct({" + + "\"" + thing.string_thing + "\", " + + thing.byte_thing + ", " + + thing.i32_thing + ", " + + Int64.toStr(thing.i64_thing) + "})"); + return thing; + } + + /** + * Prints 'testNest("{%s}")' where thing has been formatted + * into a string of the nested struct + * @param Xtruct2 thing - the Xtruct2 to print + * @return Xtruct2 - returns the Xtruct2 'thing' + * + * @param thing + */ + public function testNest(nest:Xtruct2):Xtruct2 + { + var thing:Xtruct = nest.struct_thing; + trace("testNest({" + + nest.byte_thing + ", {" + + "\"" + thing.string_thing + "\", " + + thing.byte_thing + ", " + + thing.i32_thing + ", " + + Int64.toStr(thing.i64_thing) + "}, " + + nest.i32_thing + "})"); + return nest; + } + + /** + * Prints 'testMap("{%s")' where thing has been formatted + * into a string of 'key => value' pairs + * separated by commas and new lines + * @param map<i32,i32> thing - the map<i32,i32> to print + * @return map<i32,i32> - returns the map<i32,i32> 'thing' + * + * @param thing + */ + public function testMap(thing:IntMap<haxe.Int32>):IntMap<haxe.Int32> + { + trace("testMap({"); + var first:Bool = true; + for (key in thing.keys()) { + if (first) { + first = false; + } else { + trace(", "); + }; + trace(key + " => " + thing.get(key)); + }; + trace("})"); + return thing; + } + + /** + * Prints 'testStringMap("{%s}")' where thing has been formatted + * into a string of 'key => value' pairs + * separated by commas and new lines + * @param map<string,string> thing - the map<string,string> to print + * @return map<string,string> - returns the map<string,string> 'thing' + * + * @param thing + */ + public function testStringMap(thing:StringMap<String>):StringMap<String> + { + trace("testStringMap({"); + var first:Bool = true; + for (key in thing.keys()) { + if (first) { + first = false; + } else { + trace(", "); + }; + trace(key + " => " + thing.get(key)); + }; + trace("})"); + return thing; + } + + /** + * Prints 'testSet("{%s}")' where thing has been formatted + * into a string of values + * separated by commas and new lines + * @param set<i32> thing - the set<i32> to print + * @return set<i32> - returns the set<i32> 'thing' + * + * @param thing + */ + public function testSet(thing:IntSet):IntSet + { + trace("testSet({"); + var first:Bool = true; + for (elem in thing) { + if (first) { + first = false; + } else { + trace(", "); + }; + trace(elem); + }; + trace("})"); + return thing; + } + + /** + * Prints 'testList("{%s}")' where thing has been formatted + * into a string of values + * separated by commas and new lines + * @param list<i32> thing - the list<i32> to print + * @return list<i32> - returns the list<i32> 'thing' + * + * @param thing + */ + public function testList(thing:List<haxe.Int32>):List<haxe.Int32> + { + trace("testList({"); + var first:Bool = true; + for (elem in thing) { + if (first) { + first = false; + } else { + trace(", "); + }; + trace(elem); + }; + trace("})"); + return thing; + } + + /** + * Prints 'testEnum("%d")' where thing has been formatted into it's numeric value + * @param Numberz thing - the Numberz to print + * @return Numberz - returns the Numberz 'thing' + * + * @param thing + */ + public function testEnum(thing:Int):Int + { + trace("testEnum(" + thing + ")"); + return thing; + } + + /** + * Prints 'testTypedef("%d")' with thing as '%d' + * @param UserId thing - the UserId to print + * @return UserId - returns the UserId 'thing' + * + * @param thing + */ + public function testTypedef(thing:haxe.Int64):haxe.Int64 + { + trace("testTypedef(" + thing + ")"); + return thing; + } + + /** + * Prints 'testMapMap("%d")' with hello as '%d' + * @param i32 hello - the i32 to print + * @return map<i32,map<i32,i32>> - returns a dictionary with these values: + * {-4 => {-4 => -4, -3 => -3, -2 => -2, -1 => -1, }, + * 4 => {1 => 1, 2 => 2, 3 => 3, 4 => 4, }, } + * + * @param hello + */ + public function testMapMap(hello:haxe.Int32):IntMap<IntMap<haxe.Int32>> + { + trace("testMapMap(" + hello + ")"); + var mapmap = new IntMap<IntMap<Int>>(); + var pos = new IntMap<Int>(); + var neg = new IntMap<Int>(); + for (i in 1 ... 5) { + pos.set(i, i); + neg.set(-i, -i); + }; + mapmap.set(4, pos); + mapmap.set(-4, neg); + return mapmap; + } + + /** + * So you think you've got this all worked, out eh? + * + * Creates a the returned map with these values and prints it out: + * { 1 => { 2 => argument, + * 3 => argument, + * }, + * 2 => { 6 => <empty Insanity struct>, }, + * } + * @return map<UserId, map<Numberz,Insanity>> - a map with the above values + * + * @param argument + */ + public function testInsanity(argument : Insanity) : Int64Map< IntMap< Insanity>> + { + trace("testInsanity()"); + + var first_map = new IntMap< Insanity>(); + first_map.set(Numberz.TWO, argument); + first_map.set(Numberz.THREE, argument); + + var second_map = new IntMap< Insanity>(); + var looney = new Insanity(); + second_map.set(Numberz.SIX, looney); + + var insane = new Int64Map< IntMap< Insanity>>(); + insane.set( Int64.make(0,1), first_map); + insane.set( Int64.make(0,2), second_map); + + return insane; + } + + /** + * Prints 'testMulti()' + * @param byte arg0 - + * @param i32 arg1 - + * @param i64 arg2 - + * @param map<i16, string> arg3 - + * @param Numberz arg4 - + * @param UserId arg5 - + * @return Xtruct - returns an Xtruct + * with string_thing = "Hello2, byte_thing = arg0, i32_thing = arg1 + * and i64_thing = arg2 + * + * @param arg0 + * @param arg1 + * @param arg2 + * @param arg3 + * @param arg4 + * @param arg5 + */ + public function testMulti(arg0:haxe.Int32, arg1:haxe.Int32, arg2:haxe.Int64, + arg3:IntMap<String>, arg4:Int, arg5:haxe.Int64):Xtruct + { + trace("testMulti()"); + var hello = new Xtruct(); + hello.string_thing = "Hello2"; + hello.byte_thing = arg0; + hello.i32_thing = arg1; + hello.i64_thing = arg2; + return hello; + } + + /** + * Print 'testException(%s)' with arg as '%s' + * @param string arg - a string indication what type of exception to throw + * if arg == "Xception" throw Xception with errorCode = 1001 and message = arg + * elsen if arg == "TException" throw TException + * else do not throw anything + * + * @param arg + */ + public function testException(arg:String):Void + { + trace("testException(" + arg + ")"); + if (arg == "Xception") { + var x = new Xception(); + x.errorCode = 1001; + x.message = arg; + throw x; + }; + if (arg == "TException") { + throw new TException(); + }; + return; + } + + /** + * Print 'testMultiException(%s, %s)' with arg0 as '%s' and arg1 as '%s' + * @param string arg - a string indication what type of exception to throw + * if arg0 == "Xception" + * throw Xception with errorCode = 1001 and message = "This is an Xception" + * else if arg0 == "Xception2" + * throw Xception2 with errorCode = 2002 and message = "This is an Xception2" + * else do not throw anything + * @return Xtruct - an Xtruct with string_thing = arg1 + * + * @param arg0 + * @param arg1 + */ + public function testMultiException(arg0:String, arg1:String):Xtruct + { + trace("testMultiException(" + arg0 + ", " + arg1 + ")"); + if (arg0 == "Xception") { + var x = new Xception(); + x.errorCode = 1001; + x.message = "This is an Xception"; + throw x; + } else if (arg0 == "Xception2") { + var x = new Xception2(); + x.errorCode = 2002; + x.struct_thing = new Xtruct(); + x.struct_thing.string_thing = "This is an Xception2"; + throw x; + }; + var result = new Xtruct(); + result.string_thing = arg1; + return result; + } + + /** + * Print 'testOneway(%d): Sleeping...' with secondsToSleep as '%d' + * sleep 'secondsToSleep' + * Print 'testOneway(%d): done sleeping!' with secondsToSleep as '%d' + * @param i32 secondsToSleep - the number of seconds to sleep + * + * @param secondsToSleep + */ + public function testOneway(secondsToSleep:haxe.Int32):Void + { + trace("testOneway(" + secondsToSleep + "), sleeping..."); + Sys.sleep(secondsToSleep); + trace("testOneway finished"); + } + + public function testStop():Void + { + if (server != null) { + server.Stop(); + }; + } +} |