This is an automated email from the ASF dual-hosted git repository.
zwoop pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/trafficserver.git
The following commit(s) were added to refs/heads/master by this push:
new 02fc306613 Restructure the Config objects (#11478)
02fc306613 is described below
commit 02fc306613842aaf11beaa99057a192994105ef1
Author: Leif Hedstrom <[email protected]>
AuthorDate: Thu Jun 27 13:43:54 2024 -0600
Restructure the Config objects (#11478)
* Restructure the Config objects
* Adds a small cache for the static Records
* Fixes an unecessary copy
* Better error handling for bad Records
---
example/cripts/example1.cc | 1 +
include/cripts/Bundles/Common.hpp | 6 +-
include/cripts/Configs.hpp | 238 ++++++++++++++++++++------------------
include/cripts/ConfigsBase.hpp | 135 ++++++++++++++++-----
include/cripts/Context.hpp | 7 --
include/cripts/Epilogue.hpp | 2 +-
include/cripts/Headers.hpp | 5 +-
include/cripts/Instance.hpp | 2 +-
include/cripts/Lulu.hpp | 10 ++
include/cripts/Matcher.hpp | 3 +-
include/cripts/Metrics.hpp | 8 +-
src/cripts/Bundles/Common.cc | 24 ++--
src/cripts/Bundles/HRWBridge.cc | 16 +--
src/cripts/Bundles/Headers.cc | 4 +-
src/cripts/Configs.cc | 128 +++++++++++---------
src/cripts/Connections.cc | 2 +-
src/cripts/Crypto.cc | 4 +-
src/cripts/Headers.cc | 22 ++--
src/cripts/Matcher.cc | 8 +-
src/cripts/Urls.cc | 20 ++--
tools/cripts/genconfig.py | 12 +-
21 files changed, 386 insertions(+), 271 deletions(-)
diff --git a/example/cripts/example1.cc b/example/cripts/example1.cc
index 971a10b599..a8a5c82539 100644
--- a/example/cripts/example1.cc
+++ b/example/cripts/example1.cc
@@ -150,6 +150,7 @@ do_remap()
CDebug("Int config cache.http = {}", proxy.config.http.cache.http.get());
CDebug("Float config cache.heuristic_lm_factor = {}",
proxy.config.http.cache.heuristic_lm_factor.get());
+ CDebug("String config http.response_server_str = {}",
proxy.config.http.response_server_str.getSV(context));
CDebug("X-Miles = {}", req["X-Miles"]);
CDebug("random(1000) = {}", Cript::random(1000));
diff --git a/include/cripts/Bundles/Common.hpp
b/include/cripts/Bundles/Common.hpp
index fdbd1f79eb..b5ee8674d6 100644
--- a/include/cripts/Bundles/Common.hpp
+++ b/include/cripts/Bundles/Common.hpp
@@ -34,7 +34,7 @@ class Common : public Cript::Bundle::Base
using super_type = Cript::Bundle::Base;
using self_type = Common;
- using RecordsList = std::vector<std::pair<Cript::Records, const
Cript::Records::ValueType>>;
+ using RecordsList = std::vector<std::pair<const Cript::Records *, const
Cript::Records::ValueType>>;
public:
using super_type::Base;
@@ -68,8 +68,8 @@ public:
}
self_type &via_header(const Cript::string_view &destination, const
Cript::string_view &value);
- self_type &set_config(const Cript::string_view name, const
Cript::Records::ValueType value);
- self_type &set_config(std::vector<std::pair<const Cript::string_view, const
Cript::Records::ValueType>> configs);
+ self_type &set_config(const Cript::string_view name, const
Cript::Records::ValueType &value);
+ self_type &set_config(const std::vector<std::pair<const Cript::string_view,
const Cript::Records::ValueType>> &configs);
void doRemap(Cript::Context *context) override;
diff --git a/include/cripts/Configs.hpp b/include/cripts/Configs.hpp
index 5d70fae07e..e76d55e105 100644
--- a/include/cripts/Configs.hpp
+++ b/include/cripts/Configs.hpp
@@ -38,7 +38,8 @@ private:
class Body_Factory
{
public:
- Cript::IntConfig
response_suppression_mode{TS_CONFIG_BODY_FACTORY_RESPONSE_SUPPRESSION_MODE};
+ Cript::IntConfig
response_suppression_mode{"proxy.config.body_factory.response_suppression_mode"};
+ Cript::StringConfig
template_base{"proxy.config.body_factory.template_base"};
}; // End class Body_Factory
public:
@@ -48,6 +49,7 @@ private:
class Hostdb
{
public:
+ Cript::StringConfig ip_resolve{"proxy.config.hostdb.ip_resolve"};
}; // End class Hostdb
public:
@@ -57,61 +59,61 @@ private:
class Http
{
public:
- Cript::IntConfig allow_half_open{TS_CONFIG_HTTP_ALLOW_HALF_OPEN};
- Cript::IntConfig allow_multi_range{TS_CONFIG_HTTP_ALLOW_MULTI_RANGE};
- Cript::IntConfig
anonymize_remove_client_ip{TS_CONFIG_HTTP_ANONYMIZE_REMOVE_CLIENT_IP};
- Cript::IntConfig
anonymize_remove_cookie{TS_CONFIG_HTTP_ANONYMIZE_REMOVE_COOKIE};
- Cript::IntConfig
anonymize_remove_from{TS_CONFIG_HTTP_ANONYMIZE_REMOVE_FROM};
- Cript::IntConfig
anonymize_remove_referer{TS_CONFIG_HTTP_ANONYMIZE_REMOVE_REFERER};
- Cript::IntConfig
anonymize_remove_user_agent{TS_CONFIG_HTTP_ANONYMIZE_REMOVE_USER_AGENT};
- Cript::IntConfig
attach_server_session_to_client{TS_CONFIG_HTTP_ATTACH_SERVER_SESSION_TO_CLIENT};
- Cript::IntConfig
auth_server_session_private{TS_CONFIG_HTTP_AUTH_SERVER_SESSION_PRIVATE};
- Cript::IntConfig
background_fill_active_timeout{TS_CONFIG_HTTP_BACKGROUND_FILL_ACTIVE_TIMEOUT};
- Cript::FloatConfig
background_fill_completed_threshold{TS_CONFIG_HTTP_BACKGROUND_FILL_COMPLETED_THRESHOLD};
+ Cript::IntConfig allow_half_open{"proxy.config.http.allow_half_open"};
+ Cript::IntConfig
allow_multi_range{"proxy.config.http.allow_multi_range"};
+ Cript::IntConfig
anonymize_remove_client_ip{"proxy.config.http.anonymize_remove_client_ip"};
+ Cript::IntConfig
anonymize_remove_cookie{"proxy.config.http.anonymize_remove_cookie"};
+ Cript::IntConfig
anonymize_remove_from{"proxy.config.http.anonymize_remove_from"};
+ Cript::IntConfig
anonymize_remove_referer{"proxy.config.http.anonymize_remove_referer"};
+ Cript::IntConfig
anonymize_remove_user_agent{"proxy.config.http.anonymize_remove_user_agent"};
+ Cript::IntConfig
attach_server_session_to_client{"proxy.config.http.attach_server_session_to_client"};
+ Cript::IntConfig
auth_server_session_private{"proxy.config.http.auth_server_session_private"};
+ Cript::IntConfig
background_fill_active_timeout{"proxy.config.http.background_fill_active_timeout"};
+ Cript::FloatConfig
background_fill_completed_threshold{"proxy.config.http.background_fill_completed_threshold"};
private:
class Cache
{
public:
- Cript::IntConfig
cache_responses_to_cookies{TS_CONFIG_HTTP_CACHE_CACHE_RESPONSES_TO_COOKIES};
- Cript::IntConfig
cache_urls_that_look_dynamic{TS_CONFIG_HTTP_CACHE_CACHE_URLS_THAT_LOOK_DYNAMIC};
- Cript::IntConfig generation{TS_CONFIG_HTTP_CACHE_GENERATION};
- Cript::IntConfig
guaranteed_max_lifetime{TS_CONFIG_HTTP_CACHE_GUARANTEED_MAX_LIFETIME};
- Cript::IntConfig
guaranteed_min_lifetime{TS_CONFIG_HTTP_CACHE_GUARANTEED_MIN_LIFETIME};
- Cript::FloatConfig
heuristic_lm_factor{TS_CONFIG_HTTP_CACHE_HEURISTIC_LM_FACTOR};
- Cript::IntConfig
heuristic_max_lifetime{TS_CONFIG_HTTP_CACHE_HEURISTIC_MAX_LIFETIME};
- Cript::IntConfig
heuristic_min_lifetime{TS_CONFIG_HTTP_CACHE_HEURISTIC_MIN_LIFETIME};
- Cript::IntConfig http{TS_CONFIG_HTTP_CACHE_HTTP};
- Cript::IntConfig
ignore_accept_charset_mismatch{TS_CONFIG_HTTP_CACHE_IGNORE_ACCEPT_CHARSET_MISMATCH};
- Cript::IntConfig
ignore_accept_encoding_mismatch{TS_CONFIG_HTTP_CACHE_IGNORE_ACCEPT_ENCODING_MISMATCH};
- Cript::IntConfig
ignore_accept_language_mismatch{TS_CONFIG_HTTP_CACHE_IGNORE_ACCEPT_LANGUAGE_MISMATCH};
- Cript::IntConfig
ignore_accept_mismatch{TS_CONFIG_HTTP_CACHE_IGNORE_ACCEPT_MISMATCH};
- Cript::IntConfig
ignore_authentication{TS_CONFIG_HTTP_CACHE_IGNORE_AUTHENTICATION};
- Cript::IntConfig
ignore_client_cc_max_age{TS_CONFIG_HTTP_CACHE_IGNORE_CLIENT_CC_MAX_AGE};
- Cript::IntConfig
ignore_client_no_cache{TS_CONFIG_HTTP_CACHE_IGNORE_CLIENT_NO_CACHE};
- Cript::IntConfig ignore_query{TS_CONFIG_HTTP_CACHE_IGNORE_QUERY};
- Cript::IntConfig
ignore_server_no_cache{TS_CONFIG_HTTP_CACHE_IGNORE_SERVER_NO_CACHE};
- Cript::IntConfig
ims_on_client_no_cache{TS_CONFIG_HTTP_CACHE_IMS_ON_CLIENT_NO_CACHE};
- Cript::IntConfig
max_open_read_retries{TS_CONFIG_HTTP_CACHE_MAX_OPEN_READ_RETRIES};
- Cript::IntConfig
max_open_write_retries{TS_CONFIG_HTTP_CACHE_MAX_OPEN_WRITE_RETRIES};
- Cript::IntConfig
max_open_write_retry_timeout{TS_CONFIG_HTTP_CACHE_MAX_OPEN_WRITE_RETRY_TIMEOUT};
- Cript::IntConfig max_stale_age{TS_CONFIG_HTTP_CACHE_MAX_STALE_AGE};
- Cript::IntConfig
open_read_retry_time{TS_CONFIG_HTTP_CACHE_OPEN_READ_RETRY_TIME};
- Cript::IntConfig
open_write_fail_action{TS_CONFIG_HTTP_CACHE_OPEN_WRITE_FAIL_ACTION};
+ Cript::IntConfig
cache_responses_to_cookies{"proxy.config.http.cache.cache_responses_to_cookies"};
+ Cript::IntConfig
cache_urls_that_look_dynamic{"proxy.config.http.cache.cache_urls_that_look_dynamic"};
+ Cript::IntConfig generation{"proxy.config.http.cache.generation"};
+ Cript::IntConfig
guaranteed_max_lifetime{"proxy.config.http.cache.guaranteed_max_lifetime"};
+ Cript::IntConfig
guaranteed_min_lifetime{"proxy.config.http.cache.guaranteed_min_lifetime"};
+ Cript::FloatConfig
heuristic_lm_factor{"proxy.config.http.cache.heuristic_lm_factor"};
+ Cript::IntConfig
heuristic_max_lifetime{"proxy.config.http.cache.heuristic_max_lifetime"};
+ Cript::IntConfig
heuristic_min_lifetime{"proxy.config.http.cache.heuristic_min_lifetime"};
+ Cript::IntConfig http{"proxy.config.http.cache.http"};
+ Cript::IntConfig
ignore_accept_charset_mismatch{"proxy.config.http.cache.ignore_accept_charset_mismatch"};
+ Cript::IntConfig
ignore_accept_encoding_mismatch{"proxy.config.http.cache.ignore_accept_encoding_mismatch"};
+ Cript::IntConfig
ignore_accept_language_mismatch{"proxy.config.http.cache.ignore_accept_language_mismatch"};
+ Cript::IntConfig
ignore_accept_mismatch{"proxy.config.http.cache.ignore_accept_mismatch"};
+ Cript::IntConfig
ignore_authentication{"proxy.config.http.cache.ignore_authentication"};
+ Cript::IntConfig
ignore_client_cc_max_age{"proxy.config.http.cache.ignore_client_cc_max_age"};
+ Cript::IntConfig
ignore_client_no_cache{"proxy.config.http.cache.ignore_client_no_cache"};
+ Cript::IntConfig
ignore_query{"proxy.config.http.cache.ignore_query"};
+ Cript::IntConfig
ignore_server_no_cache{"proxy.config.http.cache.ignore_server_no_cache"};
+ Cript::IntConfig
ims_on_client_no_cache{"proxy.config.http.cache.ims_on_client_no_cache"};
+ Cript::IntConfig
max_open_read_retries{"proxy.config.http.cache.max_open_read_retries"};
+ Cript::IntConfig
max_open_write_retries{"proxy.config.http.cache.max_open_write_retries"};
+ Cript::IntConfig
max_open_write_retry_timeout{"proxy.config.http.cache.max_open_write_retry_timeout"};
+ Cript::IntConfig
max_stale_age{"proxy.config.http.cache.max_stale_age"};
+ Cript::IntConfig
open_read_retry_time{"proxy.config.http.cache.open_read_retry_time"};
+ Cript::IntConfig
open_write_fail_action{"proxy.config.http.cache.open_write_fail_action"};
private:
class Range
{
public:
- Cript::IntConfig lookup{TS_CONFIG_HTTP_CACHE_RANGE_LOOKUP};
- Cript::IntConfig write{TS_CONFIG_HTTP_CACHE_RANGE_WRITE};
+ Cript::IntConfig lookup{"proxy.config.http.cache.range.lookup"};
+ Cript::IntConfig write{"proxy.config.http.cache.range.write"};
}; // End class Range
public:
Range range;
- Cript::IntConfig
required_headers{TS_CONFIG_HTTP_CACHE_REQUIRED_HEADERS};
- Cript::IntConfig
when_to_revalidate{TS_CONFIG_HTTP_CACHE_WHEN_TO_REVALIDATE};
+ Cript::IntConfig
required_headers{"proxy.config.http.cache.required_headers"};
+ Cript::IntConfig
when_to_revalidate{"proxy.config.http.cache.when_to_revalidate"};
}; // End class Cache
public:
@@ -121,13 +123,13 @@ private:
class Chunking
{
public:
- Cript::IntConfig size{TS_CONFIG_HTTP_CHUNKING_SIZE};
+ Cript::IntConfig size{"proxy.config.http.chunking.size"};
}; // End class Chunking
public:
Chunking chunking;
- Cript::IntConfig chunking_enabled{TS_CONFIG_HTTP_CHUNKING_ENABLED};
+ Cript::IntConfig chunking_enabled{"proxy.config.http.chunking_enabled"};
private:
class Connect
@@ -136,7 +138,7 @@ private:
class Down
{
public:
- Cript::IntConfig policy{TS_CONFIG_HTTP_CONNECT_DOWN_POLICY};
+ Cript::IntConfig policy{"proxy.config.http.connect.down.policy"};
}; // End class Down
public:
@@ -147,19 +149,19 @@ private:
public:
Connect connect;
- Cript::IntConfig
connect_attempts_max_retries{TS_CONFIG_HTTP_CONNECT_ATTEMPTS_MAX_RETRIES};
- Cript::IntConfig
connect_attempts_max_retries_down_server{TS_CONFIG_HTTP_CONNECT_ATTEMPTS_MAX_RETRIES_DOWN_SERVER};
- Cript::IntConfig
connect_attempts_rr_retries{TS_CONFIG_HTTP_CONNECT_ATTEMPTS_RR_RETRIES};
- Cript::IntConfig
connect_attempts_timeout{TS_CONFIG_HTTP_CONNECT_ATTEMPTS_TIMEOUT};
- Cript::IntConfig default_buffer_size{TS_CONFIG_HTTP_DEFAULT_BUFFER_SIZE};
- Cript::IntConfig
default_buffer_water_mark{TS_CONFIG_HTTP_DEFAULT_BUFFER_WATER_MARK};
- Cript::IntConfig
doc_in_cache_skip_dns{TS_CONFIG_HTTP_DOC_IN_CACHE_SKIP_DNS};
+ Cript::IntConfig
connect_attempts_max_retries{"proxy.config.http.connect_attempts_max_retries"};
+ Cript::IntConfig
connect_attempts_max_retries_down_server{"proxy.config.http.connect_attempts_max_retries_down_server"};
+ Cript::IntConfig
connect_attempts_rr_retries{"proxy.config.http.connect_attempts_rr_retries"};
+ Cript::IntConfig
connect_attempts_timeout{"proxy.config.http.connect_attempts_timeout"};
+ Cript::IntConfig
default_buffer_size{"proxy.config.http.default_buffer_size"};
+ Cript::IntConfig
default_buffer_water_mark{"proxy.config.http.default_buffer_water_mark"};
+ Cript::IntConfig
doc_in_cache_skip_dns{"proxy.config.http.doc_in_cache_skip_dns"};
private:
class Down_Server
{
public:
- Cript::IntConfig cache_time{TS_CONFIG_HTTP_DOWN_SERVER_CACHE_TIME};
+ Cript::IntConfig
cache_time{"proxy.config.http.down_server.cache_time"};
}; // End class Down_Server
public:
@@ -169,9 +171,9 @@ private:
class Flow_Control
{
public:
- Cript::IntConfig enabled{TS_CONFIG_HTTP_FLOW_CONTROL_ENABLED};
- Cript::IntConfig
high_water{TS_CONFIG_HTTP_FLOW_CONTROL_HIGH_WATER_MARK};
- Cript::IntConfig low_water{TS_CONFIG_HTTP_FLOW_CONTROL_LOW_WATER_MARK};
+ Cript::IntConfig enabled{"proxy.config.http.flow_control.enabled"};
+ Cript::IntConfig
high_water{"proxy.config.http.flow_control.high_water"};
+ Cript::IntConfig low_water{"proxy.config.http.flow_control.low_water"};
}; // End class Flow_Control
public:
@@ -181,43 +183,45 @@ private:
class Forward
{
public:
- Cript::IntConfig
proxy_auth_to_parent{TS_CONFIG_HTTP_FORWARD_PROXY_AUTH_TO_PARENT};
+ Cript::IntConfig
proxy_auth_to_parent{"proxy.config.http.forward.proxy_auth_to_parent"};
}; // End class Forward
public:
Forward forward;
- Cript::IntConfig
forward_connect_method{TS_CONFIG_HTTP_FORWARD_CONNECT_METHOD};
- Cript::IntConfig
insert_age_in_response{TS_CONFIG_HTTP_INSERT_AGE_IN_RESPONSE};
- Cript::IntConfig
insert_client_ip{TS_CONFIG_HTTP_ANONYMIZE_INSERT_CLIENT_IP};
- Cript::IntConfig
insert_request_via_str{TS_CONFIG_HTTP_INSERT_REQUEST_VIA_STR};
- Cript::IntConfig
insert_response_via_str{TS_CONFIG_HTTP_INSERT_RESPONSE_VIA_STR};
- Cript::IntConfig
insert_squid_x_forwarded_for{TS_CONFIG_HTTP_INSERT_SQUID_X_FORWARDED_FOR};
- Cript::IntConfig
keep_alive_enabled_in{TS_CONFIG_HTTP_KEEP_ALIVE_ENABLED_IN};
- Cript::IntConfig
keep_alive_enabled_out{TS_CONFIG_HTTP_KEEP_ALIVE_ENABLED_OUT};
- Cript::IntConfig
keep_alive_no_activity_timeout_in{TS_CONFIG_HTTP_KEEP_ALIVE_NO_ACTIVITY_TIMEOUT_IN};
- Cript::IntConfig
keep_alive_no_activity_timeout_out{TS_CONFIG_HTTP_KEEP_ALIVE_NO_ACTIVITY_TIMEOUT_OUT};
- Cript::IntConfig keep_alive_post_out{TS_CONFIG_HTTP_KEEP_ALIVE_POST_OUT};
- Cript::IntConfig max_proxy_cycles{TS_CONFIG_HTTP_MAX_PROXY_CYCLES};
- Cript::IntConfig
negative_caching_enabled{TS_CONFIG_HTTP_NEGATIVE_CACHING_ENABLED};
- Cript::IntConfig
negative_caching_lifetime{TS_CONFIG_HTTP_NEGATIVE_CACHING_LIFETIME};
- Cript::IntConfig
negative_revalidating_enabled{TS_CONFIG_HTTP_NEGATIVE_REVALIDATING_ENABLED};
- Cript::IntConfig
negative_revalidating_lifetime{TS_CONFIG_HTTP_NEGATIVE_REVALIDATING_LIFETIME};
- Cript::IntConfig
no_dns_just_forward_to_parent{TS_CONFIG_HTTP_NO_DNS_JUST_FORWARD_TO_PARENT};
- Cript::IntConfig normalize_ae{TS_CONFIG_HTTP_NORMALIZE_AE};
- Cript::IntConfig
number_of_redirections{TS_CONFIG_HTTP_NUMBER_OF_REDIRECTIONS};
+ Cript::IntConfig
forward_connect_method{"proxy.config.http.forward_connect_method"};
+ Cript::StringConfig
global_user_agent_header{"proxy.config.http.global_user_agent_header"};
+ Cript::IntConfig
insert_age_in_response{"proxy.config.http.insert_age_in_response"};
+ Cript::IntConfig
insert_client_ip{"proxy.config.http.insert_client_ip"};
+ Cript::StringConfig
insert_forwarded{"proxy.config.http.insert_forwarded"};
+ Cript::IntConfig
insert_request_via_str{"proxy.config.http.insert_request_via_str"};
+ Cript::IntConfig
insert_response_via_str{"proxy.config.http.insert_response_via_str"};
+ Cript::IntConfig
insert_squid_x_forwarded_for{"proxy.config.http.insert_squid_x_forwarded_for"};
+ Cript::IntConfig
keep_alive_enabled_in{"proxy.config.http.keep_alive_enabled_in"};
+ Cript::IntConfig
keep_alive_enabled_out{"proxy.config.http.keep_alive_enabled_out"};
+ Cript::IntConfig
keep_alive_no_activity_timeout_in{"proxy.config.http.keep_alive_no_activity_timeout_in"};
+ Cript::IntConfig
keep_alive_no_activity_timeout_out{"proxy.config.http.keep_alive_no_activity_timeout_out"};
+ Cript::IntConfig
keep_alive_post_out{"proxy.config.http.keep_alive_post_out"};
+ Cript::IntConfig
max_proxy_cycles{"proxy.config.http.max_proxy_cycles"};
+ Cript::IntConfig
negative_caching_enabled{"proxy.config.http.negative_caching_enabled"};
+ Cript::IntConfig
negative_caching_lifetime{"proxy.config.http.negative_caching_lifetime"};
+ Cript::IntConfig
negative_revalidating_enabled{"proxy.config.http.negative_revalidating_enabled"};
+ Cript::IntConfig
negative_revalidating_lifetime{"proxy.config.http.negative_revalidating_lifetime"};
+ Cript::IntConfig
no_dns_just_forward_to_parent{"proxy.config.http.no_dns_just_forward_to_parent"};
+ Cript::IntConfig normalize_ae{"proxy.config.http.normalize_ae"};
+ Cript::IntConfig
number_of_redirections{"proxy.config.http.number_of_redirections"};
private:
class Parent_Proxy
{
public:
- Cript::IntConfig
disable_parent_markdowns{TS_CONFIG_HTTP_DISABLE_PARENT_MARKDOWNS};
- Cript::IntConfig
enable_parent_timeout_markdowns{TS_CONFIG_HTTP_ENABLE_PARENT_TIMEOUT_MARKDOWNS};
- Cript::IntConfig
fail_threshold{TS_CONFIG_HTTP_PARENT_PROXY_FAIL_THRESHOLD};
- Cript::IntConfig
mark_down_hostdb{TS_CONFIG_PARENT_FAILURES_UPDATE_HOSTDB};
- Cript::IntConfig
per_parent_connect_attempts{TS_CONFIG_HTTP_PER_PARENT_CONNECT_ATTEMPTS};
- Cript::IntConfig retry_time{TS_CONFIG_HTTP_PARENT_PROXY_RETRY_TIME};
- Cript::IntConfig
total_connect_attempts{TS_CONFIG_HTTP_PARENT_PROXY_TOTAL_CONNECT_ATTEMPTS};
+ Cript::IntConfig
disable_parent_markdowns{"proxy.config.http.parent_proxy.disable_parent_markdowns"};
+ Cript::IntConfig
enable_parent_timeout_markdowns{"proxy.config.http.parent_proxy.enable_parent_timeout_markdowns"};
+ Cript::IntConfig
fail_threshold{"proxy.config.http.parent_proxy.fail_threshold"};
+ Cript::IntConfig
mark_down_hostdb{"proxy.config.http.parent_proxy.mark_down_hostdb"};
+ Cript::IntConfig
per_parent_connect_attempts{"proxy.config.http.parent_proxy.per_parent_connect_attempts"};
+ Cript::IntConfig
retry_time{"proxy.config.http.parent_proxy.retry_time"};
+ Cript::IntConfig
total_connect_attempts{"proxy.config.http.parent_proxy.total_connect_attempts"};
}; // End class Parent_Proxy
public:
@@ -233,7 +237,7 @@ private:
class Content_Length
{
public:
- Cript::IntConfig
enabled{TS_CONFIG_HTTP_POST_CHECK_CONTENT_LENGTH_ENABLED};
+ Cript::IntConfig
enabled{"proxy.config.http.post.check.content_length.enabled"};
}; // End class Content_Length
public:
@@ -249,18 +253,20 @@ private:
public:
Post post;
- Cript::IntConfig proxy_protocol_out{TS_CONFIG_HTTP_PROXY_PROTOCOL_OUT};
- Cript::IntConfig
redirect_use_orig_cache_key{TS_CONFIG_HTTP_REDIRECT_USE_ORIG_CACHE_KEY};
- Cript::IntConfig
request_buffer_enabled{TS_CONFIG_HTTP_REQUEST_BUFFER_ENABLED};
- Cript::IntConfig
request_header_max_size{TS_CONFIG_HTTP_REQUEST_HEADER_MAX_SIZE};
- Cript::IntConfig
response_header_max_size{TS_CONFIG_HTTP_RESPONSE_HEADER_MAX_SIZE};
- Cript::IntConfig
response_server_enabled{TS_CONFIG_HTTP_RESPONSE_SERVER_ENABLED};
- Cript::IntConfig
send_http11_requests{TS_CONFIG_HTTP_SEND_HTTP11_REQUESTS};
+ Cript::IntConfig
proxy_protocol_out{"proxy.config.http.proxy_protocol_out"};
+ Cript::IntConfig
redirect_use_orig_cache_key{"proxy.config.http.redirect_use_orig_cache_key"};
+ Cript::IntConfig
request_buffer_enabled{"proxy.config.http.request_buffer_enabled"};
+ Cript::IntConfig
request_header_max_size{"proxy.config.http.request_header_max_size"};
+ Cript::IntConfig
response_header_max_size{"proxy.config.http.response_header_max_size"};
+ Cript::IntConfig
response_server_enabled{"proxy.config.http.response_server_enabled"};
+ Cript::StringConfig
response_server_str{"proxy.config.http.response_server_str"};
+ Cript::IntConfig
send_http11_requests{"proxy.config.http.send_http11_requests"};
private:
class Server_Session_Sharing
{
public:
+ Cript::StringConfig
match{"proxy.config.http.server_session_sharing.match"};
}; // End class Server_Session_Sharing
public:
@@ -273,7 +279,7 @@ private:
class Log
{
public:
- Cript::IntConfig threshold{TS_CONFIG_HTTP_SLOW_LOG_THRESHOLD};
+ Cript::IntConfig threshold{"proxy.config.http.slow.log.threshold"};
}; // End class Log
public:
@@ -284,11 +290,11 @@ private:
public:
Slow slow;
- Cript::IntConfig
transaction_active_timeout_in{TS_CONFIG_HTTP_TRANSACTION_ACTIVE_TIMEOUT_IN};
- Cript::IntConfig
transaction_active_timeout_out{TS_CONFIG_HTTP_TRANSACTION_ACTIVE_TIMEOUT_OUT};
- Cript::IntConfig
transaction_no_activity_timeout_in{TS_CONFIG_HTTP_TRANSACTION_NO_ACTIVITY_TIMEOUT_IN};
- Cript::IntConfig
transaction_no_activity_timeout_out{TS_CONFIG_HTTP_TRANSACTION_NO_ACTIVITY_TIMEOUT_OUT};
- Cript::IntConfig
uncacheable_requests_bypass_parent{TS_CONFIG_HTTP_UNCACHEABLE_REQUESTS_BYPASS_PARENT};
+ Cript::IntConfig
transaction_active_timeout_in{"proxy.config.http.transaction_active_timeout_in"};
+ Cript::IntConfig
transaction_active_timeout_out{"proxy.config.http.transaction_active_timeout_out"};
+ Cript::IntConfig
transaction_no_activity_timeout_in{"proxy.config.http.transaction_no_activity_timeout_in"};
+ Cript::IntConfig
transaction_no_activity_timeout_out{"proxy.config.http.transaction_no_activity_timeout_out"};
+ Cript::IntConfig
uncacheable_requests_bypass_parent{"proxy.config.http.uncacheable_requests_bypass_parent"};
}; // End class Http
public:
@@ -298,13 +304,13 @@ private:
class Net
{
public:
- Cript::IntConfig
default_inactivity_timeout{TS_CONFIG_NET_DEFAULT_INACTIVITY_TIMEOUT};
- Cript::IntConfig sock_notsent_lowat{TS_CONFIG_NET_SOCK_NOTSENT_LOWAT};
- Cript::IntConfig
sock_option_flag_out{TS_CONFIG_NET_SOCK_OPTION_FLAG_OUT};
- Cript::IntConfig
sock_packet_mark_out{TS_CONFIG_NET_SOCK_PACKET_MARK_OUT};
- Cript::IntConfig sock_packet_tos_out{TS_CONFIG_NET_SOCK_PACKET_TOS_OUT};
- Cript::IntConfig
sock_recv_buffer_size_out{TS_CONFIG_NET_SOCK_RECV_BUFFER_SIZE_OUT};
- Cript::IntConfig
sock_send_buffer_size_out{TS_CONFIG_NET_SOCK_SEND_BUFFER_SIZE_OUT};
+ Cript::IntConfig
default_inactivity_timeout{"proxy.config.net.default_inactivity_timeout"};
+ Cript::IntConfig
sock_notsent_lowat{"proxy.config.net.sock_notsent_lowat"};
+ Cript::IntConfig
sock_option_flag_out{"proxy.config.net.sock_option_flag_out"};
+ Cript::IntConfig
sock_packet_mark_out{"proxy.config.net.sock_packet_mark_out"};
+ Cript::IntConfig
sock_packet_tos_out{"proxy.config.net.sock_packet_tos_out"};
+ Cript::IntConfig
sock_recv_buffer_size_out{"proxy.config.net.sock_recv_buffer_size_out"};
+ Cript::IntConfig
sock_send_buffer_size_out{"proxy.config.net.sock_send_buffer_size_out"};
}; // End class Net
public:
@@ -317,8 +323,8 @@ private:
class Vc
{
public:
- Cript::IntConfig
default_buffer_index{TS_CONFIG_PLUGIN_VC_DEFAULT_BUFFER_INDEX};
- Cript::IntConfig
default_buffer_water_mark{TS_CONFIG_PLUGIN_VC_DEFAULT_BUFFER_WATER_MARK};
+ Cript::IntConfig
default_buffer_index{"proxy.config.plugin.vc.default_buffer_index"};
+ Cript::IntConfig
default_buffer_water_mark{"proxy.config.plugin.vc.default_buffer_water_mark"};
}; // End class Vc
public:
@@ -330,7 +336,7 @@ private:
Plugin plugin;
public:
- Cript::IntConfig srv_enabled{TS_CONFIG_SRV_ENABLED};
+ Cript::IntConfig srv_enabled{"proxy.config.srv_enabled"};
private:
class Ssl
@@ -345,6 +351,7 @@ private:
class Cert
{
public:
+ Cript::StringConfig
filename{"proxy.config.ssl.client.CA.cert.filename"};
}; // End class Cert
public:
@@ -356,10 +363,14 @@ private:
Ca CA;
public:
+ Cript::StringConfig
alpn_protocols{"proxy.config.ssl.client.alpn_protocols"};
+
private:
class Cert
{
public:
+ Cript::StringConfig
filename{"proxy.config.ssl.client.cert.filename"};
+ Cript::StringConfig path{"proxy.config.ssl.client.cert.path"};
}; // End class Cert
public:
@@ -369,11 +380,14 @@ private:
class Private_Key
{
public:
+ Cript::StringConfig
filename{"proxy.config.ssl.client.private_key.filename"};
}; // End class Private_Key
public:
Private_Key private_key;
+ Cript::StringConfig sni_policy{"proxy.config.ssl.client.sni_policy"};
+
private:
class Verify
{
@@ -381,6 +395,8 @@ private:
class Server
{
public:
+ Cript::StringConfig
policy{"proxy.config.ssl.client.verify.server.policy"};
+ Cript::StringConfig
properties{"proxy.config.ssl.client.verify.server.properties"};
}; // End class Server
public:
@@ -397,8 +413,8 @@ private:
Client client;
public:
- Cript::IntConfig
hsts_include_subdomains{TS_CONFIG_SSL_HSTS_INCLUDE_SUBDOMAINS};
- Cript::IntConfig hsts_max_age{TS_CONFIG_SSL_HSTS_MAX_AGE};
+ Cript::IntConfig
hsts_include_subdomains{"proxy.config.ssl.hsts_include_subdomains"};
+ Cript::IntConfig hsts_max_age{"proxy.config.ssl.hsts_max_age"};
}; // End class Ssl
public:
@@ -408,7 +424,7 @@ private:
class Url_Remap
{
public:
- Cript::IntConfig
pristine_host_hdr{TS_CONFIG_URL_REMAP_PRISTINE_HOST_HDR};
+ Cript::IntConfig
pristine_host_hdr{"proxy.config.url_remap.pristine_host_hdr"};
}; // End class Url_Remap
public:
@@ -418,8 +434,8 @@ private:
class Websocket
{
public:
- Cript::IntConfig active_timeout{TS_CONFIG_WEBSOCKET_ACTIVE_TIMEOUT};
- Cript::IntConfig
no_activity_timeout{TS_CONFIG_WEBSOCKET_NO_ACTIVITY_TIMEOUT};
+ Cript::IntConfig active_timeout{"proxy.config.websocket.active_timeout"};
+ Cript::IntConfig
no_activity_timeout{"proxy.config.websocket.no_activity_timeout"};
}; // End class Websocket
public:
diff --git a/include/cripts/ConfigsBase.hpp b/include/cripts/ConfigsBase.hpp
index 4ceb27fcfa..e1348bebac 100644
--- a/include/cripts/ConfigsBase.hpp
+++ b/include/cripts/ConfigsBase.hpp
@@ -19,40 +19,14 @@
#pragma once
-#include "ts/ts.h"
+#include <unordered_map>
+#include "ts/ts.h"
#include "cripts/Lulu.hpp"
#include "cripts/Context.hpp"
namespace Cript
{
-class IntConfig
-{
-public:
- IntConfig() = delete;
- explicit IntConfig(TSOverridableConfigKey key) : _key(key) {}
-
- // Implemented later in Configs.cc
- integer _get(Cript::Context *context) const;
- void _set(Cript::Context *context, integer value);
-
-private:
- const TSOverridableConfigKey _key;
-}; // namespace Criptclass IntConfig
-
-class FloatConfig
-{
-public:
- FloatConfig() = delete;
- explicit FloatConfig(TSOverridableConfigKey key) : _key(key) {}
-
- // Implemented later in Configs.cc
- float _get(Cript::Context *context) const;
- void _set(Cript::Context *context, float value);
-
-private:
- const TSOverridableConfigKey _key;
-};
class Records
{
@@ -70,7 +44,12 @@ public:
explicit Records(const Cript::string_view name);
ValueType _get(const Cript::Context *context) const;
- bool _set(const Cript::Context *context, const ValueType value);
+ bool _set(const Cript::Context *context, const ValueType &value) const;
+
+ // Optimizations, we can't use string_view in the ValueType since we need
persistent storage.
+ // Be careful with the setSV() and make sure there's underlying storage!
+ const Cript::string_view getSV(const Cript::Context *context) const;
+ bool setSV(const Cript::Context *context, const
Cript::string_view value) const;
[[nodiscard]] TSOverridableConfigKey
key() const
@@ -96,9 +75,105 @@ public:
return (_key != TS_CONFIG_NULL && _type != TS_RECORDDATATYPE_NULL);
}
+ [[nodiscard]] bool
+ isInteger() const
+ {
+ return _type == TS_RECORDDATATYPE_INT;
+ }
+
+ [[nodiscard]] bool
+ isFloat() const
+ {
+ return _type == TS_RECORDDATATYPE_FLOAT;
+ }
+
+ [[nodiscard]] bool
+ isString() const
+ {
+ return _type == TS_RECORDDATATYPE_STRING;
+ }
+
+ static void add(const Records *rec);
+ static const Records *lookup(const Cript::string_view name);
+
private:
Cript::string _name;
TSOverridableConfigKey _key = TS_CONFIG_NULL;
TSRecordDataType _type = TS_RECORDDATATYPE_NULL;
-};
+
+ static std::unordered_map<Cript::string_view, const Records *> _gRecords;
+}; // class Records
+
+class IntConfig
+{
+public:
+ IntConfig() = delete;
+ explicit IntConfig(const Cript::string_view name) : _record(name) {
Records::add(&_record); }
+
+ float
+ _get(Cript::Context *context) const
+ {
+ return std::get<TSMgmtInt>(_record._get(context));
+ }
+
+ void
+ _set(Cript::Context *context, integer value)
+ {
+ _record._set(context, value);
+ }
+
+private:
+ const Records _record;
+}; // class IntConfig
+
+class FloatConfig
+{
+public:
+ FloatConfig() = delete;
+ explicit FloatConfig(const Cript::string_view name) : _record(name) {
Records::add(&_record); }
+
+ float
+ _get(Cript::Context *context) const
+ {
+ return std::get<TSMgmtFloat>(_record._get(context));
+ }
+
+ void
+ _set(Cript::Context *context, float value)
+ {
+ _record._set(context, value);
+ }
+
+private:
+ const Records _record;
+}; // class FloatConfig
+
+class StringConfig
+{
+public:
+ StringConfig() = delete;
+ explicit StringConfig(const Cript::string_view name) : _record(name) {
Records::add(&_record); }
+
+ std::string
+ _get(Cript::Context *context) const
+ {
+ return std::get<std::string>(_record._get(context));
+ }
+
+ void
+ _set(Cript::Context *context, std::string &value)
+ {
+ _record.setSV(context, value);
+ }
+
+ const std::string_view
+ getSV(Cript::Context *context) const
+ {
+ return _record.getSV(context);
+ }
+
+private:
+ const Records _record;
+}; // class StringConfig
+
} // namespace Cript
diff --git a/include/cripts/Context.hpp b/include/cripts/Context.hpp
index d6eedc24a3..128b537fd9 100644
--- a/include/cripts/Context.hpp
+++ b/include/cripts/Context.hpp
@@ -108,13 +108,6 @@ private:
#define transaction context->state
#define txn_data context->data
#define instance context->p_instance
-#define borrow auto &
#define CDebug(...) context->p_instance.debug(__VA_ARGS__)
#define CDebugOn() context->p_instance.debugOn()
-#define CAssert(...) TSReleaseAssert(__VA_ARGS__)
#define DisableCallback(cb) context->state.disableCallback(cb)
-#define AsBoolean(arg) std::get<boolean>(arg)
-#define AsString(arg) std::get<Cript::string>(arg)
-#define AsInteger(arg) std::get<integer>(arg)
-#define AsFloat(arg) std::get<double>(arg)
-#define AsPointer(arg) std::get<void *>(arg)
diff --git a/include/cripts/Epilogue.hpp b/include/cripts/Epilogue.hpp
index 6b26d62a1a..96b7b712c4 100644
--- a/include/cripts/Epilogue.hpp
+++ b/include/cripts/Epilogue.hpp
@@ -348,7 +348,7 @@ default_cont(TSCont contp, TSEvent event, void *edata)
break;
// This is for cleanup, and should always be called / wrapped
default:
- TSReleaseAssert(!"Unknown event to Cript plugin!");
+ CFatal("Cripts continuation: Unknown event %d", event);
break;
}
diff --git a/include/cripts/Headers.hpp b/include/cripts/Headers.hpp
index 22ec36d088..b0b30a053f 100644
--- a/include/cripts/Headers.hpp
+++ b/include/cripts/Headers.hpp
@@ -24,6 +24,7 @@
#include "ts/ts.h"
#include "cripts/Transaction.hpp"
+#include "cripts/Lulu.hpp"
class Header
{
@@ -123,7 +124,7 @@ public:
[[nodiscard]] Cript::string_view::const_pointer
data() const
{
- TSReleaseAssert(_method.size() > 0);
+ CAssert(_method.size() > 0);
return _method.data();
}
@@ -319,7 +320,7 @@ public:
operator++()
{
if (_tag != END_TAG) {
- TSReleaseAssert(_tag == _owner->_iterator_tag);
+ CAssert(_tag == _owner->_iterator_tag);
_view = _owner->iterate();
if (_view.empty()) {
diff --git a/include/cripts/Instance.hpp b/include/cripts/Instance.hpp
index a3b4742e2d..5866fe1604 100644
--- a/include/cripts/Instance.hpp
+++ b/include/cripts/Instance.hpp
@@ -63,7 +63,7 @@ public:
{
for (auto &it : bundles) {
if (it->name() == bundle->name()) {
- TSReleaseAssert(!"Duplicate bundle");
+ CFatal("[Instance]: Duplicate bundle %s", bundle->name().c_str());
}
}
diff --git a/include/cripts/Lulu.hpp b/include/cripts/Lulu.hpp
index e32dbc05b8..7108c4b109 100644
--- a/include/cripts/Lulu.hpp
+++ b/include/cripts/Lulu.hpp
@@ -42,6 +42,16 @@ namespace CFS = std::filesystem; // Simplify the
usage of std::filesys
integer integer_helper(std::string_view sv);
+// Some convenience macros
+#define borrow auto &
+#define CAssert(...) TSReleaseAssert(__VA_ARGS__)
+#define CFatal(...) TSFatal(__VA_ARGS__)
+#define AsBoolean(arg) std::get<boolean>(arg)
+#define AsString(arg) std::get<Cript::string>(arg)
+#define AsInteger(arg) std::get<integer>(arg)
+#define AsFloat(arg) std::get<double>(arg)
+#define AsPointer(arg) std::get<void *>(arg)
+
namespace Cript
{
// Use Cript::string_view consistently, so that it's a one-stop shop for all
string_view needs.
diff --git a/include/cripts/Matcher.hpp b/include/cripts/Matcher.hpp
index b7110147d5..24e48a75cf 100644
--- a/include/cripts/Matcher.hpp
+++ b/include/cripts/Matcher.hpp
@@ -27,6 +27,7 @@
#include <tuple>
#include "ts/ts.h"
+#include "cripts/Lulu.hpp"
namespace Matcher
{
@@ -84,7 +85,7 @@ namespace Range
if (swoc::IPRange r; r.load(str)) {
mark(r);
} else {
- TSReleaseAssert("Bad IP range");
+ CFatal("[Matcher::Range::IP] Invalid IP range: %.*s",
static_cast<int>(str.size()), str.data());
}
}
diff --git a/include/cripts/Metrics.hpp b/include/cripts/Metrics.hpp
index 5b653dcc31..e70ea33dd5 100644
--- a/include/cripts/Metrics.hpp
+++ b/include/cripts/Metrics.hpp
@@ -59,7 +59,7 @@ public:
void
increment(int64_t inc) const
{
- TSReleaseAssert(_id != ts::Metrics::NOT_FOUND);
+ CAssert(_id != ts::Metrics::NOT_FOUND);
_metric->increment(inc);
}
@@ -72,7 +72,7 @@ public:
void
decrement(int64_t dec) const
{
- TSReleaseAssert(_id != ts::Metrics::NOT_FOUND);
+ CAssert(_id != ts::Metrics::NOT_FOUND);
_metric->decrement(dec);
}
@@ -85,14 +85,14 @@ public:
[[nodiscard]] int64_t
get() const
{
- TSReleaseAssert(_id != TS_ERROR);
+ CAssert(_id != TS_ERROR);
return _metric->load();
}
void
set(int64_t val)
{
- TSReleaseAssert(_id != TS_ERROR);
+ CAssert(_id != TS_ERROR);
_metric->store(val);
}
diff --git a/src/cripts/Bundles/Common.cc b/src/cripts/Bundles/Common.cc
index 2956c35bfd..f5b7e2e608 100644
--- a/src/cripts/Bundles/Common.cc
+++ b/src/cripts/Bundles/Common.cc
@@ -42,28 +42,28 @@ Common::validate(std::vector<Cript::Bundle::Error> &errors)
const
// Make sure all configurations are of the correct type
for (auto &[rec, value] : _configs) {
- switch (rec.type()) {
+ switch (rec->type()) {
case TS_RECORDDATATYPE_INT:
if (!std::holds_alternative<TSMgmtInt>(value)) {
- errors.emplace_back("Invalid value for config, expecting an integer",
name(), rec.name());
+ errors.emplace_back("Invalid value for config, expecting an integer",
name(), rec->name());
good = false;
}
break;
case TS_RECORDDATATYPE_FLOAT:
if (!std::holds_alternative<TSMgmtFloat>(value)) {
- errors.emplace_back("Invalid value for config, expecting a float",
name(), rec.name());
+ errors.emplace_back("Invalid value for config, expecting a float",
name(), rec->name());
good = false;
}
break;
case TS_RECORDDATATYPE_STRING:
if (!std::holds_alternative<std::string>(value)) {
- errors.emplace_back("Invalid value for config, expecting an integer",
name(), rec.name());
+ errors.emplace_back("Invalid value for config, expecting an integer",
name(), rec->name());
good = false;
}
break;
default:
- errors.emplace_back("Invalid configuration type", name(), rec.name());
+ errors.emplace_back("Invalid configuration type", name(), rec->name());
good = false;
break;
}
@@ -105,20 +105,22 @@ Common::via_header(const Cript::string_view &destination,
const Cript::string_vi
}
Common &
-Common::set_config(const Cript::string_view name, const
Cript::Records::ValueType value)
+Common::set_config(const Cript::string_view name, const
Cript::Records::ValueType &value)
{
- Cript::Records rec(name);
+ auto rec = Cript::Records::lookup(name); // These should be loaded at startup
- if (rec.loaded()) {
+ if (rec) {
needCallback(Cript::Callbacks::DO_REMAP);
- _configs.emplace_back(std::move(rec), value);
+ _configs.emplace_back(rec, value);
+ } else {
+ CFatal("[Common::set_config]: Unknown configuration '%.*s'",
static_cast<int>(name.size()), name.data());
}
return *this;
}
Common &
-Common::set_config(std::vector<std::pair<const Cript::string_view, const
Cript::Records::ValueType>> configs)
+Common::set_config(const std::vector<std::pair<const Cript::string_view, const
Cript::Records::ValueType>> &configs)
{
for (auto &[name, value] : configs) {
set_config(name, value);
@@ -150,7 +152,7 @@ Common::doRemap(Cript::Context *context)
// .set_config()
for (auto &[rec, value] : _configs) {
- rec._set(context, value);
+ rec->_set(context, value);
}
}
diff --git a/src/cripts/Bundles/HRWBridge.cc b/src/cripts/Bundles/HRWBridge.cc
index bba4727bb6..09eb6d6e4a 100644
--- a/src/cripts/Bundles/HRWBridge.cc
+++ b/src/cripts/Bundles/HRWBridge.cc
@@ -54,7 +54,7 @@ ID::ID(const Cript::string_view &id) : super_type(id)
} else if (id == "UNIQUE") {
_type = Type::UNIQUE;
} else {
- TSReleaseAssert(!"Invalid ID type in HRWBridge");
+ CFatal("[Cripts::Headers] Unknown HRWBridge ID type: %s.", id.data());
}
}
@@ -112,7 +112,7 @@ IP::IP(const Cript::string_view &type) : super_type(type)
} else if (type == "OUTBOUND") {
_type = Type::INBOUND;
} else {
- TSReleaseAssert(!"Invalid TYPE IP in HRWBridge");
+ CFatal("[Cripts::Headers] Unknown HRWBridge IP type: %s.", type.data());
}
}
@@ -169,17 +169,17 @@ CIDR::CIDR(Cript::string_view &cidr) : super_type(cidr)
{
auto ipv4 = cidr.split_prefix_at(',');
- TSReleaseAssert(ipv4 != cidr); // No ' found
+ CAssert(ipv4 != cidr); // No ' found
auto result = std::from_chars(ipv4.data(), ipv4.data() + ipv4.size(),
_ipv4_cidr);
if (result.ec != std::errc()) {
- TSReleaseAssert(!"Invalid CIDR parameters in HRWBridge");
+ CFatal("[Cripts::Headers] Invalid IPv4 CIDR parameters: %s.", cidr.data());
}
result = std::from_chars(cidr.data(), cidr.data() + cidr.size(), _ipv6_cidr);
if (result.ec != std::errc()) {
- TSReleaseAssert(!"Invalid CIDR parameters in HRWBridge");
+ CFatal("[Cripts::Headers] Invalid IPv6 CIDR parameters: %s.", cidr.data());
}
}
@@ -251,7 +251,7 @@ URL::_getComponent(Cript::Url &url)
break;
default:
- TSReleaseAssert(!"Invalid URL component in HRWBridge");
+ CFatal("[Cripts::Headers] Invalid URL component in HRWBridge.");
break;
}
@@ -275,7 +275,7 @@ URL::URL(Type utype, const Cript::string_view &comp) :
super_type("")
} else if (comp == "URL") {
_comp = Component::URL;
} else {
- TSReleaseAssert(!"Invalid URL component in HRWBridge");
+ CFatal("[Cripts::Headers] Invalid URL component in HRWBridge.");
}
}
@@ -320,7 +320,7 @@ URL::value(Cript::Context *context)
} break;
default:
- TSReleaseAssert(!"Invalid URL type in HRWBridge");
+ CFatal("[Cripts::Headers] Invalid URL type in HRWBridge.");
break;
}
diff --git a/src/cripts/Bundles/Headers.cc b/src/cripts/Bundles/Headers.cc
index ddd3ec4d50..c068cd6469 100644
--- a/src/cripts/Bundles/Headers.cc
+++ b/src/cripts/Bundles/Headers.cc
@@ -73,7 +73,7 @@ Headers::rm_headers(const Cript::string_view target, const
HeaderList &headers)
needCallback(Cript::Callbacks::DO_READ_RESPONSE);
break;
default:
- TSReleaseAssert(!"Invalid target for rm_headers()");
+ CFatal("[Cripts::Headers] Unknown header target: %s.", target.data());
}
return *this;
@@ -102,7 +102,7 @@ Headers::set_headers(const Cript::string_view target, const
HeaderValueList &hea
needCallback(Cript::Callbacks::DO_READ_RESPONSE);
break;
default:
- TSReleaseAssert(!"Invalid target for set_headers()");
+ CFatal("[Cripts::Headers] Unknown header target: %s.", target.data());
}
hdrs->reserve(headers.size());
diff --git a/src/cripts/Configs.cc b/src/cripts/Configs.cc
index 0c6dfca2f8..226b1b2f4c 100644
--- a/src/cripts/Configs.cc
+++ b/src/cripts/Configs.cc
@@ -21,68 +21,28 @@
namespace Cript
{
-integer
-IntConfig::_get(Cript::Context *context) const
-{
- integer value = -1;
-
- TSAssert(context->state.txnp);
- if (TSHttpTxnConfigIntGet(context->state.txnp, _key, &value) != TS_SUCCESS) {
- context->state.error.fail();
- }
-
- return value;
-}
-
-void
-IntConfig::_set(Cript::Context *context, integer value)
-{
- TSAssert(context->state.txnp);
- if (TSHttpTxnConfigIntSet(context->state.txnp, _key,
static_cast<TSMgmtInt>(value)) != TS_SUCCESS) {
- context->state.error.fail();
- }
-}
-
-float
-FloatConfig::_get(Cript::Context *context) const
-{
- float value = -1;
- TSAssert(context->state.txnp);
- if (TSHttpTxnConfigFloatGet(context->state.txnp, _key, &value) !=
TS_SUCCESS) {
- context->state.error.fail();
- }
-
- return value;
-}
-
-void
-FloatConfig::_set(Cript::Context *context, float value)
-{
- TSAssert(context->state.txnp);
- if (TSHttpTxnConfigFloatSet(context->state.txnp, _key,
static_cast<TSMgmtFloat>(value)) != TS_SUCCESS) {
- context->state.error.fail();
- }
-}
+std::unordered_map<Cript::string_view, const Records *> Records::_gRecords;
Records::Records(const Cript::string_view name)
{
TSOverridableConfigKey key;
TSRecordDataType type;
- if (TSHttpTxnConfigFind(name.data(), name.size(), &key, &type) !=
TS_SUCCESS) {
- TSError("Invalid configuration variable '%.*s'",
static_cast<int>(name.size()), name.data());
- TSReleaseAssert(!"Invalid configuration variable");
- } else {
+ if (TSHttpTxnConfigFind(name.data(), name.size(), &key, &type) ==
TS_SUCCESS) {
_name = name;
_key = key;
_type = type;
+ } else {
+ CFatal("[Records]: Invalid configuration variable '%.*s'",
static_cast<int>(name.size()), name.data());
}
}
Records::ValueType
Records::_get(const Cript::Context *context) const
{
+ TSAssert(context->state.txnp);
+
switch (_type) {
case TS_RECORDDATATYPE_INT: {
TSMgmtInt i;
@@ -98,25 +58,44 @@ Records::_get(const Cript::Context *context) const
return f;
}
} break;
+ case TS_RECORDDATATYPE_STRING: {
+ return std::string{getSV(context)};
+ } break;
+ default:
+ CFatal("[Records]: Invalid configuration type");
+ return 0;
+ }
+
+ return 0;
+}
+
+const Cript::string_view
+Records::getSV(const Cript::Context *context) const
+{
+ TSAssert(context->state.txnp);
+
+ switch (_type) {
case TS_RECORDDATATYPE_STRING: {
const char *s = nullptr;
int len = 0;
if (TSHttpTxnConfigStringGet(context->state.txnp, _key, &s, &len) ==
TS_SUCCESS) {
- return std::string(s, len);
+ return {s, len};
}
} break;
default:
- TSReleaseAssert(!"Invalid configuration type");
- return 0;
+ CFatal("[Records]: Invalid configuration type for getSV()");
+ break;
}
- return 0;
+ return {};
}
bool
-Records::_set(const Cript::Context *context, const ValueType value)
+Records::_set(const Cript::Context *context, const ValueType &value) const
{
+ TSAssert(context->state.txnp);
+
switch (_type) {
case TS_RECORDDATATYPE_INT: {
TSMgmtInt i = std::get<TSMgmtInt>(value);
@@ -139,18 +118,59 @@ Records::_set(const Cript::Context *context, const
ValueType value)
case TS_RECORDDATATYPE_STRING: {
auto &str = std::get<std::string>(value);
- if (TSHttpTxnConfigStringSet(context->state.txnp, _key, str.c_str(),
str.size()) != TS_SUCCESS) {
+ setSV(context, {str.data(), str.size()});
+ } break;
+ default:
+ CFatal("[Records]: Invalid configuration type");
+ return false;
+ }
+
+ return true; // Success
+}
+
+bool
+Records::setSV(const Cript::Context *context, const Cript::string_view value)
const
+{
+ TSAssert(context->state.txnp);
+
+ switch (_type) {
+ case TS_RECORDDATATYPE_STRING: {
+ if (TSHttpTxnConfigStringSet(context->state.txnp, _key, value.data(),
value.size()) != TS_SUCCESS) {
TSError("Failed to set string configuration '%s'", _name.c_str());
return false;
}
- CDebug("Set string configuration '{}' to '{}'", _name.c_str(),
str.c_str());
+ CDebug("Set string configuration '{}' to '{}'", _name.c_str(), value);
} break;
default:
- TSReleaseAssert(!"Invalid configuration type");
+ CFatal("[Records]: Invalid configuration type for setSV()");
return false;
}
return true; // Success
}
+// Static members for the records "cache"
+void
+Records::add(const Records *rec)
+{
+ CAssert(rec->loaded());
+ auto it = _gRecords.find(rec->name());
+
+ CAssert(it == _gRecords.end());
+ _gRecords[rec->name()] = rec;
+}
+
+const Records *
+Records::lookup(const Cript::string_view name)
+{
+ auto it = _gRecords.find(name);
+
+ if (it != _gRecords.end()) {
+ CAssert(it->second->loaded());
+ return it->second;
+ }
+
+ return nullptr;
+}
+
} // namespace Cript
diff --git a/src/cripts/Connections.cc b/src/cripts/Connections.cc
index 8b7bbd735a..931af5b40c 100644
--- a/src/cripts/Connections.cc
+++ b/src/cripts/Connections.cc
@@ -96,7 +96,7 @@ Cript::IP::hasher(unsigned ipv4_cidr, unsigned ipv6_cidr)
bool
Cript::IP::sample(double rate, uint32_t seed, unsigned ipv4_cidr, unsigned
ipv6_cidr)
{
- TSReleaseAssert(rate >= 0.0 && rate <= 1.0); // For detecting bugs in a
Cript, 0.0 and 1.0 are valid though
+ CAssert(rate >= 0.0 && rate <= 1.0); // For detecting bugs in a Cript, 0.0
and 1.0 are valid though
if (_sampler == 0) {
// This only works until 2038
diff --git a/src/cripts/Crypto.cc b/src/cripts/Crypto.cc
index 8bf36080c2..bf1ef1895f 100644
--- a/src/cripts/Crypto.cc
+++ b/src/cripts/Crypto.cc
@@ -152,8 +152,8 @@ Crypto::detail::Cipher::_initialize()
unsigned char iv[EVP_MAX_IV_LENGTH];
TSAssert(_ctx == nullptr);
- TSReleaseAssert(_cipher != nullptr);
- TSReleaseAssert(_key_len ==
static_cast<int>(EVP_CIPHER_key_length(_cipher))); // Make sure the crypto key
was correct size
+ CAssert(_cipher != nullptr);
+ CAssert(_key_len == static_cast<int>(EVP_CIPHER_key_length(_cipher))); //
Make sure the crypto key was correct size
memset(iv, 0, sizeof(iv)); // The IV is always '0x0'
_ctx = EVP_CIPHER_CTX_new();
diff --git a/src/cripts/Headers.cc b/src/cripts/Headers.cc
index 6f5b5509f8..88b6e77753 100644
--- a/src/cripts/Headers.cc
+++ b/src/cripts/Headers.cc
@@ -318,9 +318,9 @@ Header::iterate()
Client::Response &
Client::Response::_get(Cript::Context *context)
{
- TSReleaseAssert(context->state.hook != TS_HTTP_READ_REQUEST_HDR_HOOK);
- TSReleaseAssert(context->state.hook != TS_HTTP_POST_REMAP_HOOK);
- TSReleaseAssert(context->state.hook != TS_HTTP_SEND_REQUEST_HDR_HOOK);
+ CAssert(context->state.hook != TS_HTTP_READ_REQUEST_HDR_HOOK);
+ CAssert(context->state.hook != TS_HTTP_POST_REMAP_HOOK);
+ CAssert(context->state.hook != TS_HTTP_SEND_REQUEST_HDR_HOOK);
Client::Response *response = &context->_client_resp_header;
@@ -339,10 +339,10 @@ Client::Response::_get(Cript::Context *context)
Server::Request &
Server::Request::_get(Cript::Context *context)
{
- TSReleaseAssert(context->state.hook != TS_HTTP_READ_REQUEST_HDR_HOOK);
- TSReleaseAssert(context->state.hook != TS_HTTP_POST_REMAP_HOOK);
- TSReleaseAssert(context->state.hook != TS_HTTP_CACHE_LOOKUP_COMPLETE_HOOK);
- TSReleaseAssert(context->state.hook != TS_HTTP_READ_RESPONSE_HDR_HOOK);
+ CAssert(context->state.hook != TS_HTTP_READ_REQUEST_HDR_HOOK);
+ CAssert(context->state.hook != TS_HTTP_POST_REMAP_HOOK);
+ CAssert(context->state.hook != TS_HTTP_CACHE_LOOKUP_COMPLETE_HOOK);
+ CAssert(context->state.hook != TS_HTTP_READ_RESPONSE_HDR_HOOK);
Server::Request *request = &context->_server_req_header;
@@ -361,10 +361,10 @@ Server::Request::_get(Cript::Context *context)
Server::Response &
Server::Response::_get(Cript::Context *context)
{
- TSReleaseAssert(context->state.hook != TS_HTTP_READ_REQUEST_HDR_HOOK);
- TSReleaseAssert(context->state.hook != TS_HTTP_POST_REMAP_HOOK);
- TSReleaseAssert(context->state.hook != TS_HTTP_CACHE_LOOKUP_COMPLETE_HOOK);
- TSReleaseAssert(context->state.hook != TS_HTTP_SEND_REQUEST_HDR_HOOK);
+ CAssert(context->state.hook != TS_HTTP_READ_REQUEST_HDR_HOOK);
+ CAssert(context->state.hook != TS_HTTP_POST_REMAP_HOOK);
+ CAssert(context->state.hook != TS_HTTP_CACHE_LOOKUP_COMPLETE_HOOK);
+ CAssert(context->state.hook != TS_HTTP_SEND_REQUEST_HDR_HOOK);
Server::Response *response = &context->_server_resp_header;
diff --git a/src/cripts/Matcher.cc b/src/cripts/Matcher.cc
index 77e6246d1f..67ec165f61 100644
--- a/src/cripts/Matcher.cc
+++ b/src/cripts/Matcher.cc
@@ -34,7 +34,7 @@ Matcher::PCRE::Result::malloc(PCRE2_SIZE size, void *context)
auto *result = static_cast<Result *>(context);
std::byte *ret = result->_ctx_data + result->_ctx_ix;
- TSReleaseAssert(size < (sizeof(result->_ctx_data) - result->_ctx_ix));
+ CAssert(size < (sizeof(result->_ctx_data) - result->_ctx_ix));
result->_ctx_ix += size;
return ret;
@@ -52,13 +52,11 @@ Matcher::PCRE::add(Cript::string_view regex, uint32_t
options, bool jit)
PCRE2_UCHAR error[256];
pcre2_get_error_message(errorcode, error, sizeof(error));
- TSError("PCRE compile error `%s': %.*s", error,
static_cast<int>(regex.length()), regex.data());
- TSReleaseAssert(!"Failed to compile regex");
+ CFatal("[Matcher::PCRE]: PCRE compile error `%s': %.*s", error,
static_cast<int>(regex.length()), regex.data());
} else {
if (jit) {
if (0 != pcre2_jit_compile(re, PCRE2_JIT_COMPLETE)) {
- TSError("PCRE JIT compile error: %.*s",
static_cast<int>(regex.length()), regex.data());
- TSReleaseAssert(!"Failed to JIT compile regex");
+ CFatal("[Matcher::PCRE]: PCRE JIT compile error: %.*s",
static_cast<int>(regex.length()), regex.data());
}
}
_regexes.emplace_back(regex, re);
diff --git a/src/cripts/Urls.cc b/src/cripts/Urls.cc
index bbe25f10ec..d9108c9d36 100644
--- a/src/cripts/Urls.cc
+++ b/src/cripts/Urls.cc
@@ -43,7 +43,7 @@ Cript::Url::Scheme::getSV()
Cript::Url::Scheme
Cript::Url::Scheme::operator=(Cript::string_view scheme)
{
- TSReleaseAssert(!_owner->readOnly()); // This can not be a read-only URL
+ CAssert(!_owner->readOnly()); // This can not be a read-only URL
TSUrlSchemeSet(_owner->_bufp, _owner->_urlp, scheme.data(), scheme.size());
_owner->_modified = true;
reset();
@@ -70,7 +70,7 @@ Cript::Url::Host::getSV()
Cript::Url::Host
Cript::Url::Host::operator=(Cript::string_view host)
{
- TSReleaseAssert(!_owner->readOnly()); // This can not be a read-only URL
+ CAssert(!_owner->readOnly()); // This can not be a read-only URL
TSUrlHostSet(_owner->_bufp, _owner->_urlp, host.data(), host.size());
_owner->_modified = true;
reset();
@@ -91,7 +91,7 @@ Cript::Url::Port::operator integer() // This should not be
explicit
Cript::Url::Port
Cript::Url::Port::operator=(int port)
{
- TSReleaseAssert(!_owner->readOnly()); // This can not be a read-only URL
+ CAssert(!_owner->readOnly()); // This can not be a read-only URL
TSUrlPortSet(_owner->_bufp, _owner->_urlp, port);
_owner->_modified = true;
reset();
@@ -142,7 +142,7 @@ Cript::Url::Path::operator[](Segments::size_type ix)
Cript::Url::Path
Cript::Url::Path::operator=(Cript::string_view path)
{
- TSReleaseAssert(!_owner->readOnly()); // This can not be a read-only URL
+ CAssert(!_owner->readOnly()); // This can not be a read-only URL
TSUrlPathSet(_owner->_bufp, _owner->_urlp, path.data(), path.size());
_owner->_modified = true;
reset();
@@ -168,7 +168,7 @@ Cript::Url::Path::operator+=(Cript::string_view add)
Cript::Url::Path::String &
Cript::Url::Path::String::operator=(const Cript::string_view str)
{
- TSReleaseAssert(!_owner->_owner->readOnly()); // This can not be a read-only
URL
+ CAssert(!_owner->_owner->readOnly()); // This can not be a read-only URL
_owner->_size -= _owner->_segments[_ix].size();
_owner->_segments[_ix] = str;
_owner->_size += str.size();
@@ -215,7 +215,7 @@ Cript::Url::Path::_parser()
Cript::Url::Query::Parameter &
Cript::Url::Query::Parameter::operator=(const Cript::string_view str)
{
- TSReleaseAssert(!_owner->_owner->readOnly()); // This can not be a read-only
URL
+ CAssert(!_owner->_owner->readOnly()); // This can not be a read-only URL
auto iter = _owner->_hashed.find(_name);
if (iter != _owner->_hashed.end()) {
@@ -275,7 +275,7 @@ Cript::Url::Query::getSV()
Cript::Url::Query
Cript::Url::Query::operator=(Cript::string_view query)
{
- TSReleaseAssert(!_owner->readOnly()); // This can not be a read-only URL
+ CAssert(!_owner->readOnly()); // This can not be a read-only URL
TSUrlHttpQuerySet(_owner->_bufp, _owner->_urlp, query.data(), query.size());
_owner->_modified = true;
reset();
@@ -329,7 +329,7 @@ Cript::Url::Query::erase(Cript::string_view param)
_size -= iter->second.size(); // Size of the erased value
_hashed.erase(iter);
- TSReleaseAssert(viter != _ordered.end());
+ CAssert(viter != _ordered.end());
_size -= viter->size(); // Length of the erased key
_ordered.erase(viter);
@@ -351,7 +351,7 @@
Cript::Url::Query::erase(std::initializer_list<Cript::string_view> list, bool ke
if (list.end() == std::find(list.begin(), list.end(), *viter)) {
auto iter = _hashed.find(*viter);
- TSReleaseAssert(iter != _hashed.end());
+ CAssert(iter != _hashed.end());
_size -= iter->second.size(); // Size of the erased value
_size -= viter->size(); // Length of the erased key
_hashed.erase(iter);
@@ -420,7 +420,7 @@ Cript::Url::Matrix::getSV()
Cript::Url::Matrix
Cript::Url::Matrix::operator=(Cript::string_view matrix)
{
- TSReleaseAssert(!_owner->readOnly()); // This can not be a read-only URL
+ CAssert(!_owner->readOnly()); // This can not be a read-only URL
TSUrlHttpParamsSet(_owner->_bufp, _owner->_urlp, matrix.data(),
matrix.size());
_owner->_modified = true;
reset();
diff --git a/tools/cripts/genconfig.py b/tools/cripts/genconfig.py
index 34bb4b2031..579867f676 100755
--- a/tools/cripts/genconfig.py
+++ b/tools/cripts/genconfig.py
@@ -79,13 +79,11 @@ def print_class(tree, cur="", indent=0):
indentp("public:", indent - 1)
firstInstance = False
if tree[k][1] == "TS_RECORDDATATYPE_INT":
- indentp("Cript::IntConfig {}{{{}}};".format(k, tree[k][0]),
indent)
+ indentp("Cript::IntConfig {}{{\"{}\"}};".format(k,
tree[k][2]), indent)
elif tree[k][1] == "TS_RECORDDATATYPE_FLOAT":
- indentp("Cript::FloatConfig {}{{{}}};".format(k, tree[k][0]),
indent)
+ indentp("Cript::FloatConfig {}{{\"{}\"}};".format(k,
tree[k][2]), indent)
elif tree[k][1] == "TS_RECORDDATATYPE_STRING":
- pass
- # ToDo: Support strings somehow??
- # indentp("StringConfig {}{{{}}};".format(k, tree[k][0]),
indent + 1)
+ indentp("Cript::StringConfig {}{{\"{}\"}};".format(k,
tree[k][2]), indent)
else:
print("The source file has a bad configuration data type:
{}".format(tree[k][1]))
if cur:
@@ -112,7 +110,6 @@ while i < len(lines):
conf = conf.strip(" {\"").rstrip("\" ")
enum = enum.strip(" {")
type = type.strip(" ").rstrip(",}); ")
- # parts = conf.split(".")
elements.append((conf, enum, type))
i += 1
@@ -120,13 +117,14 @@ tree = {}
elements.sort()
for elem in elements:
cur = tree
+ name = elem[0]
parts = elem[0].split(".")
size = len(parts) - 1
for ix, part in enumerate(parts):
sub = cur.get(part)
if sub is None:
if ix == size:
- cur[part] = (elem[1], elem[2])
+ cur[part] = (elem[1], elem[2], name)
else:
cur[part] = {}
cur = cur[part]
