Fix for blockchain_sync

cleverfox · cleverfox · commit 8bb4151cec7d · 2023-02-14T17:39:44.000+03:00
diff --git a/apps/tpnode/src/blockchain_reader.erl b/apps/tpnode/src/blockchain_reader.erl
@@ -341,6 +341,22 @@ handle_cast({tpic, From, #{
                                       })),
   {noreply, State};
 
+handle_cast({update,#{temporary:=_,header:=#{height:=H1, parent:=Par}=Hdr,hash:=Hash1}=NewTmp},
+            #{lastblock:=#{header:=#{height:=H0}, hash:=Hash0 }}=State) ->
+  if(H1==H0+1 andalso Par==Hash0) ->
+      {noreply, State#{tmpblock=>NewTmp}};
+    true ->
+      ?LOG_NOTICE("Incompatible tmp block ~s arrived to RDR: ~p", [blkid(Hash1),Hdr]),
+      if(H1=/=H0+1) ->
+          ?LOG_NOTICE("Height mismatch ~p =/= ~p",[H1,H0+1]);
+        (Par=/=Hash1) ->
+          ?LOG_NOTICE("Parent hash mismatch ~p =/= ~p",[Hash0,Hash1]);
+        true ->
+          ?LOG_NOTICE("Can't understand what is wrong",[])
+      end,
+      {noreply, get_last(State)}
+  end;
+
 handle_cast(update, State) ->
   {noreply, get_last(State)};
 
diff --git a/apps/tpnode/src/blockchain_sync.erl b/apps/tpnode/src/blockchain_sync.erl
@@ -76,9 +76,44 @@ chainstate() ->
 init(_Args) ->
   {ok, LDB}=ldb:open(utils:dbpath(db)),
   {ok, get_last(#{
-         ldb=>LDB
+         ldb=>LDB,
+         last_res=>undefined
         })}.
 
+handle_call(last_res, _From, State) ->
+  {reply, maps:get(last_res,State,not_found), State};
+
+handle_call({runsync_h,N}, _From, State) ->
+  #{header:=#{height:=MyHeight}, hash:=MyLastHash}=blockchain:last_meta(),
+  stout:log(runsync, [ {node, nodekey:node_name()}, {where, got_info} ]),
+  ?LOG_DEBUG("got runsync, myHeight: ~p, myLastHash: ~p", [MyHeight, blkid(MyLastHash)]),
+  {H,T} = case N of
+            any -> {any, any};
+            I when is_integer(I) ->
+              {I, any};
+            {I, J} when is_integer(I), is_integer(J) ->
+              {I, J}
+          end,
+
+  ?LOG_DEBUG("use default list of candidates"),
+  Candidates = sort_rnd(
+                 lists:filter(
+                   fun(_) when H==any, T==any -> true;
+                      ({_, #{last_height:=CH}}) when CH==H, T==any -> true;
+                      ({_, #{last_height:=CH,last_temp:=CT}}) when CH==H, CT==T -> true;
+                      (_) -> false
+                   end,
+                   tpiccall(
+                     <<"blockchain">>,
+                     #{null=><<"sync_request">>},
+                     [last_hash, last_height, chain, last_temp]
+                    )
+                  )
+                ),
+  self() ! {runsync, Candidates},
+  {reply, {ok, Candidates}, State};
+
+
 handle_call({runsync, NewChain}, _From, State) ->
   stout:log(runsync, [ {node, nodekey:node_name()}, {where, call} ]),
   self() ! runsync,
@@ -180,31 +215,35 @@ handle_info({bbyb_sync, Hash},
   ?LOG_DEBUG("run bbyb sync res ~p",[BBRes]),
   case BBRes of
     sync_cont ->
-      {noreply, State};
+      {noreply, State#{last_res => {erlang:system_time(),sync_cont}}};
     done ->
       synchronizer ! imready,
       {noreply,
-       maps:without([sync, syncblock, sync_peer, sync_candidates, bbsync_pid], State)
+       maps:without([sync, syncblock, sync_peer, sync_candidates, bbsync_pid],
+                    State#{last_res => {erlang:system_time(),done}})
       };
     {broken_block, C1} ->
       {noreply,
        maps:without([sync, syncblock, sync_peer, sync_candidates, bbsync_pid],
                     State#{
-                      sync_candidates => C1
+                      sync_candidates => C1,
+                      last_res => {erlang:system_time(),broken_block}
                      })
       };
     {broken_sync, C1} ->
       {noreply,
        maps:without([sync, syncblock, sync_peer, sync_candidates, bbsync_pid],
                     State#{
-                      sync_candidates => C1
+                      sync_candidates => C1,
+                      last_res => {erlang:system_time(), broken_sync}
                      })
       };
     {noresponse, C1} ->
       {noreply,
        maps:without([sync, syncblock, sync_peer, sync_candidates, bbsync_pid],
                     State#{
-                      sync_candidates => C1
+                      sync_candidates => C1,
+                      last_res => {erlang:system_time(),noresponse}
                      })
       }
   end;
diff --git a/apps/tpnode/src/blockchain_updater.erl b/apps/tpnode/src/blockchain_updater.erl
@@ -349,8 +349,9 @@ handle_call({new_block, #{hash:=BlockHash,
                                        })
                               })
                             }),
-                  gen_server:cast(blockchain_reader,update),
+                  gen_server:cast(blockchain_reader,{update,MBlk}),
                   gen_server:cast(tpnode_ws_dispatcher, {new_block, MBlk}),
+
                   {reply, ok, State#{
                                 tmpblock=>MBlk
                                }};
@@ -657,7 +658,7 @@ handle_cast({signature, BlockHash, _Sigs}, State) ->
              [blkid(BlockHash) ]),
   T=maps:get(unksig,State,0),
   if(T>=2) ->
