blob: cd439ccdf6f8f5875d32540a384518f6a5336352 [file] [log] [blame]
%%
%% 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.
%%
-module(test_server).
-export([start_link/1, handle_function/2]).
-include("thriftTest_types.hrl").
start_link(Port) ->
thrift_server:start_link(Port, thriftTest_thrift, ?MODULE).
handle_function(testVoid, {}) ->
io:format("testVoid~n"),
ok;
handle_function(testString, {S}) when is_binary(S) ->
io:format("testString: ~p~n", [S]),
{reply, S};
handle_function(testByte, {I8}) when is_integer(I8) ->
io:format("testByte: ~p~n", [I8]),
{reply, I8};
handle_function(testI32, {I32}) when is_integer(I32) ->
io:format("testI32: ~p~n", [I32]),
{reply, I32};
handle_function(testI64, {I64}) when is_integer(I64) ->
io:format("testI64: ~p~n", [I64]),
{reply, I64};
handle_function(testDouble, {Double}) when is_float(Double) ->
io:format("testDouble: ~p~n", [Double]),
{reply, Double};
handle_function(testStruct,
{Struct = #xtruct{string_thing = String,
byte_thing = Byte,
i32_thing = I32,
i64_thing = I64}})
when is_binary(String),
is_integer(Byte),
is_integer(I32),
is_integer(I64) ->
io:format("testStruct: ~p~n", [Struct]),
{reply, Struct};
handle_function(testNest,
{Nest}) when is_record(Nest, xtruct2),
is_record(Nest#xtruct2.struct_thing, xtruct) ->
io:format("testNest: ~p~n", [Nest]),
{reply, Nest};
handle_function(testMap, {Map}) ->
io:format("testMap: ~p~n", [dict:to_list(Map)]),
{reply, Map};
handle_function(testSet, {Set}) ->
true = sets:is_set(Set),
io:format("testSet: ~p~n", [sets:to_list(Set)]),
{reply, Set};
handle_function(testList, {List}) when is_list(List) ->
io:format("testList: ~p~n", [List]),
{reply, List};
handle_function(testEnum, {Enum}) when is_integer(Enum) ->
io:format("testEnum: ~p~n", [Enum]),
{reply, Enum};
handle_function(testTypedef, {UserID}) when is_integer(UserID) ->
io:format("testTypedef: ~p~n", [UserID]),
{reply, UserID};
handle_function(testMapMap, {Hello}) ->
io:format("testMapMap: ~p~n", [Hello]),
PosList = [{I, I} || I <- lists:seq(1, 5)],
NegList = [{-I, -I} || I <- lists:seq(1, 5)],
MapMap = dict:from_list([{4, dict:from_list(PosList)},
{-4, dict:from_list(NegList)}]),
{reply, MapMap};
handle_function(testInsanity, {Insanity}) when is_record(Insanity, insanity) ->
Hello = #xtruct{string_thing = <<"Hello2">>,
byte_thing = 2,
i32_thing = 2,
i64_thing = 2},
Goodbye = #xtruct{string_thing = <<"Goodbye4">>,
byte_thing = 4,
i32_thing = 4,
i64_thing = 4},
Crazy = #insanity{
userMap = dict:from_list([{?thriftTest_EIGHT, 8}]),
xtructs = [Goodbye]
},
Looney = #insanity{
userMap = dict:from_list([{?thriftTest_FIVE, 5}]),
xtructs = [Hello]
},
FirstMap = dict:from_list([{?thriftTest_TWO, Crazy},
{?thriftTest_THREE, Crazy}]),
SecondMap = dict:from_list([{?thriftTest_SIX, Looney}]),
Insane = dict:from_list([{1, FirstMap},
{2, SecondMap}]),
io:format("Return = ~p~n", [Insane]),
{reply, Insane};
handle_function(testMulti, Args = {Arg0, Arg1, Arg2, _Arg3, Arg4, Arg5})
when is_integer(Arg0),
is_integer(Arg1),
is_integer(Arg2),
is_integer(Arg4),
is_integer(Arg5) ->
io:format("testMulti(~p)~n", [Args]),
{reply, #xtruct{string_thing = <<"Hello2">>,
byte_thing = Arg0,
i32_thing = Arg1,
i64_thing = Arg2}};
handle_function(testException, {String}) when is_binary(String) ->
io:format("testException(~p)~n", [String]),
case String of
<<"Xception">> ->
throw(#xception{errorCode = 1001,
message = <<"This is an Xception">>});
_ ->
ok
end;
handle_function(testMultiException, {Arg0, Arg1}) ->
io:format("testMultiException(~p, ~p)~n", [Arg0, Arg1]),
case Arg0 of
<<"Xception">> ->
throw(#xception{errorCode = 1001,
message = <<"This is an Xception">>});
<<"Xception2">> ->
throw(#xception2{errorCode = 2002,
struct_thing =
#xtruct{string_thing = <<"This is an Xception2">>}});
_ ->
{reply, #xtruct{string_thing = Arg1}}
end;
handle_function(testOneway, {Seconds}) ->
timer:sleep(1000 * Seconds),
ok.