Add insert_new_or_lookup/2 function

[arcusfelis]

insert_new/2 is useful, but there could be a case, when we want to insert new or read existing record.
And there could be a race condition between these two events (i.e. this race condition is even in the default ets module).
Which means the code would have to implement this:

-spec init_ram_key(ProposedKey) -> Result when
      ProposedKey :: mod_keystore:key(),
      Result :: {ok, ActualKey} | {error, init_ram_key_failed},
      ActualKey :: mod_keystore:key().
init_ram_key(ProposedKey) ->
    init_ram_key(ProposedKey, 1, 3).

%% Inserts new key or returns already inserted.
-spec init_ram_key(Key, TriedTimes, Retries) -> Result when
      Result :: {ok, Key} | {error, init_ram_key_failed},
      Key :: mod_keystore:key(),
      TriedTimes :: non_neg_integer(),
      Retries :: non_neg_integer().
init_ram_key(#key{id = Id, key = Key}, _, 0) ->
    ?LOG_ERROR(#{what => init_ram_key_failed, id => Id, key => Key}),
    {error, init_ram_key_failed};
init_ram_key(ProposedKey = #key{id = Id = {_, HostType}, key = PropKey}, N, Retries) ->
    Tab = table_name(HostType),
    case cets:insert_new(Tab, {Id, PropKey}) of
        true ->
            {ok, ProposedKey};
        false ->
            case ets:lookup(Tab, Id) of
                [{Id, Key}] ->
                    %% Return already inserted key
                    {ok, #key{id = Id, key = Key}};
                [] ->
                    ?LOG_WARNING(#{what => init_ram_key_retry,
                                   id => Id, key => PropKey, tried_times => N}),
                    init_ram_key(ProposedKey, N + 1, Retries - 1)
            end
   end.

Retry mechanism. Would also require tests, would also need to decide when to stop to retry... Sounds too much work.

This new function allows to rewrite the above code as:

-spec init_ram_key(ProposedKey) -> Result when
     ProposedKey :: mod_keystore:key(),
     Result :: {ok, ActualKey} | {error, init_ram_key_failed},
     ActualKey :: mod_keystore:key().
init_ram_key(ProposedKey = #key{id = Id = {_, HostType}, key = PropKey}) ->
   Tab = table_name(HostType),
   case cets:insert_new_or_lookup(Tab, {Id, PropKey}) of
       {true, _} ->
           {ok, ProposedKey};
       {false, [{Id, Key}]} ->
           {ok, #key{id = Id, key = Key}}
  end.

It is in case you want to write a testcase for the false condition. If you don't want to have any special logic in case of conflict (and no separation in the cover reports):

-spec init_ram_key(ProposedKey) -> Result when
    ProposedKey :: mod_keystore:key(),
    Result :: {ok, ActualKey} | {error, init_ram_key_failed},
    ActualKey :: mod_keystore:key().
init_ram_key(ProposedKey = #key{id = Id = {_, HostType}, key = PropKey}) ->
  Tab = table_name(HostType),
  {_, [{Id, Key}]} = cets:insert_new_or_lookup(Tab, {Id, PropKey}),
  {ok, #key{id = Id, key = Key}}.

[codecov]

Codecov Report

All modified lines are covered by tests ✅

Comparison is base (e3ad43f) 97.38% compared to head (72b01d2) 97.42%.

Additional details and impacted files

@@            Coverage Diff             @@
##             main      #36      +/-   ##
==========================================
+ Coverage   97.38%   97.42%   +0.03%     
==========================================
  Files           9        9              
  Lines         613      622       +9     
==========================================
+ Hits          597      606       +9     
  Misses         16       16              

Files	Coverage Δ
src/cets.erl	100.00% <100.00%> (ø)

☔ View full report in Codecov by Sentry.
📢 Have feedback on the report? Share it here.

[chrzaszcz]

👌