auser-poolparty 1.3.1 → 1.3.2

data/vendor/gems/thrift/lib/erl/src/thrift_processor.erl

@@ -1,188 +0,0 @@
-%%
-%% 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(thrift_processor).
-
--export([init/1]).
-
--include("thrift_constants.hrl").
--include("thrift_protocol.hrl").
-
--record(thrift_processor, {handler, in_protocol, out_protocol, service}).
-
-init({Server, ProtoGen, Service, Handler}) when is_function(ProtoGen, 0) ->
-    {ok, IProt, OProt} = ProtoGen(),
-    loop(#thrift_processor{in_protocol = IProt,
-                           out_protocol = OProt,
-                           service = Service,
-                           handler = Handler}).
-
-loop(State = #thrift_processor{in_protocol  = IProto,
-                               out_protocol = OProto}) ->
-    case thrift_protocol:read(IProto, message_begin) of
-        #protocol_message_begin{name = Function,
-                                type = ?tMessageType_CALL} ->
-            ok = handle_function(State, list_to_atom(Function)),
-            loop(State);
-        #protocol_message_begin{name = Function,
-                                type = ?tMessageType_ONEWAY} ->
-            ok = handle_function(State, list_to_atom(Function)),
-            loop(State);
-        {error, timeout} ->
-            thrift_protocol:close_transport(OProto),
-            ok;
-        {error, closed} ->
-            %% error_logger:info_msg("Client disconnected~n"),
-            thrift_protocol:close_transport(OProto),
-            exit(shutdown)
-    end.
-
-handle_function(State=#thrift_processor{in_protocol = IProto,
-                                        out_protocol = OProto,
-                                        handler = Handler,
-                                        service = Service},
-                Function) ->
-    InParams = Service:function_info(Function, params_type),
-
-    {ok, Params} = thrift_protocol:read(IProto, InParams),
-
-    try
-        Result = Handler:handle_function(Function, Params),
-        %% {Micro, Result} = better_timer(Handler, handle_function, [Function, Params]),
-        %% error_logger:info_msg("Processed ~p(~p) in ~.4fms~n",
-        %%                       [Function, Params, Micro/1000.0]),
-        handle_success(State, Function, Result)
-    catch
-        Type:Data ->
-            handle_function_catch(State, Function, Type, Data)
-    end,
-    after_reply(OProto).
-
-handle_function_catch(State = #thrift_processor{service = Service},
-                      Function, ErrType, ErrData) ->
-    IsOneway = Service:function_info(Function, reply_type) =:= oneway_void,
-
-    case {ErrType, ErrData} of
-        _ when IsOneway ->
-            Stack = erlang:get_stacktrace(),
-            error_logger:warning_msg(
-              "oneway void ~p threw error which must be ignored: ~p",
-              [Function, {ErrType, ErrData, Stack}]),
-            ok;
-
-        {throw, Exception} when is_tuple(Exception), size(Exception) > 0 ->
-            error_logger:warning_msg("~p threw exception: ~p~n", [Function, Exception]),
-            handle_exception(State, Function, Exception),
-            ok;   % we still want to accept more requests from this client
-
-        {error, Error} ->
-            ok = handle_error(State, Function, Error)
-    end.
-
-handle_success(State = #thrift_processor{out_protocol = OProto,
-                                         service = Service},
-               Function,
-               Result) ->
-    ReplyType  = Service:function_info(Function, reply_type),
-    StructName = atom_to_list(Function) ++ "_result",
-
-    ok = case Result of
-             {reply, ReplyData} ->
-                 Reply = {{struct, [{0, ReplyType}]}, {StructName, ReplyData}},
-                 send_reply(OProto, Function, ?tMessageType_REPLY, Reply);
-
-             ok when ReplyType == {struct, []} ->
-                 send_reply(OProto, Function, ?tMessageType_REPLY, {ReplyType, {StructName}});
-
-             ok when ReplyType == oneway_void ->
-                 %% no reply for oneway void
-                 ok
-         end.
-
-handle_exception(State = #thrift_processor{out_protocol = OProto,
-                                           service = Service},
-                 Function,
-                 Exception) ->
-    ExceptionType = element(1, Exception),
-    %% Fetch a structure like {struct, [{-2, {struct, {Module, Type}}},
-    %%                                  {-3, {struct, {Module, Type}}}]}
-
-    ReplySpec = Service:function_info(Function, exceptions),
-    {struct, XInfo} = ReplySpec,
-
-    true = is_list(XInfo),
-
-    %% Assuming we had a type1 exception, we'd get: [undefined, Exception, undefined]
-    %% e.g.: [{-1, type0}, {-2, type1}, {-3, type2}]
-    ExceptionList = [case Type of
-                         ExceptionType -> Exception;
-                         _ -> undefined
-                     end
-                     || {_Fid, {struct, {_Module, Type}}} <- XInfo],
-
-    ExceptionTuple = list_to_tuple([Function | ExceptionList]),
-
-                                                % Make sure we got at least one defined
-    case lists:all(fun(X) -> X =:= undefined end, ExceptionList) of
-        true ->
-            ok = handle_unknown_exception(State, Function, Exception);
-        false ->
-            ok = send_reply(OProto, Function, ?tMessageType_REPLY, {ReplySpec, ExceptionTuple})
-    end.
-
-%%
-%% Called when an exception has been explicitly thrown by the service, but it was
-%% not one of the exceptions that was defined for the function.
-%%
-handle_unknown_exception(State, Function, Exception) ->
-    handle_error(State, Function, {exception_not_declared_as_thrown,
-                                   Exception}).
-
-handle_error(#thrift_processor{out_protocol = OProto}, Function, Error) ->
-    Stack = erlang:get_stacktrace(),
-    error_logger:error_msg("~p had an error: ~p~n", [Function, {Error, Stack}]),
-
-    Message =
-        case application:get_env(thrift, exceptions_include_traces) of
-            {ok, true} ->
-                lists:flatten(io_lib:format("An error occurred: ~p~n",
-                                            [{Error, Stack}]));
-            _ ->
-                "An unknown handler error occurred."
-        end,
-    Reply = {?TApplicationException_Structure,
-             #'TApplicationException'{
-                message = Message,
-                type = ?TApplicationException_UNKNOWN}},
-    send_reply(OProto, Function, ?tMessageType_EXCEPTION, Reply).
-
-send_reply(OProto, Function, ReplyMessageType, Reply) ->
-    ok = thrift_protocol:write(OProto, #protocol_message_begin{
-                                 name = atom_to_list(Function),
-                                 type = ReplyMessageType,
-                                 seqid = 0}),
-    ok = thrift_protocol:write(OProto, Reply),
-    ok = thrift_protocol:write(OProto, message_end),
-    ok = thrift_protocol:flush_transport(OProto),
-    ok.
-
-after_reply(OProto) ->
-    ok = thrift_protocol:flush_transport(OProto)
-    %%     ok = thrift_protocol:close_transport(OProto)
-    .