-      self() ! checksync,
+      blockchain_sync ! checksync,
       {noreply, State};
     true ->
       {noreply, State#{unksig=>T+1}}
@@ -728,6 +729,43 @@ handle_info({continue_cleanup,N}, #{ldb:=LDB,clean_iterator:=Iterator}=State) ->
       {noreply, maps:without([clean_iterator], State)}
   end;
 
+handle_info(check_mgmt, #{settings:=Sets}=State) ->
+  InChain=try
+            settings:get(
+            [<<"current">>,<<"management">>,<<"uri">>],
+            Sets,
+            undefined
+           )
+          catch Ec:Ee:S ->
+                  ?LOG_ERROR("~p:~p @ ~p...",[Ec,Ee,hd(S)]),
+                  undefined
+          end,
+  if InChain == undefined ->
+       {noreply, State};
+     is_binary(InChain) ->
+       InChain1=binary_to_list(InChain),
+       MgmtCfg=utils:read_cfg(mgmt_cfg,undefined),
+       InCfg=case MgmtCfg of
+               Cfg when is_list(Cfg) ->
+                 proplists:get_value(management,Cfg,undefined);
+               _ ->
+                 undefined
+             end,
+       if InChain1 == InCfg ->
+            {noreply, State};
+          is_list(MgmtCfg) -> % OVERRIDE MANAGEMENT URL IN CONFIG
+            ?LOG_INFO("Check mgmt ~p ~p",[InCfg,InChain]),
+            utils:update_cfg(mgmt_cfg,[{management,InChain1},{http,[]},{https,[]}]),
+            {noreply, State};
+          true -> % no config
+            ?LOG_INFO("Check mgmt ~p ~p",[InCfg,InChain]),
+            utils:update_cfg(mgmt_cfg,[{management,InChain1}]),
+            {noreply, State}
+       end;
+     true ->
+       {noreply, State}
+  end;
+
 handle_info(_Info, State) ->
   ?LOG_NOTICE("BC unhandled info ~p", [_Info]),
   {noreply, State}.
diff --git a/apps/tpnode/src/tpnode_httpapi.erl b/apps/tpnode/src/tpnode_httpapi.erl
@@ -119,12 +119,12 @@ h(Method, [<<"playground">>|Path], Req) ->
 h(Method, [<<"api">>|Path], Req) ->
   h(Method, Path, Req);
 
-h(<<"GET">>, [<<"node">>, <<"status">>], _Req) ->
+h(<<"GET">>, [<<"node">>, <<"status">>], Req) ->
   Chain=chainsettings:get_val(mychain),
   #{hash:=Hash,
     header:=Header1}=Blk=blockchain:last_meta(),
   Temp=maps:get(temporary,Blk,false),
-  BinPacker=packer(_Req),
+  BinPacker=packer(Req),
   Header=maps:map(
            fun(roots, V) ->
                [ if is_binary(RV) ->
@@ -173,6 +173,41 @@ h(<<"GET">>, [<<"node">>, <<"status">>], _Req) ->
                    []
            end,
   {Ver, _BuildTime}=tpnode:ver(),
+  BRLB = begin
+           QS=cowboy_req:parse_qs(Req),
+           case proplists:get_value(<<"brlb">>, QS) of
+             undefined -> undefined;
+             _ ->
+               try
+                 #{hash:=BVHas,
+                   header:=#{chain := BVCh,
+                             height := BVHei,
+                             parent := BVPar,
+                             roots := BVRoots}
+                  }=BVB=gen_server:call(blockchain_reader,last_block),
+                 maps:merge(
+                   #{hash=>BinPacker(BVHas),
+                     header=>#{
+                               chain=>BVCh,
+                               height=>BVHei,
+                               parent=>BinPacker(BVPar),
+                               roots=>[ if is_binary(RV) ->
+                                             [N, BinPacker(RV)];
+                                           true ->
+                                             [N, RV]
+                                        end || {N,RV} <- BVRoots ]
+                              }
+                    },
+                   maps:with([temporary],BVB)
+                  )
+               catch Ec1:Ee1:S1 ->
+                       ?LOG_ERROR("blockchain_reader last_block error: ~p:~p~n~p",
+                                  [Ec1, Ee1, hd(S1)]),
+                       #{ error => true }
+               end
+           end
+         end,
+
   answer(
     #{ result => <<"ok">>,
       status => #{
@@ -193,6 +228,7 @@ h(<<"GET">>, [<<"node">>, <<"status">>], _Req) ->
                        gen_server:call(blockvote, status)
                      catch _:_ -> #{ error => true }
                      end,
+        blockchain_reader_lastblock => BRLB,
         xchain_inbound => try
                             gen_server:call(xchain_dispatcher, peers)
                           catch _:_ -> #{ error => true }
@@ -226,8 +262,15 @@ h(<<"GET">>, [<<"node">>, <<"chainstate">>], _Req) ->
      });
 
 h(<<"POST">>, [<<"node">>, <<"runsync">>], _Req) ->
