Feat/process now max age

src/core/resolver/hb_opts.erl

@@ -484,6 +484,8 @@ raw_default_message() ->
         % default_index => #{ <<"device">> => <<"hyperbuddy@1.0">> },
         % Should we use the latest cached state of a process when computing?
         <<"process-now-from-cache">> => false,
+        % Maximum age, in seconds, for `/now' to serve from the process cache.
+        <<"process-now-max-age">> => infinity,
         % Should we trust the GraphQL API when converting to ANS-104? Some GQL
         % services do not provide the `anchor' or `last_tx' fields, so their
         % responses are not verifiable.

src/preloaded/arweave/dev_arweave.erl

@@ -885,31 +885,7 @@ request(Method, Path, Extra, LogExtra, Opts) ->
                 <<"cache-control">> => [<<"no-cache">>, <<"no-store">>]
             }
         ),
-    to_message(Path, Method, best_response(Res), LogExtra, Opts).
-
-%% @doc Select the best response from a list of responses by sorting them
-%% ascending by HTTP status code. Returns the first (best) response tuple.
-best_response({error, {no_viable_responses, Responses}}) ->
-    best_response(Responses);
-best_response([]) ->
-    {error, no_viable_responses};
-best_response(Responses) when is_list(Responses) ->
-    Sorted = lists:sort(
-        fun({_, ResponseA}, {_, ResponseB}) ->
-            StatusA = response_status(ResponseA),
-            StatusB = response_status(ResponseB),
-            StatusA =< StatusB
-        end,
-        Responses
-    ),
-    hd(Sorted);
-best_response(Response) ->
-    Response.
-
-response_status(Response) when is_map(Response) ->
-    maps:get(<<"status">>, Response, 999);
-response_status(_Response) ->
-    999.
+    to_message(Path, Method, lib_arweave_common:best_response(Res), LogExtra, Opts).
 
 %% @doc Transform a response from the Arweave node into an AO-Core message.
 to_message(Path, Method, {error, #{ <<"status">> := 404 }}, LogExtra, _Opts) ->
@@ -1206,7 +1182,7 @@ best_response_handles_failed_connect_entries_test_parallel() ->
     ],
     ?assertEqual(
         {ok, #{ <<"status">> => 200, <<"body">> => <<"OK-2">> }},
-        best_response(Responses)
+        lib_arweave_common:best_response(Responses)
     ).
 
 best_response_non_map_error_round_trips_test_parallel() ->

src/preloaded/arweave/dev_manifest.erl

@@ -102,10 +102,7 @@ request(Base, Req, Opts) ->
         %    message replaced with the casted manifest.
         case {Rest, maybe_cast_manifest(Loaded, Opts)} of
             {_, ignored} ->
-                ?event(
-                    debug_manifest,
-                    {non_manifest_returning_loaded, {loaded, Loaded}, {rest, Rest}}),
-                {ok, Req#{ <<"body">> => [Loaded|Rest] }};
+                maybe_cast_resolved_path(Loaded, Rest, Req, Opts);
             {[], {ok, Casted}} ->
                 ?event(debug_manifest, {manifest_returning_index, {req, Req}}),
                 {ok, Req#{ <<"body">> => [Casted, #{<<"path">> => <<"index">>}] }};
@@ -129,6 +126,36 @@ request(Base, Req, Opts) ->
             {ok, Req}
     end.
 
+maybe_cast_resolved_path(Loaded, [Next | Rest], Req, Opts) ->
+    case catch hb_ao:resolve(Loaded, Next, Opts) of
+        {ok, Resolved} ->
+            case catch load(Resolved, Opts) of
+                {ok, NextLoaded} ->
+                    case maybe_cast_manifest(NextLoaded, Opts) of
+                        {ok, Casted} -> manifest_path(Casted, Rest, Req);
+                        ignored -> non_manifest_path(Loaded, [Next | Rest], Req)
+                    end;
+                _ -> non_manifest_path(Loaded, [Next | Rest], Req)
+            end;
+        _ -> non_manifest_path(Loaded, [Next | Rest], Req)
+    end;
+maybe_cast_resolved_path(Loaded, [], Req, _Opts) ->
+    non_manifest_path(Loaded, [], Req).
+
+manifest_path(Casted, [], Req) ->
+    ?event(debug_manifest, {manifest_returning_index, {req, Req}}),
+    {ok, Req#{ <<"body">> => [Casted, #{<<"path">> => <<"index">>}] }};
+manifest_path(Casted, Rest, Req) ->
+    ?event(debug_manifest, {manifest_returning_subpath, {req, Req}}),
+    {ok, Req#{ <<"body">> => [Casted | Rest] }}.
+
+non_manifest_path(Loaded, Rest, Req) ->
+    ?event(
+        debug_manifest,
+        {non_manifest_returning_loaded, {loaded, Loaded}, {rest, Rest}}
+    ),
+    {ok, Req#{ <<"body">> => [Loaded | Rest] }}.
+
 %% @doc Cast a message to `manifest@1.0` if it has the correct content-type but
 %% no other device is specified.
 load(Msg, _Opts) when is_map(Msg) -> {ok, Msg};

src/preloaded/codec/lib_arweave_common.erl

@@ -6,6 +6,7 @@
 -export([bundle_hint/4, data/3, tags/5, excluded_tags/3]).
 -export([to/3, to/6, siginfo/4, fields_to_tx/4]).
 -export([bundle_header/2, bundle_header/3]).
+-export([best_response/1]).
 -include("include/hb.hrl").
 
 -define(ANS104_BASE_FIELDS, [<<"anchor">>, <<"target">>]).
@@ -770,3 +771,29 @@ read_bundle_header(BundleStartOffset, HeaderSize, FirstChunk, Opts) ->
         Error ->
             Error
     end.
+
+%% @doc Select the best response from a (potentially multi-node) request result
+%% by sorting the responses ascending by HTTP status code and returning the
+%% first (best) one. Shared by the Arweave devices, which broadcast requests to
+%% several nodes and take the most successful reply.
+best_response({error, {no_viable_responses, Responses}}) ->
+    best_response(Responses);
+best_response([]) ->
+    {error, no_viable_responses};
+best_response(Responses) when is_list(Responses) ->
+    Sorted = lists:sort(
+        fun({_, ResponseA}, {_, ResponseB}) ->
+            StatusA = response_status(ResponseA),
+            StatusB = response_status(ResponseB),
+            StatusA =< StatusB
+        end,
+        Responses
+    ),
+    hd(Sorted);
+best_response(Response) ->
+    Response.
+
+response_status(Response) when is_map(Response) ->
+    maps:get(<<"status">>, Response, 999);
+response_status(_Response) ->
+    999.

src/preloaded/name/dev_name.erl

@@ -83,21 +83,24 @@ request(HookMsg, HookReq, Opts) ->
     maybe
         {ok, Req} ?= hb_maps:find(<<"request">>, HookReq, Opts),
         {ok, Host} ?= hb_maps:find(<<"host">>, Req, Opts),
-        {ok, Name} ?=
+        {ok, RawName} ?=
             name_from_host(
                 Host,
                 hb_opts:get(node_host, hb_opts:get(host, no_host, Opts), Opts)
             ),
+        {Name, NamePath} = name_path(RawName),
         {ok, ResolvedMsg} ?= resolve(Name, HookMsg, HookReq, Opts),
         ModReq =
-            maybe_append_named_message(
+            append_name_path(
                 ResolvedMsg,
+                NamePath,
                 hb_util:ok(hb_maps:find(<<"body">>, HookReq, Opts)),
                 Opts
             ),
         ?event(
             {request_with_prepended_path,
                 {name, Name},
+                {name_path, NamePath},
                 {full_host, Host},
                 {resolved_msg, ResolvedMsg},
                 {to_execute, ModReq}
@@ -121,6 +124,19 @@ request(HookMsg, HookReq, Opts) ->
             end
     end.
 
+%% @doc Split an underscore-encoded subdomain into root name and path parts.
+%% `x_y_z' resolves `z', then `y', then `x'.
+name_path(Name) ->
+    case lists:reverse(binary:split(Name, <<"_">>, [global, trim_all])) of
+        [Root | Path] -> {Root, Path};
+        [] -> {Name, []}
+    end.
+
+%% @doc Append the resolved name as the base, then any path encoded in the host.
+append_name_path(ResolvedMsg, NamePath, OldReq, Opts) ->
+    [Base | Rest] = maybe_append_named_message(ResolvedMsg, OldReq, Opts),
+    [Base | ([#{ <<"path">> => Part } || Part <- NamePath] ++ Rest)].
+
 %% @doc After finding a hit for a named message, we should ensure that it is the
 %% base message for the evaluation. If it is already present in the request,
 %% however, we should not add it twice. Instead, we must add the version that
@@ -209,6 +225,19 @@ device_resolver(Msg) ->
         }
     }.
 
+host_test_opts() ->
+    #{
+        <<"port">> => 0,
+        <<"name-resolvers">> =>
+            [
+                device_resolver(
+                    #{ <<"permabytes">> => #{ <<"content-type">> => <<"text/html">> } }
+                )
+            ],
+        <<"on">> =>
+            #{ <<"request">> => #{ <<"device">> => <<"name@1.0">> } }
+    }.
+
 single_resolver_test_parallel() ->
     ?assertEqual(
         {ok, <<"world">>},
@@ -303,39 +332,82 @@ arns_json_snapshot_test_parallel() ->
         )
     ).
 
-arns_host_resolution_test_parallel() ->
-    Opts = hb_name_test_utils:arns_opts(),
+host_resolution_test_parallel() ->
+    Opts = host_test_opts(),
     Node = hb_http_server:start_node(Opts),
     ?assertMatch(
         {ok, <<"text/html">>},
         hb_http:get(
             Node,
             #{
                 <<"path">> => <<"content-type">>,
-                <<"host">> => <<"001_permabytes.localhost">>
+                <<"host">> => <<"permabytes.localhost">>
             },
             Opts
         )
     ).
 
-arns_host_resolution_with_node_host_test_parallel() ->
-    Opts = (hb_name_test_utils:arns_opts())#{
-        <<"node-host">> => <<"http://localhost">>,
-        <<"port">> => 0
-    },
+host_resolution_with_node_host_test_parallel() ->
+    Opts = (host_test_opts())#{ <<"node-host">> => <<"http://localhost">> },
     Node = hb_http_server:start_node(Opts),
     ?assertMatch(
         {ok, <<"text/html">>},
         hb_http:get(
             Node,
             #{
                 <<"path">> => <<"content-type">>,
-                <<"host">> => <<"001_permabytes.localhost">>
+                <<"host">> => <<"permabytes.localhost">>
             },
             Opts
         )
     ).
 
+underscore_host_parts_resolve_manifest_test_parallel() ->
+    Opts = hb_name_test_utils:manifest_opts(),
+    ManifestID = <<"42jky7O3rzKkMOfHBXgK-304YjulzEYqHc9qyjT3efA">>,
+    {ok, IndexPageID} =
+        hb_cache:write(
+            #{
+                <<"content-type">> => <<"text/html">>,
+                <<"body">> => <<"Index page.">>
+            }
+        ),
+    Subrealm =
+        #{
+            <<"sub2">> => ManifestID
+            <<"index">> => IndexPageID
+        }
+    Opts =
+        (hb_name_test_utils:manifest_opts())#{
+            <<"port">> => 0,
+            <<"http-client-hackney-recv-timeout">> => 30_000,
+            <<"name-resolvers">> =>
+                [
+                    device_resolver(
+                        #{
+                            <<"sub2_sub1">> => <<"not-the-manifest">>,
+                            <<"sub1">> => IndexPageID
+                        }
+                    )
+                ],
+            <<"on">> =>
+                #{
+                    <<"request">> =>
+                        [
+                            #{<<"device">> => <<"name@1.0">>},
+                            #{<<"device">> => <<"manifest@1.0">>}
+                        ]
+                }
+        },
+    Node = hb_http_server:start_node(Opts),
+    hb_test_utils:assert_manifest_response(
+        Node,
+        #{ <<"path">> => <<"/">>, <<"host">> => <<"sub2_sub1.localhost">> },
+        <<"text/html">>,
+        <<"<title>Portal</title>">>,
+        Opts
+    ).
+
 root_request_skips_name_resolution_test_parallel() ->
     BaseOpts =
         #{
@@ -371,4 +443,9 @@ name_from_host_test_parallel() ->
     ?assertEqual(
         {ok, <<"sub3.sub2">>},
         name_from_host(<<"sub3.sub2.sub1.abc.xyz">>, <<"sub1.abc.xyz">>)
+    ),
+    ?assertEqual({<<"sub1">>, [<<"sub2">>]}, name_path(<<"sub2_sub1">>)),
+    ?assertEqual(
+        {<<"sub1">>, [<<"sub2">>, <<"sub3">>]},
+        name_path(<<"sub3_sub2_sub1">>)
     ).