RubyGems - poolparty - Versions diffs - 1.3.15 → 1.4.0 - Mend

poolparty 1.3.15 → 1.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1171) hide show

data/examples/thrift/erlang/deps/thrift/src/thrift_client.erl DELETED Viewed

@@ -1,328 +0,0 @@
-%%%-------------------------------------------------------------------
-%%% File    : thrift_client.erl
-%%% Author  : Todd Lipcon <todd@lipcon.org>
-%%% Description : A client which connects to a thrift service
-%%%
-%%% Created : 24 Feb 2008 by Todd Lipcon <todd@lipcon.org>
-%%%-------------------------------------------------------------------
--module(thrift_client).
--behaviour(gen_server).
-%% API
--export([start_link/2, start_link/3, start_link/4, call/3, send_call/3, close/1]).
-%% gen_server callbacks
--export([init/1, handle_call/3, handle_cast/2, handle_info/2,
-         terminate/2, code_change/3]).
--include("thrift_constants.hrl").
--include("thrift_protocol.hrl").
--record(state, {service, protocol, seqid}).
-%%====================================================================
-%% API
-%%====================================================================
-%%--------------------------------------------------------------------
-%% Function: start_link() -> {ok,Pid} | ignore | {error,Error}
-%% Description: Starts the server
-%%--------------------------------------------------------------------
-start_link(Host, Port, Service) when is_integer(Port), is_atom(Service) ->
-    start_link(Host, Port, Service, []).
-%%
-%% Splits client options into protocol options and transport options
-%%
-%% split_options([Options...]) -> {ProtocolOptions, TransportOptions}
-%%
-split_options(Options) ->
-    split_options(Options, [], []).
-split_options([], ProtoIn, TransIn) ->
-    {ProtoIn, TransIn};
-split_options([Opt = {OptKey, _} | Rest], ProtoIn, TransIn)
-  when OptKey =:= strict_read;
-       OptKey =:= strict_write ->
-    split_options(Rest, [Opt | ProtoIn], TransIn);
-split_options([Opt = {OptKey, _} | Rest], ProtoIn, TransIn)
-  when OptKey =:= framed;
-       OptKey =:= connect_timeout;
-       OptKey =:= sockopts ->
-    split_options(Rest, ProtoIn, [Opt | TransIn]).
-%% Backwards-compatible starter for the common-case of socket transports
-start_link(Host, Port, Service, Options)
-  when is_integer(Port), is_atom(Service), is_list(Options) ->
-    {ProtoOpts, TransOpts} = split_options(Options),
-    % {ok, TransportFactory} =
-    %     thrift_socket_transport:new_transport_factory(Host, Port, TransOpts),
-    %
-    % {ok, ProtocolFactory} = thrift_binary_protocol:new_protocol_factory(
-    %                           TransportFactory, ProtoOpts),
-    %
-    % start_link(ProtocolFactory, Service).
-    {ok, TransportFactory} = thrift_socket_transport:new_transport_factory(Host, Port,  TransOpts),
-    case thrift_socket_transport:new_transport_factory(Host, Port, TransOpts) of
-      {ok, TransportFactory} ->
-        case thrift_binary_protocol:new_protocol_factory(TransportFactory,  ProtoOpts) of
-          {ok, ProtocolFactory} ->  start_link(ProtocolFactory, Service);
-          Else                  ->
-            io:format("Error with new_protocol_factory(~p): ~p~n", [TransportFactory, Else]),
-            Else
-        end;
-      Else -> Else
-    end.
-%% ProtocolFactory :: fun() -> thrift_protocol()
-start_link(ProtocolFactory, Service)
-  when is_function(ProtocolFactory), is_atom(Service) ->
-    case gen_server:start_link(?MODULE, [Service], []) of
-        {ok, Pid} ->
-            case gen_server:call(Pid, {connect, ProtocolFactory}) of
-                ok ->
-                    {ok, Pid};
-                Error ->
-                    Error
-            end;
-        Else ->
-            Else
-    end.
-call(Client, Function, Args) when is_pid(Client), is_atom(Function), is_list(Args) ->
-    case gen_server:call(Client, {call, Function, Args}) of
-        R = {ok, _} -> R;
-        R = {error, _} -> R;
-        {exception, Exception} -> throw(Exception)
-    end.
-cast(Client, Function, Args)
-  when is_pid(Client), is_atom(Function), is_list(Args) ->
-    gen_server:cast(Client, {call, Function, Args}).
-%% Sends a function call but does not read the result. This is useful
-%% if you're trying to log non-async function calls to write-only
-%% transports like thrift_disk_log_transport.
-send_call(Client, Function, Args)
-  when is_pid(Client), is_atom(Function), is_list(Args) ->
-    gen_server:call(Client, {send_call, Function, Args}).
-close(Client) when is_pid(Client) ->
-    gen_server:cast(Client, close).
-%%====================================================================
-%% gen_server callbacks
-%%====================================================================
-%%--------------------------------------------------------------------
-%% Function: init(Args) -> {ok, State} |
-%%                         {ok, State, Timeout} |
-%%                         ignore               |
-%%                         {stop, Reason}
-%% Description: Initiates the server
-%%--------------------------------------------------------------------
-init([Service]) ->
-    {ok, #state{service = Service}}.
-%%--------------------------------------------------------------------
-%% Function: %% handle_call(Request, From, State) -> {reply, Reply, State} |
-%%                                      {reply, Reply, State, Timeout} |
-%%                                      {noreply, State} |
-%%                                      {noreply, State, Timeout} |
-%%                                      {stop, Reason, Reply, State} |
-%%                                      {stop, Reason, State}
-%% Description: Handling call messages
-%%--------------------------------------------------------------------
-handle_call({connect, ProtocolFactory}, _From,
-            State = #state{service = Service}) ->
-    case ProtocolFactory() of
-        {ok, Protocol} ->
-            {reply, ok, State#state{protocol = Protocol,
-                                    seqid = 0}};
-        Error ->
-            {stop, normal, Error, State}
-    end;
-handle_call({call, Function, Args}, _From, State = #state{service = Service}) ->
-    Result = catch_function_exceptions(
-               fun() ->
-                       ok = send_function_call(State, Function, Args),
-                       receive_function_result(State, Function)
-               end,
-               Service),
-    {reply, Result, State};
-handle_call({send_call, Function, Args}, _From, State = #state{service = Service}) ->
-    Result = catch_function_exceptions(
-               fun() ->
-                       send_function_call(State, Function, Args)
-               end,
-               Service),
-    {reply, Result, State}.
-%% Helper function that catches exceptions thrown by sending or receiving
-%% a function and returns the correct response for call or send_only above.
-catch_function_exceptions(Fun, Service) ->
-    try
-        Fun()
-    catch
-        throw:{return, Return} ->
-            Return;
-          error:function_clause ->
-            ST = erlang:get_stacktrace(),
-            case hd(ST) of
-                {Service, function_info, [Function, _]} ->
-                    {error, {no_function, Function}};
-                _ -> throw({error, {function_clause, ST}})
-            end
-    end.
-%%--------------------------------------------------------------------
-%% Function: handle_cast(Msg, State) -> {noreply, State} |
-%%                                      {noreply, State, Timeout} |
-%%                                      {stop, Reason, State}
-%% Description: Handling cast messages
-%%--------------------------------------------------------------------
-handle_cast({call, Function, Args}, State = #state{service = Service,
-                                                   protocol = Protocol,
-                                                   seqid = SeqId}) ->
-    _Result =
-        try
-            ok = send_function_call(State, Function, Args),
-            receive_function_result(State, Function)
-        catch
-            Class:Reason ->
-                error_logger:error_msg("error ignored in handle_cast({cast,...},...): ~p:~p~n", [Class, Reason])
-        end,
-    {noreply, State};
-handle_cast(close, State=#state{protocol = Protocol}) ->
-%%     error_logger:info_msg("thrift_client ~p received close", [self()]),
-    {stop,normal,State};
-handle_cast(_Msg, State) ->
-    {noreply, State}.
-%%--------------------------------------------------------------------
-%% Function: handle_info(Info, State) -> {noreply, State} |
-%%                                       {noreply, State, Timeout} |
-%%                                       {stop, Reason, State}
-%% Description: Handling all non call/cast messages
-%%--------------------------------------------------------------------
-handle_info(_Info, State) ->
-    {noreply, State}.
-%%--------------------------------------------------------------------
-%% Function: terminate(Reason, State) -> void()
-%% Description: This function is called by a gen_server when it is about to
-%% terminate. It should be the opposite of Module:init/1 and do any necessary
-%% cleaning up. When it returns, the gen_server terminates with Reason.
-%% The return value is ignored.
-%%--------------------------------------------------------------------
-terminate(Reason, State = #state{protocol=undefined}) ->
-    ok;
-terminate(Reason, State = #state{protocol=Protocol}) ->
-    thrift_protocol:close_transport(Protocol),
-    ok.
-%%--------------------------------------------------------------------
-%% Func: code_change(OldVsn, State, Extra) -> {ok, NewState}
-%% Description: Convert process state when code is changed
-%%--------------------------------------------------------------------
-code_change(_OldVsn, State, _Extra) ->
-    {ok, State}.
-%%--------------------------------------------------------------------
-%%% Internal functions
-%%--------------------------------------------------------------------
-send_function_call(#state{protocol = Proto,
-                          service  = Service,
-                          seqid    = SeqId},
-                   Function,
-                   Args) ->
-    Params = Service:function_info(Function, params_type),
-    {struct, PList} = Params,
-    if
-        length(PList) =/= length(Args) ->
-            throw({return, {error, {bad_args, Function, Args}}});
-        true -> ok
-    end,
-    Begin = #protocol_message_begin{name = atom_to_list(Function),
-                                    type = ?tMessageType_CALL,
-                                    seqid = SeqId},
-    ok = thrift_protocol:write(Proto, Begin),
-    ok = thrift_protocol:write(Proto, {Params, list_to_tuple([Function | Args])}),
-    ok = thrift_protocol:write(Proto, message_end),
-    thrift_protocol:flush_transport(Proto),
-    ok.
-receive_function_result(State = #state{protocol = Proto,
-                                       service = Service},
-                        Function) ->
-    ResultType = Service:function_info(Function, reply_type),
-    read_result(State, Function, ResultType).
-read_result(_State,
-            _Function,
-            async_void) ->
-    {ok, ok};
-read_result(State = #state{protocol = Proto,
-                           seqid    = SeqId},
-            Function,
-            ReplyType) ->
-    case thrift_protocol:read(Proto, message_begin) of
-        #protocol_message_begin{seqid = RetSeqId} when RetSeqId =/= SeqId ->
-            {error, {bad_seq_id, SeqId}};
-        #protocol_message_begin{type = ?tMessageType_EXCEPTION} ->
-            handle_application_exception(State);
-        #protocol_message_begin{type = ?tMessageType_REPLY} ->
-            handle_reply(State, Function, ReplyType)
-    end.
-handle_reply(State = #state{protocol = Proto,
-                            service = Service},
-             Function,
-             ReplyType) ->
-    {struct, ExceptionFields} = Service:function_info(Function, exceptions),
-    ReplyStructDef = {struct, [{0, ReplyType}] ++ ExceptionFields},
-    {ok, Reply} = thrift_protocol:read(Proto, ReplyStructDef),
-    ReplyList = tuple_to_list(Reply),
-    true = length(ReplyList) == length(ExceptionFields) + 1,
-    ExceptionVals = tl(ReplyList),
-    Thrown = [X || X <- ExceptionVals,
-                   X =/= undefined],
-    Result =
-        case Thrown of
-            [] when ReplyType == {struct, []} ->
-                {ok, ok};
-            [] ->
-                {ok, hd(ReplyList)};
-            [Exception] ->
-                {exception, Exception}
-        end,
-    ok = thrift_protocol:read(Proto, message_end),
-    Result.
-handle_application_exception(State = #state{protocol = Proto}) ->
-    {ok, Exception} = thrift_protocol:read(Proto,
-                                           ?TApplicationException_Structure),
-    ok = thrift_protocol:read(Proto, message_end),
-    XRecord = list_to_tuple(
-                ['TApplicationException' | tuple_to_list(Exception)]),
-    error_logger:error_msg("X: ~p~n", [XRecord]),
-    true = is_record(XRecord, 'TApplicationException'),
-    {exception, XRecord}.

data/examples/thrift/erlang/deps/thrift/src/thrift_disk_log_transport.erl DELETED Viewed

@@ -1,106 +0,0 @@
-%%%-------------------------------------------------------------------
-%%% File    : thrift_disk_log_transport.erl
-%%% Author  : Todd Lipcon <todd@amiestreet.com>
-%%% Description : Write-only Thrift transport outputting to disk_log
-%%% Created : 22 Apr 2008 by Todd Lipcon <todd@lipcon.org>
-%%%
-%%% Todo: this might be better off as a gen_server type of transport
-%%%       that handles stuff like group commit, similar to TFileTransport
-%%%       in cpp land
-%%%-------------------------------------------------------------------
--module(thrift_disk_log_transport).
--behaviour(thrift_transport).
-%% API
--export([new/2, new_transport_factory/2, new_transport_factory/3]).
-%% thrift_transport callbacks
--export([read/2, write/2, force_flush/1, flush/1, close/1]).
-%% state
--record(dl_transport, {log,
-                       close_on_close = false,
-                       sync_every = infinity,
-                       sync_tref}).
-%% Create a transport attached to an already open log.
-%% If you'd like this transport to close the disk_log using disk_log:lclose()
-%% when the transport is closed, pass a {close_on_close, true} tuple in the
-%% Opts list.
-new(LogName, Opts) when is_atom(LogName), is_list(Opts) ->
-    State = parse_opts(Opts, #dl_transport{log = LogName}),
-    State2 =
-        case State#dl_transport.sync_every of
-            N when is_integer(N), N > 0 ->
-                {ok, TRef} = timer:apply_interval(N, ?MODULE, force_flush, State),
-                State#dl_transport{sync_tref = TRef};
-            _ -> State
-        end,
-    thrift_transport:new(?MODULE, State2).
-parse_opts([], State) ->
-    State;
-parse_opts([{close_on_close, Bool} | Rest], State) when is_boolean(Bool) ->
-    State#dl_transport{close_on_close = Bool};
-parse_opts([{sync_every, Int} | Rest], State) when is_integer(Int), Int > 0 ->
-    State#dl_transport{sync_every = Int}.
-%%%% TRANSPORT IMPLENTATION %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%% disk_log_transport is write-only
-read(_State, Len) ->
-    {error, no_read_from_disk_log}.
-write(#dl_transport{log = Log}, Data) ->
-    disk_log:balog(Log, erlang:iolist_to_binary(Data)).
-force_flush(#dl_transport{log = Log}) ->
-    error_logger:info_msg("~p syncing~n", [?MODULE]),
-    disk_log:sync(Log).
-flush(#dl_transport{log = Log, sync_every = SE}) ->
-    case SE of
-        undefined -> % no time-based sync
-            disk_log:sync(Log);
-        _Else ->     % sync will happen automagically
-            ok
-    end.
-%% On close, close the underlying log if we're configured to do so.
-close(#dl_transport{close_on_close = false}) ->
-    ok;
-close(#dl_transport{log = Log}) ->
-    disk_log:lclose(Log).
-%%%% FACTORY GENERATION %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-new_transport_factory(Name, ExtraLogOpts) ->
-    new_transport_factory(Name, ExtraLogOpts, [{close_on_close, true},
-                                               {sync_every, 500}]).
-new_transport_factory(Name, ExtraLogOpts, TransportOpts) ->
-    F = fun() -> factory_impl(Name, ExtraLogOpts, TransportOpts) end,
-    {ok, F}.
-factory_impl(Name, ExtraLogOpts, TransportOpts) ->
-    LogOpts = [{name, Name},
-               {format, external},
-               {type, wrap} |
-               ExtraLogOpts],
-    Log =
-        case disk_log:open(LogOpts) of
-            {ok, Log} ->
-                Log;
-            {repaired, Log, Info1, Info2} ->
-                error_logger:info_msg("Disk log ~p repaired: ~p, ~p~n", [Log, Info1, Info2]),
-                Log
-        end,
-    new(Log, TransportOpts).

data/examples/thrift/erlang/deps/thrift/src/thrift_file_transport.erl DELETED Viewed

@@ -1,69 +0,0 @@
--module(thrift_file_transport).
--author(todd@amiestreet.com).
--behaviour(thrift_transport).
--export([new_reader/1,
-         new/1,
-         new/2,
-         write/2, read/2, flush/1, close/1]).
--record(t_file_transport, {device,
-                           should_close = true,
-                           mode = write}).
-%%%% CONSTRUCTION   %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-new_reader(Filename) ->
-    case file:open(Filename, [read, binary, {read_ahead, 1024*1024}]) of
-        {ok, IODevice} ->
-            new(IODevice, [{should_close, true}, {mode, read}]);
-        Error -> Error
-    end.
-new(Device) ->
-    new(Device, []).
-%% Device :: io_device()
-%%
-%% Device should be opened in raw and binary mode.
-new(Device, Opts) when is_list(Opts) ->
-    State = parse_opts(Opts, #t_file_transport{device = Device}),
-    thrift_transport:new(?MODULE, State).
-%% Parse options
-parse_opts([{should_close, Bool} | Rest], State) when is_boolean(Bool) ->
-    parse_opts(Rest, State#t_file_transport{should_close = Bool});
-parse_opts([{mode, Mode} | Rest], State)
-  when Mode =:= write;
-       Mode =:= read ->
-    parse_opts(Rest, State#t_file_transport{mode = Mode});
-parse_opts([], State) ->
-     State.
-%%%% TRANSPORT IMPL %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-write(#t_file_transport{device = Device, mode = write}, Data) ->
-    file:write(Device, Data);
-write(_T, _D) ->
-    {error, read_mode}.
-read(#t_file_transport{device = Device, mode = read}, Len)
-  when is_integer(Len), Len >= 0 ->
-    file:read(Device, Len);
-read(_T, _D) ->
-    {error, read_mode}.
-flush(#t_file_transport{device = Device, mode = write}) ->
-    file:sync(Device).
-close(#t_file_transport{device = Device, should_close = SC}) ->
-    case SC of
-        true ->
-            file:close(Device);
-        false ->
-            ok
-    end.

data/examples/thrift/erlang/deps/thrift/src/thrift_framed_transport.erl DELETED Viewed

@@ -1,196 +0,0 @@
-%%%-------------------------------------------------------------------
-%%% File    : thrift_framed_transport.erl
-%%% Author  : <cpiro@facebook.com>
-%%% Description : Framed transport for thrift
-%%%
-%%% Created : 12 Mar 2008 by <cpiro@facebook.com>
-%%%-------------------------------------------------------------------
--module(thrift_framed_transport).
--behaviour(gen_server).
--behaviour(thrift_transport).
-%% API
--export([new/1]).
-%% gen_server callbacks
--export([init/1, handle_call/3, handle_cast/2, handle_info/2,
-         terminate/2, code_change/3]).
-%% thrift_transport callbacks
--export([write/2, read/2, flush/1, close/1]).
--record(framed_transport, {wrapped, % a thrift_transport
-                           read_buffer, % iolist()
-                           write_buffer % iolist()
-                          }).
-%%====================================================================
-%% API
-%%====================================================================
-%%--------------------------------------------------------------------
-%% Function: start_link() -> {ok,Pid} | ignore | {error,Error}
-%% Description: Starts the server
-%%--------------------------------------------------------------------
-new(WrappedTransport) ->
-    case gen_server:start_link(?MODULE, [WrappedTransport], []) of
-        {ok, Pid} ->
-            thrift_transport:new(?MODULE, Pid);
-        Else ->
-            Else
-    end.
-%%--------------------------------------------------------------------
-%% Function: write(Transport, Data) -> ok
-%%
-%% Data = iolist()
-%%
-%% Description: Writes data into the buffer
-%%--------------------------------------------------------------------
-write(Transport, Data) ->
-    gen_server:call(Transport, {write, Data}).
-%%--------------------------------------------------------------------
-%% Function: flush(Transport) -> ok
-%%
-%% Description: Flushes the buffer through to the wrapped transport
-%%--------------------------------------------------------------------
-flush(Transport) ->
-    gen_server:call(Transport, flush).
-%%--------------------------------------------------------------------
-%% Function: close(Transport) -> ok
-%%
-%% Description: Closes the transport and the wrapped transport
-%%--------------------------------------------------------------------
-close(Transport) ->
-    gen_server:cast(Transport, close).
-%%--------------------------------------------------------------------
-%% Function: Read(Transport, Len) -> {ok, Data}
-%%
-%% Data = binary()
-%%
-%% Description: Reads data through from the wrapped transoprt
-%%--------------------------------------------------------------------
-read(Transport, Len) when is_integer(Len) ->
-    gen_server:call(Transport, {read, Len}).
-%%====================================================================
-%% gen_server callbacks
-%%====================================================================
-%%--------------------------------------------------------------------
-%% Function: init(Args) -> {ok, State} |
-%%                         {ok, State, Timeout} |
-%%                         ignore               |
-%%                         {stop, Reason}
-%% Description: Initiates the server
-%%--------------------------------------------------------------------
-init([Wrapped]) ->
-    {ok, #framed_transport{wrapped = Wrapped,
-                           read_buffer = [],
-                           write_buffer = []}}.
-%%--------------------------------------------------------------------
-%% Function: %% handle_call(Request, From, State) -> {reply, Reply, State} |
-%%                                      {reply, Reply, State, Timeout} |
-%%                                      {noreply, State} |
-%%                                      {noreply, State, Timeout} |
-%%                                      {stop, Reason, Reply, State} |
-%%                                      {stop, Reason, State}
-%% Description: Handling call messages
-%%--------------------------------------------------------------------
-handle_call({write, Data}, _From, State = #framed_transport{write_buffer = WBuf}) ->
-    {reply, ok, State#framed_transport{write_buffer = [WBuf, Data]}};
-handle_call({read, Len}, _From, State = #framed_transport{wrapped = Wrapped,
-                                                          read_buffer = RBuf}) ->
-    {RBuf1, RBuf1Size} =
-        %% if the read buffer is empty, read another frame
-        %% otherwise, just read from what's left in the buffer
-        case iolist_size(RBuf) of
-            0 ->
-                %% read the frame length
-                {ok, <<FrameLen:32/integer-signed-big, _/binary>>} =
-                    thrift_transport:read(Wrapped, 4),
-                %% then read the data
-                {ok, Bin} =
-                    thrift_transport:read(Wrapped, FrameLen),
-                {Bin, erlang:byte_size(Bin)};
-            Sz ->
-                {RBuf, Sz}
-        end,
-    %% pull off Give bytes, return them to the user, leave the rest in the buffer
-    Give = min(RBuf1Size, Len),
-    <<Data:Give/binary, RBuf2/binary>> = iolist_to_binary(RBuf1),
-    Response = {ok, Data},
-    State1 = State#framed_transport{read_buffer=RBuf2},
-    {reply, Response, State1};
-handle_call(flush, _From, State) ->
-    {Response, State1} = do_flush(State),
-    {reply, Response, State1}.
-%%--------------------------------------------------------------------
-%% Function: handle_cast(Msg, State) -> {noreply, State} |
-%%                                      {noreply, State, Timeout} |
-%%                                      {stop, Reason, State}
-%% Description: Handling cast messages
-%%--------------------------------------------------------------------
-handle_cast(close, State) ->
-    {_, State1} = do_flush(State),
-    %% Wrapped is closed by terminate/2
-    %%  error_logger:info_msg("thrift_framed_transport ~p: closing", [self()]),
-    {stop, normal, State};
-handle_cast(Msg, State=#framed_transport{}) ->
-    {noreply, State}.
-%%--------------------------------------------------------------------
-%% Function: handle_info(Info, State) -> {noreply, State} |
-%%                                       {noreply, State, Timeout} |
-%%                                       {stop, Reason, State}
-%% Description: Handling all non call/cast messages
-%%--------------------------------------------------------------------
-handle_info(_Info, State) ->
-    {noreply, State}.
-%%--------------------------------------------------------------------
-%% Function: terminate(Reason, State) -> void()
-%% Description: This function is called by a gen_server when it is about to
-%% terminate. It should be the opposite of Module:init/1 and do any necessary
-%% cleaning up. When it returns, the gen_server terminates with Reason.
-%% The return value is ignored.
-%%--------------------------------------------------------------------
-terminate(_Reason, State = #framed_transport{wrapped=Wrapped}) ->
-    thrift_transport:close(Wrapped),
-    ok.
-%%--------------------------------------------------------------------
-%% Func: code_change(OldVsn, State, Extra) -> {ok, NewState}
-%% Description: Convert process state when code is changed
-%%--------------------------------------------------------------------
-code_change(_OldVsn, State, _Extra) ->
-    {ok, State}.
-%%--------------------------------------------------------------------
-%%% Internal functions
-%%--------------------------------------------------------------------
-do_flush(State = #framed_transport{write_buffer = Buffer,
-                                   wrapped = Wrapped}) ->
-    FrameLen = iolist_size(Buffer),
-    Data     = [<<FrameLen:32/integer-signed-big>>, Buffer],
-    Response = thrift_transport:write(Wrapped, Data),
-    thrift_transport:flush(Wrapped),
-    State1 = State#framed_transport{write_buffer = []},
-    {Response, State1}.
-min(A,B) when A<B -> A;
-min(_,B)          -> B.