-  blockchain_sync ! runsync,
-  answer(#{ result => <<"ok">> });
+  R=list_to_binary(
+      [ io_lib:format("~p~n",
+                     [ gen_server:call(blockchain_sync, {runsync_h, any}) ]
+                    ) ]
+     ),
+  answer(#{
+           result => <<"ok">>,
+           candidates => R
+          });
 
 h(<<"POST">>, [<<"node">>, <<"new_peer">>], Req) ->
   {RemoteIP, _Port}=cowboy_req:peer(Req),
@@ -936,6 +979,58 @@ h(<<"GET">>, [<<"settings">>|Path], Req) ->
     #{jsx=>[ strict, {error_handler, EHF} ]}
    );
 
+
+h(<<"POST">>, [<<"debug">>, <<"runsync">>|N], _Req) ->
+  Q = case N of
+        [NN] ->
+          {runsync_h, binary_to_integer(NN)};
+        [NN,TT] ->
+          {runsync_h, {binary_to_integer(NN),binary_to_integer(TT)}};
+        [] ->
+          {runsync_h, any}
+      end,
+  try
+    R=case gen_server:call(blockchain_sync, Q) of
+        {ok, RR} when is_list(RR)->
+          lists:foldl(
+            fun({{PubKey,Service, _}, Map},A) ->
+                Node=case chainsettings:is_net_node(PubKey) of
+                     {ok, NNN} -> NNN;
+                     _ -> PubKey
+                   end,
+                [ [ [Node, Service], Map ] | A ];
+               ({Key,Map},A) ->
+                [[list_to_binary( [ io_lib:format("~p", [ [Key] ]) ]),
+                  list_to_binary( [ io_lib:format("~p", [ [Map] ]) ]) ]|A];
+               (Other,A) ->
+                [list_to_binary( [ io_lib:format("( (~p) )", [ [Other] ]) ])|A]
+            end, [], RR);
+        {ok, RR} ->
+          list_to_binary( [ io_lib:format("d:~p", [ RR ]) ]);
+        Other ->
+          list_to_binary( [ io_lib:format("o:~p", [ Other ]) ])
+      end,
+    answer(#{
+             result => <<"ok">>,
+             res => R
+            })
+  catch Ec:Ee:S ->
+          err(
+            10008,
+            iolist_to_binary(io_lib:format("Error: ~p:~p at ~p", [Ec,Ee,S])),
+            #{},
+            #{http_code=>500}
+           )
+  end;
+
+h(<<"POST">>, [<<"debug">>, <<"last_sync_res">>], _Req) ->
+  R0=gen_server:call(blockchain_sync, last_res),
+  R=list_to_binary( [ io_lib:format("~p", [ R0 ]) ]),
+  answer(#{
+           result => <<"ok">>,
+           res => R
+          });
+
 h(<<"POST">>, [<<"debug">>,<<"bcupdater_reloadset">>], Req) ->
   BinPacker=packer(Req),
   EHF=fun([{Type, Str}|Tokens],{parser, State, Handler, Stack}, Conf) ->
