Router: refactored variable pass.

Since the "pass" option supports both strings and variables, a generic
nxt_var_t structure can be used in the configuration phase, and the "name"
field in actions is redundant.

No functional changes.

src/nxt_http.h

@@ -226,9 +226,9 @@ struct nxt_http_action_s {
         nxt_upstream_t              *upstream;
         uint32_t                    upstream_number;
         nxt_var_t                   *var;
+        nxt_str_t                   *pass;
     } u;
 
-    nxt_str_t                       name;
     nxt_http_action_t               *fallback;
 };
 
@@ -313,7 +313,7 @@ nxt_int_t nxt_http_request_content_length(void *ctx, nxt_http_field_t *field,
 nxt_http_routes_t *nxt_http_routes_create(nxt_task_t *task,
     nxt_router_temp_conf_t *tmcf, nxt_conf_value_t *routes_conf);
 nxt_http_action_t *nxt_http_action_create(nxt_task_t *task,
-    nxt_router_temp_conf_t *tmcf, nxt_str_t *name);
+    nxt_router_temp_conf_t *tmcf, nxt_str_t *pass);
 nxt_int_t nxt_http_routes_resolve(nxt_task_t *task,
     nxt_router_temp_conf_t *tmcf);
 nxt_int_t nxt_http_pass_segments(nxt_mp_t *mp, nxt_str_t *pass,

src/nxt_http_request.c

@@ -460,8 +460,6 @@ nxt_http_request_action(nxt_task_t *task, nxt_http_request_t *r,
     if (nxt_fast_path(action != NULL)) {
 
         do {
-            nxt_debug(task, "http request route: %V", &action->name);
-
             action = action->handler(task, r, action);
 
             if (action == NULL) {

src/nxt_http_route.c

@@ -216,14 +216,12 @@ static nxt_int_t nxt_http_route_resolve(nxt_task_t *task,
     nxt_router_temp_conf_t *tmcf, nxt_http_route_t *route);
 static nxt_int_t nxt_http_action_resolve(nxt_task_t *task,
     nxt_router_temp_conf_t *tmcf, nxt_http_action_t *action);
-static nxt_http_action_t *nxt_http_action_pass_var(nxt_task_t *task,
+static nxt_http_action_t *nxt_http_pass_var(nxt_task_t *task,
     nxt_http_request_t *r, nxt_http_action_t *action);
-static void nxt_http_action_pass_var_ready(nxt_task_t *task, void *obj,
+static void nxt_http_pass_var_ready(nxt_task_t *task, void *obj, void *data);
-    void *data);
+static void nxt_http_pass_var_error(nxt_task_t *task, void *obj, void *data);
-static void nxt_http_action_pass_var_error(nxt_task_t *task, void *obj,
+static nxt_int_t nxt_http_pass_find(nxt_mp_t *mp, nxt_router_conf_t *rtcf,
-    void *data);
+    nxt_str_t *pass, nxt_http_action_t *action);
-static nxt_int_t nxt_http_pass_find(nxt_task_t *task, nxt_mp_t *mp,
-    nxt_router_conf_t *rtcf, nxt_http_action_t *action);
 static nxt_int_t nxt_http_route_find(nxt_http_routes_t *routes, nxt_str_t *name,
     nxt_http_action_t *action);
 
@@ -652,7 +650,7 @@ nxt_http_action_init(nxt_task_t *task, nxt_router_temp_conf_t *tmcf,
 {
     nxt_mp_t                *mp;
     nxt_int_t               ret;
-    nxt_str_t               name, *string;
+    nxt_str_t               pass;
     nxt_http_action_conf_t  acf;
 
     nxt_memzero(&acf, sizeof(acf));
@@ -679,10 +677,10 @@ nxt_http_action_init(nxt_task_t *task, nxt_router_temp_conf_t *tmcf,
         return nxt_http_proxy_init(mp, action, &acf);
     }
 
-    nxt_conf_get_string(acf.pass, &name);
+    nxt_conf_get_string(acf.pass, &pass);
 
-    string = nxt_str_dup(mp, &action->name, &name);
+    action->u.var = nxt_var_compile(&pass, mp);
-    if (nxt_slow_path(string == NULL)) {
+    if (nxt_slow_path(action->u.var == NULL)) {
         return NXT_ERROR;
     }
 
@@ -1372,7 +1370,7 @@ nxt_http_action_resolve(nxt_task_t *task, nxt_router_temp_conf_t *tmcf,
     nxt_http_action_t *action)
 {
     nxt_int_t  ret;
-    nxt_var_t  *var;
+    nxt_str_t  pass;
 
     if (action->handler != NULL) {
         if (action->fallback != NULL) {
@@ -1382,20 +1380,17 @@ nxt_http_action_resolve(nxt_task_t *task, nxt_router_temp_conf_t *tmcf,
         return NXT_OK;
     }
 
-    if (nxt_is_var(&action->name)) {
+    if (nxt_var_is_const(action->u.var)) {
-        var = nxt_var_compile(&action->name, tmcf->router_conf->mem_pool);
+        nxt_var_raw(action->u.var, &pass);
-        if (nxt_slow_path(var == NULL)) {
+
+        ret = nxt_http_pass_find(tmcf->mem_pool, tmcf->router_conf, &pass,
+                                 action);
+        if (nxt_slow_path(ret != NXT_OK)) {
             return NXT_ERROR;
         }
 
-        action->u.var = var;
+    } else {
-        action->handler = nxt_http_action_pass_var;
+        action->handler = nxt_http_pass_var;
-        return NXT_OK;
-    }
-
-    ret = nxt_http_pass_find(task, tmcf->mem_pool, tmcf->router_conf, action);
-    if (nxt_slow_path(ret != NXT_OK)) {
-        return NXT_ERROR;
     }
 
     return NXT_OK;
@@ -1403,28 +1398,36 @@ nxt_http_action_resolve(nxt_task_t *task, nxt_router_temp_conf_t *tmcf,
 
 
 static nxt_http_action_t *
-nxt_http_action_pass_var(nxt_task_t *task, nxt_http_request_t *r,
+nxt_http_pass_var(nxt_task_t *task, nxt_http_request_t *r,
     nxt_http_action_t *action)
 {
-    nxt_var_t  *var;
     nxt_int_t  ret;
+    nxt_str_t  str;
+    nxt_var_t  *var;
+
+    var = action->u.var;
+
+    nxt_var_raw(var, &str);
+
+    nxt_debug(task, "http pass: \"%V\"", &str);
 
     ret = nxt_var_query_init(&r->var_query, r, r->mem_pool);
     if (nxt_slow_path(ret != NXT_OK)) {
         goto fail;
     }
 
-    var = action->u.var;
+    action = nxt_mp_get(r->mem_pool,
-
+                        sizeof(nxt_http_action_t) + sizeof(nxt_str_t));
-    action = nxt_mp_get(r->mem_pool, sizeof(nxt_http_action_t));
     if (nxt_slow_path(action == NULL)) {
         goto fail;
     }
 
-    nxt_var_query(task, r->var_query, var, &action->name);
+    action->u.pass = nxt_pointer_to(action, sizeof(nxt_http_action_t));
+
+    nxt_var_query(task, r->var_query, var, action->u.pass);
     nxt_var_query_resolve(task, r->var_query, action,
-                          nxt_http_action_pass_var_ready,
+                          nxt_http_pass_var_ready,
-                          nxt_http_action_pass_var_error);
+                          nxt_http_pass_var_error);
     return NULL;
 
 fail:
@@ -1435,7 +1438,7 @@ fail:
 
 
 static void
-nxt_http_action_pass_var_ready(nxt_task_t *task, void *obj, void *data)
+nxt_http_pass_var_ready(nxt_task_t *task, void *obj, void *data)
 {
     nxt_int_t           ret;
     nxt_router_conf_t   *rtcf;
@@ -1447,9 +1450,9 @@ nxt_http_action_pass_var_ready(nxt_task_t *task, void *obj, void *data)
     action = data;
     rtcf = r->conf->socket_conf->router_conf;
 
-    nxt_debug(task, "http pass lookup: %V", &action->name);
+    nxt_debug(task, "http pass lookup: %V", action->u.pass);
 
-    ret = nxt_http_pass_find(task, r->mem_pool, rtcf, action);
+    ret = nxt_http_pass_find(r->mem_pool, rtcf, action->u.pass, action);
 
     if (ret != NXT_OK) {
         status = (ret == NXT_DECLINED) ? NXT_HTTP_NOT_FOUND
@@ -1464,7 +1467,7 @@ nxt_http_action_pass_var_ready(nxt_task_t *task, void *obj, void *data)
 
 
 static void
-nxt_http_action_pass_var_error(nxt_task_t *task, void *obj, void *data)
+nxt_http_pass_var_error(nxt_task_t *task, void *obj, void *data)
 {
     nxt_http_request_t  *r;
 
@@ -1475,13 +1478,13 @@ nxt_http_action_pass_var_error(nxt_task_t *task, void *obj, void *data)
 
 
 static nxt_int_t
-nxt_http_pass_find(nxt_task_t *task, nxt_mp_t *mp, nxt_router_conf_t *rtcf,
+nxt_http_pass_find(nxt_mp_t *mp, nxt_router_conf_t *rtcf, nxt_str_t *pass,
     nxt_http_action_t *action)
 {
-    nxt_int_t   ret;
+    nxt_int_t  ret;
-    nxt_str_t   segments[3];
+    nxt_str_t  segments[3];
 
-    ret = nxt_http_pass_segments(mp, &action->name, segments, 3);
+    ret = nxt_http_pass_segments(mp, pass, segments, 3);
     if (nxt_slow_path(ret != NXT_OK)) {
         return ret;
     }
@@ -1587,18 +1590,24 @@ nxt_http_route_find(nxt_http_routes_t *routes, nxt_str_t *name,
 
 nxt_http_action_t *
 nxt_http_action_create(nxt_task_t *task, nxt_router_temp_conf_t *tmcf,
-    nxt_str_t *name)
+    nxt_str_t *pass)
 {
+    nxt_mp_t           *mp;
     nxt_int_t          ret;
     nxt_http_action_t  *action;
 
-    action = nxt_mp_alloc(tmcf->router_conf->mem_pool,
+    mp = tmcf->router_conf->mem_pool;
-                          sizeof(nxt_http_action_t));
+
+    action = nxt_mp_alloc(mp, sizeof(nxt_http_action_t));
     if (nxt_slow_path(action == NULL)) {
         return NULL;
     }
 
-    action->name = *name;
+    action->u.var = nxt_var_compile(pass, mp);
+    if (nxt_slow_path(action->u.var == NULL)) {
+        return NULL;
+    }
+
     action->handler = NULL;
 
     ret = nxt_http_action_resolve(task, tmcf, action);
@@ -1623,8 +1632,6 @@ nxt_http_pass_application(nxt_task_t *task, nxt_router_conf_t *rtcf,
         return NULL;
     }
 
-    action->name = *name;
-
     (void) nxt_router_application_init(rtcf, name, NULL, action);
 
     return action;

src/nxt_upstream.c

@@ -141,6 +141,11 @@ static nxt_http_action_t *
 nxt_upstream_handler(nxt_task_t *task, nxt_http_request_t *r,
     nxt_http_action_t *action)
 {
-    return nxt_upstream_proxy_handler(task, r,
+    nxt_upstream_t  *u;
-                              r->conf->upstreams[action->u.upstream_number]);
+
+    u = r->conf->upstreams[action->u.upstream_number];
+
+    nxt_debug(task, "upstream handler: \"%V\"", &u->name);
+
+    return nxt_upstream_proxy_handler(task, r, u);
 }

src/nxt_var.c

@@ -90,6 +90,21 @@ static uint32_t           nxt_var_count;
 static nxt_var_handler_t  *nxt_var_index;
 
 
+void
+nxt_var_raw(nxt_var_t *var, nxt_str_t *str)
+{
+    str->length = var->length;
+    str->start = nxt_var_raw_start(var);
+}
+
+
+nxt_bool_t
+nxt_var_is_const(nxt_var_t *var)
+{
+    return (var->vars == 0);
+}
+
+
 static nxt_int_t
 nxt_var_hash_test(nxt_lvlhsh_query_t *lhq, void *data)
 {
@@ -439,9 +454,8 @@ nxt_var_query(nxt_task_t *task, nxt_var_query_t *query, nxt_var_t *var,
     nxt_var_sub_t    *subs;
     nxt_var_value_t  *val;
 
-    if (var->vars == 0) {
+    if (nxt_var_is_const(var)) {
-        str->length = var->length;
+        nxt_var_raw(var, str);
-        str->start = nxt_var_raw_start(var);
         return;
     }
 

src/nxt_var.h

@@ -30,6 +30,9 @@ nxt_is_var(nxt_str_t *str)
 }
 
 
+void nxt_var_raw(nxt_var_t *var, nxt_str_t *str);
+nxt_bool_t nxt_var_is_const(nxt_var_t *var);
+
 nxt_int_t nxt_var_register(nxt_var_decl_t *decl, size_t n);
 nxt_int_t nxt_var_index_init(void);
 nxt_var_t *nxt_var_compile(nxt_str_t *str, nxt_mp_t *mp);