data/vendor/gems/thrift/lib/erl/src/thrift_protocol.erl

@@ -1,356 +0,0 @@
-%%
-%% 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(thrift_protocol).
-
--export([new/2,
-         write/2,
-         read/2,
-         read/3,
-         skip/2,
-         flush_transport/1,
-         close_transport/1,
-         typeid_to_atom/1
-        ]).
-
--export([behaviour_info/1]).
-
--include("thrift_constants.hrl").
--include("thrift_protocol.hrl").
-
--record(protocol, {module, data}).
-
-behaviour_info(callbacks) ->
-    [
-     {read, 2},
-     {write, 2},
-     {flush_transport, 1},
-     {close_transport, 1}
-    ];
-behaviour_info(_Else) -> undefined.
-
-new(Module, Data) when is_atom(Module) ->
-    {ok, #protocol{module = Module,
-                   data = Data}}.
-
-flush_transport(#protocol{module = Module,
-                          data = Data}) ->
-    Module:flush_transport(Data).
-
-close_transport(#protocol{module = Module,
-                          data = Data}) ->
-    Module:close_transport(Data).
-
-typeid_to_atom(?tType_STOP) -> field_stop;
-typeid_to_atom(?tType_VOID) -> void;
-typeid_to_atom(?tType_BOOL) -> bool;
-typeid_to_atom(?tType_BYTE) -> byte;
-typeid_to_atom(?tType_DOUBLE) -> double;
-typeid_to_atom(?tType_I16) -> i16;
-typeid_to_atom(?tType_I32) -> i32;
-typeid_to_atom(?tType_I64) -> i64;
-typeid_to_atom(?tType_STRING) -> string;
-typeid_to_atom(?tType_STRUCT) -> struct;
-typeid_to_atom(?tType_MAP) -> map;
-typeid_to_atom(?tType_SET) -> set;
-typeid_to_atom(?tType_LIST) -> list.
-
-term_to_typeid(void) -> ?tType_VOID;
-term_to_typeid(bool) -> ?tType_BOOL;
-term_to_typeid(byte) -> ?tType_BYTE;
-term_to_typeid(double) -> ?tType_DOUBLE;
-term_to_typeid(i16) -> ?tType_I16;
-term_to_typeid(i32) -> ?tType_I32;
-term_to_typeid(i64) -> ?tType_I64;
-term_to_typeid(string) -> ?tType_STRING;
-term_to_typeid({struct, _}) -> ?tType_STRUCT;
-term_to_typeid({map, _, _}) -> ?tType_MAP;
-term_to_typeid({set, _}) -> ?tType_SET;
-term_to_typeid({list, _}) -> ?tType_LIST.
-
-%% Structure is like:
-%%    [{Fid, Type}, ...]
-read(IProto, {struct, Structure}, Tag)
-  when is_list(Structure), is_atom(Tag) ->
-
-    % If we want a tagged tuple, we need to offset all the tuple indices
-    % by 1 to avoid overwriting the tag.
-    Offset = if Tag =/= undefined -> 1; true -> 0 end,
-    IndexList = case length(Structure) of
-                    N when N > 0 -> lists:seq(1 + Offset, N + Offset);
-                    _ -> []
-                end,
-
-    SWithIndices = [{Fid, {Type, Index}} ||
-                       {{Fid, Type}, Index} <-
-                           lists:zip(Structure, IndexList)],
-    % Fid -> {Type, Index}
-    SDict = dict:from_list(SWithIndices),
-
-    ok = read(IProto, struct_begin),
-    RTuple0 = erlang:make_tuple(length(Structure) + Offset, undefined),
-    RTuple1 = if Tag =/= undefined -> setelement(1, RTuple0, Tag);
-                 true              -> RTuple0
-              end,
-
-    RTuple2 = read_struct_loop(IProto, SDict, RTuple1),
-    {ok, RTuple2}.
-
-read(IProto, {struct, {Module, StructureName}}) when is_atom(Module),
-                                                     is_atom(StructureName) ->
-    read(IProto, Module:struct_info(StructureName), StructureName);
-
-read(IProto, S={struct, Structure}) when is_list(Structure) ->
-    read(IProto, S, undefined);
-
-read(IProto, {list, Type}) ->
-    #protocol_list_begin{etype = EType, size = Size} =
-        read(IProto, list_begin),
-    List = [Result || {ok, Result} <-
-                          [read(IProto, Type) || _X <- lists:duplicate(Size, 0)]],
-    ok = read(IProto, list_end),
-    {ok, List};
-
-read(IProto, {map, KeyType, ValType}) ->
-    #protocol_map_begin{size = Size} =
-        read(IProto, map_begin),
-
-    List = [{Key, Val} || {{ok, Key}, {ok, Val}} <-
-                              [{read(IProto, KeyType),
-                                read(IProto, ValType)} || _X <- lists:duplicate(Size, 0)]],
-    ok = read(IProto, map_end),
-    {ok, dict:from_list(List)};
-
-read(IProto, {set, Type}) ->
-    #protocol_set_begin{etype = _EType,
-                        size = Size} =
-        read(IProto, set_begin),
-    List = [Result || {ok, Result} <-
-                          [read(IProto, Type) || _X <- lists:duplicate(Size, 0)]],
-    ok = read(IProto, set_end),
-    {ok, sets:from_list(List)};
-
-read(#protocol{module = Module,
-               data = ModuleData}, ProtocolType) ->
-    Module:read(ModuleData, ProtocolType).
-
-read_struct_loop(IProto, SDict, RTuple) ->
-    #protocol_field_begin{type = FType, id = Fid, name = Name} =
-        thrift_protocol:read(IProto, field_begin),
-    case {FType, Fid} of
-        {?tType_STOP, _} ->
-            RTuple;
-        _Else ->
-            case dict:find(Fid, SDict) of
-                {ok, {Type, Index}} ->
-                    case term_to_typeid(Type) of
-                        FType ->
-                            {ok, Val} = read(IProto, Type),
-                            thrift_protocol:read(IProto, field_end),
-                            NewRTuple = setelement(Index, RTuple, Val),
-                            read_struct_loop(IProto, SDict, NewRTuple);
-                        Expected ->
-                            error_logger:info_msg(
-                              "Skipping field ~p with wrong type (~p != ~p)~n",
-                              [Fid, FType, Expected]),
-                            skip_field(FType, IProto, SDict, RTuple)
-                    end;
-                _Else2 ->
-                    error_logger:info_msg("Skipping field ~p with unknown fid~n", [Fid]),
-                    skip_field(FType, IProto, SDict, RTuple)
-            end
-    end.
-
-skip_field(FType, IProto, SDict, RTuple) ->
-    FTypeAtom = thrift_protocol:typeid_to_atom(FType),
-    thrift_protocol:skip(IProto, FTypeAtom),
-    read(IProto, field_end),
-    read_struct_loop(IProto, SDict, RTuple).
-
-
-skip(Proto, struct) ->
-    ok = read(Proto, struct_begin),
-    ok = skip_struct_loop(Proto),
-    ok = read(Proto, struct_end);
-
-skip(Proto, map) ->
-    Map = read(Proto, map_begin),
-    ok = skip_map_loop(Proto, Map),
-    ok = read(Proto, map_end);
-
-skip(Proto, set) ->
-    Set = read(Proto, set_begin),
-    ok = skip_set_loop(Proto, Set),
-    ok = read(Proto, set_end);
-
-skip(Proto, list) ->
-    List = read(Proto, list_begin),
-    ok = skip_list_loop(Proto, List),
-    ok = read(Proto, list_end);
-
-skip(Proto, Type) when is_atom(Type) ->
-    _Ignore = read(Proto, Type),
-    ok.
-
-
-skip_struct_loop(Proto) ->
-    #protocol_field_begin{type = Type} = read(Proto, field_begin),
-    case Type of
-        ?tType_STOP ->
-            ok;
-        _Else ->
-            skip(Proto, Type),
-            ok = read(Proto, field_end),
-            skip_struct_loop(Proto)
-    end.
-
-skip_map_loop(Proto, Map = #protocol_map_begin{ktype = Ktype,
-                                               vtype = Vtype,
-                                               size = Size}) ->
-    case Size of
-        N when N > 0 ->
-            skip(Proto, Ktype),
-            skip(Proto, Vtype),
-            skip_map_loop(Proto,
-                          Map#protocol_map_begin{size = Size - 1});
-        0 -> ok
-    end.
-
-skip_set_loop(Proto, Map = #protocol_set_begin{etype = Etype,
-                                               size = Size}) ->
-    case Size of
-        N when N > 0 ->
-            skip(Proto, Etype),
-            skip_set_loop(Proto,
-                          Map#protocol_set_begin{size = Size - 1});
-        0 -> ok
-    end.
-
-skip_list_loop(Proto, Map = #protocol_list_begin{etype = Etype,
-                                                 size = Size}) ->
-    case Size of
-        N when N > 0 ->
-            skip(Proto, Etype),
-            skip_list_loop(Proto,
-                           Map#protocol_list_begin{size = Size - 1});
-        0 -> ok
-    end.
-
-
-%%--------------------------------------------------------------------
-%% Function: write(OProto, {Type, Data}) -> ok
-%%
-%% Type = {struct, StructDef} |
-%%        {list, Type} |
-%%        {map, KeyType, ValType} |
-%%        {set, Type} |
-%%        BaseType
-%%
-%% Data =
-%%         tuple()  -- for struct
-%%       | list()   -- for list
-%%       | dictionary()   -- for map
-%%       | set()    -- for set
-%%       | term()   -- for base types
-%%
-%% Description:
-%%--------------------------------------------------------------------
-write(Proto, {{struct, StructDef}, Data})
-  when is_list(StructDef), is_tuple(Data), length(StructDef) == size(Data) - 1 ->
-
-    [StructName | Elems] = tuple_to_list(Data),
-    ok = write(Proto, #protocol_struct_begin{name = StructName}),
-    ok = struct_write_loop(Proto, StructDef, Elems),
-    ok = write(Proto, struct_end),
-    ok;
-
-write(Proto, {{struct, {Module, StructureName}}, Data})
-  when is_atom(Module),
-       is_atom(StructureName),
-       element(1, Data) =:= StructureName ->
-    StructType = Module:struct_info(StructureName),
-    write(Proto, {Module:struct_info(StructureName), Data});
-
-write(Proto, {{list, Type}, Data})
-  when is_list(Data) ->
-    ok = write(Proto,
-               #protocol_list_begin{
-                 etype = term_to_typeid(Type),
-                 size = length(Data)
-                }),
-    lists:foreach(fun(Elem) ->
-                          ok = write(Proto, {Type, Elem})
-                  end,
-                  Data),
-    ok = write(Proto, list_end),
-    ok;
-
-write(Proto, {{map, KeyType, ValType}, Data}) ->
-    ok = write(Proto,
-               #protocol_map_begin{
-                 ktype = term_to_typeid(KeyType),
-                 vtype = term_to_typeid(ValType),
-                 size  = dict:size(Data)
-                }),
-    dict:fold(fun(KeyData, ValData, _Acc) ->
-                      ok = write(Proto, {KeyType, KeyData}),
-                      ok = write(Proto, {ValType, ValData})
-              end,
-              _AccO = ok,
-              Data),
-    ok = write(Proto, map_end),
-    ok;
-
-write(Proto, {{set, Type}, Data}) ->
-    true = sets:is_set(Data),
-    ok = write(Proto,
-               #protocol_set_begin{
-                 etype = term_to_typeid(Type),
-                 size  = sets:size(Data)
-                }),
-    sets:fold(fun(Elem, _Acc) ->
-                      ok = write(Proto, {Type, Elem})
-              end,
-              _Acc0 = ok,
-              Data),
-    ok = write(Proto, set_end),
-    ok;
-
-write(#protocol{module = Module,
-                data = ModuleData}, Data) ->
-    Module:write(ModuleData, Data).
-
-struct_write_loop(Proto, [{Fid, Type} | RestStructDef], [Data | RestData]) ->
-    case Data of
-        undefined ->
-            % null fields are skipped in response
-            skip;
-        _ ->
-            ok = write(Proto,
-                       #protocol_field_begin{
-                         type = term_to_typeid(Type),
-                         id = Fid
-                        }),
-            ok = write(Proto, {Type, Data}),
-            ok = write(Proto, field_end)
-    end,
-    struct_write_loop(Proto, RestStructDef, RestData);
-struct_write_loop(Proto, [], []) ->
-    ok = write(Proto, field_stop),
-    ok.