From 025ca487cf016c279d822372993e1704d06cd50d Mon Sep 17 00:00:00 2001 From: famfo Date: Sat, 31 May 2025 19:15:39 +0200 Subject: [feature/internal/httpclient] add option to configure outgoing protocol (#4134) # Description Adds a configuration option to set the outgoing transport of HTTP requests for testing purposes. ## Checklist - [x] I/we have read the [GoToSocial contribution guidelines](https://codeberg.org/superseriousbusiness/gotosocial/src/branch/main/CONTRIBUTING.md). - [ ] I/we have discussed the proposed changes already, either in an issue on the repository, or in the Matrix chat. - [x] I/we have not leveraged AI to create the proposed changes. - [x] I/we have performed a self-review of added code. - [x] I/we have written code that is legible and maintainable by others. - [ ] I/we have commented the added code, particularly in hard-to-understand areas. - [x] I/we have made any necessary changes to documentation. - [ ] I/we have added tests that cover new code. - [ ] I/we have run tests and they pass locally with the changes. - [ ] I/we have run `go fmt ./...` and `golangci-lint run`. - Note: `go fmt` yes, golangci-lint fails, can't load any configuration Reviewed-on: https://codeberg.org/superseriousbusiness/gotosocial/pulls/4134 Reviewed-by: kim Co-authored-by: famfo Co-committed-by: famfo --- internal/config/helpers.gen.go | 46 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 46 insertions(+) (limited to 'internal/config/helpers.gen.go') diff --git a/internal/config/helpers.gen.go b/internal/config/helpers.gen.go index e710a9dc2..dd584e2f0 100644 --- a/internal/config/helpers.gen.go +++ b/internal/config/helpers.gen.go @@ -150,6 +150,7 @@ func (cfg *Configuration) RegisterFlags(flags *pflag.FlagSet) { flags.StringSlice("http-client-block-ips", cfg.HTTPClient.BlockIPs, "") flags.Duration("http-client-timeout", cfg.HTTPClient.Timeout, "") flags.Bool("http-client-tls-insecure-skip-verify", cfg.HTTPClient.TLSInsecureSkipVerify, "") + flags.Bool("http-client-insecure-outgoing", cfg.HTTPClient.InsecureOutgoing, "") flags.String("cache-memory-target", cfg.Cache.MemoryTarget.String(), "") flags.Float64("cache-account-mem-ratio", cfg.Cache.AccountMemRatio, "") flags.Float64("cache-account-note-mem-ratio", cfg.Cache.AccountNoteMemRatio, "") @@ -333,6 +334,7 @@ func (cfg *Configuration) MarshalMap() map[string]any { cfgmap["http-client-block-ips"] = cfg.HTTPClient.BlockIPs cfgmap["http-client-timeout"] = cfg.HTTPClient.Timeout cfgmap["http-client-tls-insecure-skip-verify"] = cfg.HTTPClient.TLSInsecureSkipVerify + cfgmap["http-client-insecure-outgoing"] = cfg.HTTPClient.InsecureOutgoing cfgmap["cache-memory-target"] = cfg.Cache.MemoryTarget.String() cfgmap["cache-account-mem-ratio"] = cfg.Cache.AccountMemRatio cfgmap["cache-account-note-mem-ratio"] = cfg.Cache.AccountNoteMemRatio @@ -1406,6 +1408,14 @@ func (cfg *Configuration) UnmarshalMap(cfgmap map[string]any) error { } } + if ival, ok := cfgmap["http-client-insecure-outgoing"]; ok { + var err error + cfg.HTTPClient.InsecureOutgoing, err = cast.ToBoolE(ival) + if err != nil { + return fmt.Errorf("error casting %#v -> bool for 'http-client-insecure-outgoing': %w", ival, err) + } + } + if ival, ok := cfgmap["cache-memory-target"]; ok { t, err := cast.ToStringE(ival) if err != nil { @@ -4969,6 +4979,31 @@ func GetHTTPClientTLSInsecureSkipVerify() bool { return global.GetHTTPClientTLSI // SetHTTPClientTLSInsecureSkipVerify safely sets the value for global configuration 'HTTPClient.TLSInsecureSkipVerify' field func SetHTTPClientTLSInsecureSkipVerify(v bool) { global.SetHTTPClientTLSInsecureSkipVerify(v) } +// HTTPClientInsecureOutgoingFlag returns the flag name for the 'HTTPClient.InsecureOutgoing' field +func HTTPClientInsecureOutgoingFlag() string { return "http-client-insecure-outgoing" } + +// GetHTTPClientInsecureOutgoing safely fetches the Configuration value for state's 'HTTPClient.InsecureOutgoing' field +func (st *ConfigState) GetHTTPClientInsecureOutgoing() (v bool) { + st.mutex.RLock() + v = st.config.HTTPClient.InsecureOutgoing + st.mutex.RUnlock() + return +} + +// SetHTTPClientInsecureOutgoing safely sets the Configuration value for state's 'HTTPClient.InsecureOutgoing' field +func (st *ConfigState) SetHTTPClientInsecureOutgoing(v bool) { + st.mutex.Lock() + defer st.mutex.Unlock() + st.config.HTTPClient.InsecureOutgoing = v + st.reloadToViper() +} + +// GetHTTPClientInsecureOutgoing safely fetches the value for global configuration 'HTTPClient.InsecureOutgoing' field +func GetHTTPClientInsecureOutgoing() bool { return global.GetHTTPClientInsecureOutgoing() } + +// SetHTTPClientInsecureOutgoing safely sets the value for global configuration 'HTTPClient.InsecureOutgoing' field +func SetHTTPClientInsecureOutgoing(v bool) { global.SetHTTPClientInsecureOutgoing(v) } + // CacheMemoryTargetFlag returns the flag name for the 'Cache.MemoryTarget' field func CacheMemoryTargetFlag() string { return "cache-memory-target" } @@ -6849,6 +6884,17 @@ func flattenConfigMap(cfgmap map[string]any) { } } + for _, key := range [][]string{ + {"http-client", "insecure-outgoing"}, + } { + ival, ok := mapGet(cfgmap, key...) + if ok { + cfgmap["http-client-insecure-outgoing"] = ival + nestedKeys[key[0]] = struct{}{} + break + } + } + for _, key := range [][]string{ {"cache", "memory-target"}, } { -- cgit v1.2.3