auser-poolparty 1.3.1 → 1.3.2

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

@@ -1,180 +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_buffered_transport).
-
--behaviour(gen_server).
--behaviour(thrift_transport).
-
-%% API
--export([new/1, new_transport_factory/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(buffered_transport, {wrapped, % a thrift_transport
-                             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}, _Timeout=10000).
-
-%%====================================================================
-%% gen_server callbacks
-%%====================================================================
-
-%%--------------------------------------------------------------------
-%% Function: init(Args) -> {ok, State} |
-%%                         {ok, State, Timeout} |
-%%                         ignore               |
-%%                         {stop, Reason}
-%% Description: Initiates the server
-%%--------------------------------------------------------------------
-init([Wrapped]) ->
-    {ok, #buffered_transport{wrapped = Wrapped,
-                             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 = #buffered_transport{write_buffer = WBuf}) ->
-    {reply, ok, State#buffered_transport{write_buffer = [WBuf, Data]}};
-
-handle_call({read, Len}, _From, State = #buffered_transport{wrapped = Wrapped}) ->
-    Response = thrift_transport:read(Wrapped, Len),
-    {reply, Response, State};
-
-handle_call(flush, _From, State = #buffered_transport{write_buffer = WBuf,
-                                                      wrapped = Wrapped}) ->
-    Response = thrift_transport:write(Wrapped, WBuf),
-    thrift_transport:flush(Wrapped),
-    {reply, Response, State#buffered_transport{write_buffer = []}}.
-
-%%--------------------------------------------------------------------
-%% Function: handle_cast(Msg, State) -> {noreply, State} |
-%%                                      {noreply, State, Timeout} |
-%%                                      {stop, Reason, State}
-%% Description: Handling cast messages
-%%--------------------------------------------------------------------
-handle_cast(close, State = #buffered_transport{write_buffer = WBuf,
-                                               wrapped = Wrapped}) ->
-    thrift_transport:write(Wrapped, WBuf),
-    %% Wrapped is closed by terminate/2
-    %%  error_logger:info_msg("thrift_buffered_transport ~p: closing", [self()]),
-    {stop, normal, State};
-handle_cast(Msg, State=#buffered_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 = #buffered_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
-%%--------------------------------------------------------------------
-%%%% FACTORY GENERATION %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-new_transport_factory(WrapFactory) ->
-    F = fun() ->
-                {ok, Wrapped} = WrapFactory(),
-                new(Wrapped)
-        end,
-    {ok, F}.

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

@@ -1,384 +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_client).
-
--behaviour(gen_server).
-
-%% API
--export([start_link/2, start_link/3, start_link/4,
-         start/3, start/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 as a linked process.
-%%--------------------------------------------------------------------
-start_link(Host, Port, Service) when is_integer(Port), is_atom(Service) ->
-    start_link(Host, Port, Service, []).
-
-start_link(Host, Port, Service, Options) ->
-    start(Host, Port, Service, [{monitor, link} | Options]).
-
-start_link(ProtocolFactory, Service) ->
-    start(ProtocolFactory, Service, [{monitor, link}]).
-
-%%
-%% Splits client options into protocol options and transport options
-%%
-%% split_options([Options...]) -> {ProtocolOptions, TransportOptions}
-%%
-split_options(Options) ->
-    split_options(Options, [], [], []).
-
-split_options([], ClientIn, ProtoIn, TransIn) ->
-    {ClientIn, ProtoIn, TransIn};
-
-split_options([Opt = {OptKey, _} | Rest], ClientIn, ProtoIn, TransIn)
-  when OptKey =:= monitor ->
-    split_options(Rest, [Opt | ClientIn], ProtoIn, TransIn);
-
-split_options([Opt = {OptKey, _} | Rest], ClientIn, ProtoIn, TransIn)
-  when OptKey =:= strict_read;
-       OptKey =:= strict_write ->
-    split_options(Rest, ClientIn, [Opt | ProtoIn], TransIn);
-
-split_options([Opt = {OptKey, _} | Rest], ClientIn, ProtoIn, TransIn)
-  when OptKey =:= framed;
-       OptKey =:= connect_timeout;
-       OptKey =:= sockopts ->
-    split_options(Rest, ClientIn, ProtoIn, [Opt | TransIn]).
-
-
-%%--------------------------------------------------------------------
-%% Function: start() -> {ok,Pid} | ignore | {error,Error}
-%% Description: Starts the server as an unlinked process.
-%%--------------------------------------------------------------------
-
-%% Backwards-compatible starter for the common-case of socket transports
-start(Host, Port, Service, Options)
-  when is_integer(Port), is_atom(Service), is_list(Options) ->
-    {ClientOpts, 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(ProtocolFactory, Service, ClientOpts).
-
-
-%% ProtocolFactory :: fun() -> thrift_protocol()
-start(ProtocolFactory, Service, ClientOpts)
-  when is_function(ProtocolFactory), is_atom(Service) ->
-    {Starter, Opts} =
-        case lists:keysearch(monitor, 1, ClientOpts) of
-            {value, {monitor, link}} ->
-                {start_link, []};
-            {value, {monitor, tether}} ->
-                {start, [{tether, self()}]};
-            _ ->
-                {start, []}
-        end,
-
-    Connect =
-        case lists:keysearch(connect, 1, ClientOpts) of
-            {value, {connect, Choice}} ->
-                Choice;
-            _ ->
-                %% By default, connect at creation-time.
-                true
-        end,
-
-
-    Started = gen_server:Starter(?MODULE, [Service, Opts], []),
-
-    if
-        Connect ->
-            case Started of
-                {ok, Pid} ->
-                    case gen_server:call(Pid, {connect, ProtocolFactory}) of
-                        ok ->
-                            {ok, Pid};
-                        Error ->
-                            Error
-                    end;
-                Else ->
-                    Else
-            end;
-        true ->
-            Started
-    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-oneway 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, Opts]) ->
-    case lists:keysearch(tether, 1, Opts) of
-        {value, {tether, Pid}} ->
-            erlang:monitor(process, Pid);
-        _Else ->
-            ok
-    end,
-    {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({'DOWN', MonitorRef, process, Pid, _Info}, State)
-  when is_reference(MonitorRef), is_pid(Pid) ->
-    %% We don't actually verify the correctness of the DOWN message.
-    {stop, parent_died, State};
-
-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,
-            oneway_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/vendor/gems/thrift/lib/erl/src/thrift_disk_log_transport.erl

@@ -1,118 +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.
-%%
-
-%%% 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).