Erlang gen_服务器：使用新状态调用

一个模块调用一个

gen_服务器

来处理一个流，该流使用记录作为状态

handle\u调用

使用来自

状态

的函数处理流，该函数将完成的数据段和尾部分开

现在，下一次，在模块发送更多数据之前，应该首先向尾部提供更新的

状态

handle_call({stream, Data}, _From, State = #mystate{myfun=Fun}) ->
    case Fun(Data) of
       {completed piece,tail} -> 
           dosomethingwithpieace,
           NewState = State##mystate{myfun=resetfun()};
           % How do i call this again to feed Tail first with new state?
       {stillstreaming, Currentstate} ->
           NewState = State##mystate{myfun=CurrentState};

我无法调用
genu服务器：调用（self（），{stream，Tail}）
，因为
状态需要首先更新。
我不能用新的
状态答复，因为模块将发送更多数据，尾部将消失

是否有一种方法可以使用更新的
状态再次调用它，而不必使用tail进行应答并从模块反馈tail

更新，代码：

% caller module
case gen_tcp:recv(Socket, 0) of % cannot set Length as it will block untill it is done reading Length number of bytes 
    {ok, Data} ->
        Response = gen_server:call(Pid, {handle_init,Socket,Data}),
        case Response of
            {ok, continue} ->
                pre_loop(Socket, Pid);
            {ok, logged_in} ->
                {UserId, UserName} = get_user_data(), % ignore it for now.
                receiver_loop(UserId, UserName, Socket, Pid);
            {stop, Reason} ->
                io:format("Error at pre_loop: ~p~n", [Reason]);
            _ ->
                io:format("Unknown response from call in pre-loop: ~p~n", [Response])
        end;
    {error, closed} -> % done here as no data was stored in mnesia yet.
        gen_server:stop(Pid),
        io:format("Client died in pre_loop~n")
end.

和gen_服务器模块：

% gen_server module
handle_call({handle_init, _Socket, Data}, _From, State = #server_state{data_fun =  {incomplete, Fun}}) ->
    case catch Fun(Data) of
        {incomplete, F} ->
            NewState = State#server_state{data_fun = {incomplete, F}},
            {reply, {ok, continue}, NewState};
        {with_tail, Term, Tail} ->
            % handle Term login/register only
            case handle_input_init(Term, Tail) of
                {incomplete, Fn, logged_in} ->
                    NewState = State#server_state{data_fun = {incomplete, Fn}},
                    {reply, {ok, logged_in}, NewState};
                {incomplete, Fn} ->
                    NewState = State#server_state{data_fun = {incomplete, Fn}},
                    {reply, {ok, continue}, NewState};
                {stop, malformed_data} ->
                    {reply, {stop, malformed_data}, State}
            end;
        _ ->
            {reply, {stop, malformed_data}, State}
    end;

handle_call(_Message, _From, State = #server_state{}) ->
{reply, {stop , unknown_call}, State}.

handle_input_init(Term, Tail) ->
case handle_term_init(Term) of
    {ok, login_passed} ->
        io:format("send user a login pass msg"),
        handle_tail_init(Tail, logged_in);
    {error, login_failed} ->
        io:format("send user a login failed error~n"),
        handle_tail_init(Tail);
    {ok, registration_passed} ->
        io:format("send user a registeration passed msg"),
        handle_tail_init(Tail);
    {error, registration_failed} ->
        io:format("send user a registeration failed error"),
        handle_tail_init(Tail);
    {error, invalidreq} ->
        io:format("send user an invalid requst error~n"),
        handle_tail_init(Tail)
end.

handle_tail_init(Tail) ->
case catch jsx:decode(Tail, [stream, return_tail, return_maps]) of
    {incomplete, F} ->
        {incomplete, F};
    {with_tail, Term, Tail2} ->
        handle_input_init(Term, Tail2);
    _ ->
        {stop, malformed_data}
end.

handle_tail_init(Tail, logged_in) -> % because it was logged in already, any further requests should be ignored
case catch jsx:decode(Tail, [stream, return_tail, return_maps]) of
    {incomplete, F} ->
        {incomplete, F, logged_in};
    {with_tail, _Term, Tail2} ->
        io:format("send user an invalid requst error~n"),
        handle_tail_init(Tail2, logged_in);
    _ ->
        {stop, malformed_data}
end.

handle_term_init(Term) ->
case Term of
    #{<<"Login">> := [UserName,Password]} ->
        login_user(UserName,Password);
    #{<<"Register">> := [UserName,Password]} ->
        register_user(UserName,Password);
    _ ->
        {error, invalidreq}
end.

%gen\u服务器模块
handle_调用（{handle_init，_Socket，Data}，_From，State=#server_State{Data_fun={complete，fun}）->
案例（数据）
{不完整，F}->
NewState=State#server_State{data_fun={completed，F}}，
{回复，{确定，继续}，新闻状态}；
{with_tail，Term，tail}->
%仅处理术语登录/注册
大小写句柄\输入\初始化（术语，尾部）
{不完整，Fn，已登录}->
NewState=State#server_State{data_fun={不完整，Fn}，
{回复，{确定，登录}，新闻状态}；
{不完整，Fn}->
NewState=State#server_State{data_fun={不完整，Fn}，
{回复，{确定，继续}，新闻状态}；
{停止，格式错误的_数据}->
{回复，{停止，格式错误的_数据}，状态}
结束；
_ ->
{回复，{停止，格式错误的_数据}，状态}
结束；
handle_call（_Message，_From，State=#server_State{}）->
{reply，{stop，unknown_call}，State}。
handle\u input\u init（术语，尾部）->
案例句柄\u术语\u初始（术语）
{好的，登录已通过}->
io：格式（“向用户发送登录密码”），
handle_tail_init（tail，已登录）；
{错误，登录失败}->
io:格式（“向用户发送登录失败错误~n”），
手柄_tail_init（tail）；
{好的，注册通过了}->
io:format（“向用户发送注册信息”），
手柄_tail_init（tail）；
{错误，注册失败}->
io:格式（“向用户发送注册失败错误”），
手柄_tail_init（tail）；
{错误，invalidreq}->
io:格式（“向用户发送无效的请求错误~n”），
句柄\u tail\u init（tail）
结束。
句柄\u tail\u init（tail）->
case-catch jsx:decode（Tail、[stream、return\u Tail、return\u maps]）
{不完整，F}->
{不完全，F}；
{with_tail，Term，Tail2}->
handle_input_init（术语，Tail2）；
_ ->
{停止，格式错误的_数据}
结束。
handle\u tail\u init（tail，logged\u in）->%因为它已经登录，所以应该忽略任何进一步的请求
case-catch jsx:decode（Tail、[stream、return\u Tail、return\u maps]）
{不完整，F}->
{不完整，F，已登录}；
{带_tail，_Term，Tail2}->
io:格式（“向用户发送无效的请求错误~n”），
handle_tail_init（Tail2，已登录）；
_ ->
{停止，格式错误的_数据}
结束。
句柄\术语\初始（术语）->
案例术语
#{:=[用户名，密码]}->
登录用户（用户名、密码）；
#{:=[用户名，密码]}->
注册用户（用户名、密码）；
_ ->
{错误，invalidreq}
结束。

它工作正常，但这是我有史以来第一个Erlang代码，我确信它可以简化为一个递归的
handle\u调用
，保持OTP风格，这就是我选择Erlang的原因

我无法调用gen_server:call（self（），{stream，Tail}），因为状态为
需要首先更新

我真的不明白你想说什么，但如果你的意思是：

我不能递归地调用
gen\u server:call（self（），{stream，Tail}）
，也就是说，我不能在
handle:call（）
中编写递归调用
handle\u call（）
的代码

然后，您当然可以将
handle:call（）中的所有数据发送给另一个递归调用自身的函数：

handle_call(...) ->

    ...
    NewState = ....
    Result = ...
    {FinalResult, FinalState} = helper_func(Result, NewState, Tail)
    {reply, FinalResult, FinalState}

helper_func(Result, State, []) ->
    {Result, State};
helper_func(Result, State, [Piece|Tail]) ->
    ...
    NewState = ...
    NewResult = ...
    helper_func(NewResult, NewState, Tail).  %% Recursive call here

写东西时千万不要用代词——谁知道
it
和
this
指的是什么。你知道，但你是唯一的一个。您可以在状态中保存任何您想要的内容：如果需要，将其扩展为1000个元素的元组，其中一个元素是您的记录，然后您可以使用其他999个插槽来存储您想要的任何内容，包括您消失的尾巴。另外，我认为你的问题与流没有任何关系，因此创建一个简单的示例来演示你的问题，而不使用流，例如，
handle\u调用（{go，Data}，{u From，Func）->case Func（Data）of{X，Y}
它不是我的尾部xD，是的，我知道我可以，但这并不能解决问题，我可以使用数千个元组或编写多个函数来解决它，但它会产生更多的问题，例如，如果尾部包含一个完整的数据段，或者尾部本身是一个完整的数据段，该怎么办？除了编写复杂的代码外，我还必须到处处理已完成的部分。调用方需要知道每次调用的结果以决定是否继续，我尝试了handle_continue，它可以帮助我使用更新状态递归调用handle_调用，但它也会在应答中更新状态，还有reply（From，reply）但打电话的人只有在我没有错的情况下才会处理一个回复。这里的问题不是如何让它工作，而是如何让它按应有的方式工作（otp风格）。如果什么都不起作用，我将限制读取缓冲区，以确保tail不包含已完成的部分，只需使用handle_continue（tail，tail）即可。调用者需要知道每次调用的结果，以决定是否继续，这是您所写的唯一明确说明您正在尝试执行的操作的内容。这里的问题不是如何让它工作，问题是如何使它工作