diff --git a/srcpkgs/consul-template/patches/nomad-namespace-queries.patch b/srcpkgs/consul-template/patches/nomad-namespace-queries.patch new file mode 100644 index 00000000000000..eafdc2e8f1c26c --- /dev/null +++ b/srcpkgs/consul-template/patches/nomad-namespace-queries.patch @@ -0,0 +1,408 @@ +From dbddbbc5a4d87c19a7c08a93d9af3e205617345d Mon Sep 17 00:00:00 2001 +From: Tim Gross +Date: Wed, 2 Sep 2026 16:28:09 -0400 +Subject: [PATCH] support cross-namespace Nomad service queries + +Add support in the Nomad service(s) dependencies for including a Nomad namespace +in the queries. The syntax for this matches the namespace syntax of the existing +Consul service queries. The `nomadServices` query will also support wildcard +namespaces. + +Fixes: https://github.com/hashicorp/consul-template/issues/2072 +Ref: https://hashicorp.atlassian.net/browse/NMD-920 +Ref: https://github.com/hashicorp/nomad/issues/14177 +--- + dependency/dependency.go | 32 ++++++++-------- + dependency/nomad_service.go | 29 ++++++++------ + dependency/nomad_service_test.go | 51 +++++++++++++++++++++++++ + dependency/nomad_services.go | 63 +++++++++++++++++++------------ + dependency/nomad_services_test.go | 59 ++++++++++++++++++++++++++++- + 7 files changed, 230 insertions(+), 60 deletions(-) + +diff --git a/dependency/dependency.go b/dependency/dependency.go +index 4a9a7f473..bfa180aed 100644 +--- a/dependency/dependency.go ++++ b/dependency/dependency.go +@@ -16,21 +16,23 @@ import ( + ) + + const ( +- dcRe = `(@(?P[[:word:]\.\-\_]+))?` +- keyRe = `/?(?P[^@\?]+)` +- filterRe = `(\|(?P[[:word:]\,]+))?` +- serviceNameRe = `(?P[[:word:]\-\_]+)` +- queryRe = `(\?(?P[[:word:]\-\_\=\&]+))?` +- nodeNameRe = `(?P[[:word:]\.\-\_]+)` +- nearRe = `(~(?P[[:word:]\.\-\_]+))?` +- prefixRe = `/?(?P[^@\?]+)` +- tagRe = `((?P[[:word:]=:\.\-\_]+)\.)?` +- regionRe = `(@(?P[[:word:]\.\-\_]+))?` +- nvPathRe = `/?(?P[^@]+)` +- nvNamespaceRe = `(@(?P[[:word:]\-\_]+))?` +- nvListPrefixRe = `/?(?P[^@]*)` +- nvListNSRe = `(@(?P([[:word:]\-\_]+|\*)))?` +- nvRegionRe = `(\.(?P[[:word:]\-\_]+))?` ++ dcRe = `(@(?P[[:word:]\.\-\_]+))?` ++ keyRe = `/?(?P[^@\?]+)` ++ filterRe = `(\|(?P[[:word:]\,]+))?` ++ serviceNameRe = `(?P[[:word:]\-\_]+)` ++ queryRe = `(\?(?P[[:word:]\-\_\=\&]+))?` ++ nodeNameRe = `(?P[[:word:]\.\-\_]+)` ++ nearRe = `(~(?P[[:word:]\.\-\_]+))?` ++ prefixRe = `/?(?P[^@\?]+)` ++ tagRe = `((?P[[:word:]=:\.\-\_]+)\.)?` ++ regionRe = `(@(?P[[:word:]\.\-\_]+))?` ++ nomadNamespaceRe = `(\?ns=(?P[a-zA-Z0-9\-]{1,128}))?` ++ nomadNamespaceWildcardRe = `(\?ns=(?P([a-zA-Z0-9\-]{1,128}|\*)))?` ++ nvPathRe = `/?(?P[^@]+)` ++ nvNamespaceRe = `(@(?P[[:word:]\-\_]+))?` ++ nvListPrefixRe = `/?(?P[^@]*)` ++ nvListNSRe = `(@(?P([[:word:]\-\_]+|\*)))?` ++ nvRegionRe = `(\.(?P[[:word:]\-\_]+))?` + + DefaultNonBlockingQuerySleepTime = 15 * time.Second + ) +diff --git a/dependency/nomad_service.go b/dependency/nomad_service.go +index c0efec78a..ecfaa8630 100644 +--- a/dependency/nomad_service.go ++++ b/dependency/nomad_service.go +@@ -21,8 +21,8 @@ var ( + // NomadServiceQueryRe is the regex that is used to understand a service + // specific Nomad query. + // +- // e.g. ".@" +- NomadServiceQueryRe = regexp.MustCompile(`\A` + tagRe + serviceNameRe + regionRe + `\z`) ++ // e.g. ".@" ++ NomadServiceQueryRe = regexp.MustCompile(`\A` + tagRe + serviceNameRe + nomadNamespaceRe + regionRe + `\z`) + ) + + func init() { +@@ -48,10 +48,11 @@ type NomadService struct { + type NomadServiceQuery struct { + stopCh chan struct{} + +- region string +- name string +- tag string +- choose string ++ region string ++ name string ++ namespace string ++ tag string ++ choose string + } + + // NewNomadServiceQuery parses a string into a NomadServiceQuery which is +@@ -64,10 +65,11 @@ func NewNomadServiceQuery(s string) (*NomadServiceQuery, error) { + m := regexpMatch(NomadServiceQueryRe, s) + + return &NomadServiceQuery{ +- stopCh: make(chan struct{}, 1), +- region: m["region"], +- name: m["name"], +- tag: m["tag"], ++ stopCh: make(chan struct{}, 1), ++ region: m["region"], ++ name: m["name"], ++ namespace: m["namespace"], ++ tag: m["tag"], + }, nil + } + +@@ -107,7 +109,9 @@ func (d *NomadServiceQuery) Fetch(client *ClientSet, opts *QueryOptions) (interf + + log.Printf("[TRACE] %s: GET %s", d, u) + +- entries, qm, err := client.Nomad().Services().Get(d.name, opts.ToNomadOpts()) ++ nOpts := opts.ToNomadOpts() ++ nOpts.Namespace = d.namespace ++ entries, qm, err := client.Nomad().Services().Get(d.name, nOpts) + if err != nil { + return nil, nil, errors.Wrap(err, d.String()) + } +@@ -158,6 +162,9 @@ func (d *NomadServiceQuery) String() string { + if d.tag != "" { + name = d.tag + "." + name + } ++ if d.namespace != "" { ++ name = name + "?ns=" + d.namespace ++ } + if d.region != "" { + name = name + "@" + d.region + } +diff --git a/dependency/nomad_service_test.go b/dependency/nomad_service_test.go +index d427cd888..42f5a1e5f 100644 +--- a/dependency/nomad_service_test.go ++++ b/dependency/nomad_service_test.go +@@ -81,6 +81,42 @@ func TestNewNomadServiceQuery(t *testing.T) { + }, + false, + }, ++ { ++ "name_namespace", ++ "myservice?ns=foo", ++ &NomadServiceQuery{ ++ name: "myservice", ++ namespace: "foo", ++ }, ++ false, ++ }, ++ { ++ "name_namespace_region", ++ "myservice?ns=foo@us-east-1", ++ &NomadServiceQuery{ ++ region: "us-east-1", ++ name: "myservice", ++ namespace: "foo", ++ }, ++ false, ++ }, ++ { ++ "tag_name_namespace_region", ++ "tag.myservice?ns=foo@us-east-1", ++ &NomadServiceQuery{ ++ region: "us-east-1", ++ name: "myservice", ++ namespace: "foo", ++ tag: "tag", ++ }, ++ false, ++ }, ++ { ++ "namespace_only", ++ "?ns=foo", ++ nil, ++ true, ++ }, + } + + for i, tc := range cases { +@@ -275,6 +311,21 @@ func TestNomadServiceQuery_String(t *testing.T) { + "tag.name@us-east-1", + "nomad.service(tag.name@us-east-1)", + }, ++ { ++ "name_namespace", ++ "myservice?ns=foo", ++ "nomad.service(myservice?ns=foo)", ++ }, ++ { ++ "name_namespace_region", ++ "myservice?ns=foo@us-east-1", ++ "nomad.service(myservice?ns=foo@us-east-1)", ++ }, ++ { ++ "tag_name_namespace_region", ++ "tag.myservice?ns=foo@us-east-1", ++ "nomad.service(tag.myservice?ns=foo@us-east-1)", ++ }, + } + + for i, tc := range cases { +diff --git a/dependency/nomad_services.go b/dependency/nomad_services.go +index 97c15dd4d..0bc9ccbdb 100644 +--- a/dependency/nomad_services.go ++++ b/dependency/nomad_services.go +@@ -11,7 +11,6 @@ import ( + "regexp" + "sort" + +- nomadapi "github.com/hashicorp/nomad/api" + "github.com/pkg/errors" + ) + +@@ -21,7 +20,9 @@ var ( + + // NomadServicesQueryRe is the regex that is used to understand a service + // listing Nomad query. +- NomadServicesQueryRe = regexp.MustCompile(`\A` + regionRe + `\z`) ++ // ++ // e.g. "@", namespace may also be the wildcard "*" ++ NomadServicesQueryRe = regexp.MustCompile(`\A` + nomadNamespaceWildcardRe + regionRe + `\z`) + ) + + func init() { +@@ -30,8 +31,9 @@ func init() { + + // NomadServicesSnippet is a stub service entry in Nomad. + type NomadServicesSnippet struct { +- Name string +- Tags ServiceTags ++ Name string ++ Namespace string ++ Tags ServiceTags + } + + // nomadSortableSnippet is a sortable slice of NomadServicesSnippet structs. +@@ -46,7 +48,8 @@ func (s nomadSortableSnippet) Less(i, j int) bool { return s[i].Name < s[j].Name + type NomadServicesQuery struct { + stopCh chan struct{} + +- region string ++ region string ++ namespace string + } + + // NewNomadServicesQuery parses a string into a NomadServicesQuery which is +@@ -58,8 +61,9 @@ func NewNomadServicesQuery(s string) (*NomadServicesQuery, error) { + + m := regexpMatch(NomadServicesQueryRe, s) + return &NomadServicesQuery{ +- stopCh: make(chan struct{}, 1), +- region: m["region"], ++ stopCh: make(chan struct{}, 1), ++ region: m["region"], ++ namespace: m["namespace"], + }, nil + } + +@@ -86,28 +90,32 @@ func (d *NomadServicesQuery) Fetch(clients *ClientSet, opts *QueryOptions) (inte + RawQuery: opts.String(), + }) + +- namespaces, qm, err := clients.Nomad().Services().List(opts.ToNomadOpts()) ++ nOpts := opts.ToNomadOpts() ++ nOpts.Namespace = d.namespace ++ listStubs, qm, err := clients.Nomad().Services().List(nOpts) + if err != nil { + return nil, nil, errors.Wrap(err, d.String()) + } + +- // Cross namespaces queries aren't allowed via consul-template, so only +- // the namespace the client is configured for will be returned. +- var entries []*nomadapi.ServiceRegistrationStub +- if len(namespaces) > 0 { +- entries = namespaces[0].Services +- } +- +- log.Printf("[TRACE] %s: returned %d results", d, len(entries)) +- +- services := make([]*NomadServicesSnippet, len(entries)) +- for i, s := range entries { +- services[i] = &NomadServicesSnippet{ +- Name: s.ServiceName, +- Tags: deepCopyAndSortTags(s.Tags), ++ // The List API returns one entry per namespace. Flatten all namespace ++ // entries into a single slice (there will be more than one when the ++ // wildcard namespace "*" is used). ++ services := []*NomadServicesSnippet{} ++ ++ // var entries []*nomadapi.ServiceRegistrationStub ++ for _, listStub := range listStubs { ++ for _, s := range listStub.Services { ++ services = append(services, ++ &NomadServicesSnippet{ ++ Name: s.ServiceName, ++ Namespace: listStub.Namespace, ++ Tags: deepCopyAndSortTags(s.Tags), ++ }) + } + } + ++ log.Printf("[TRACE] %s: returned %d results", d, len(services)) ++ + sort.Stable(nomadSortableSnippet(services)) + + rm := &ResponseMetadata{ +@@ -120,8 +128,15 @@ func (d *NomadServicesQuery) Fetch(clients *ClientSet, opts *QueryOptions) (inte + + // String returns the human-friendly version of this dependency. + func (d *NomadServicesQuery) String() string { +- if d.region != "" { +- return fmt.Sprintf("nomad.services(@%s)", d.region) ++ if d.namespace != "" || d.region != "" { ++ ns, region := "", "" ++ if d.namespace != "" { ++ ns = "?ns=" + d.namespace ++ } ++ if d.region != "" { ++ region = "@" + d.region ++ } ++ return fmt.Sprintf("nomad.services(%s%s)", ns, region) + } + return "nomad.services" + } +diff --git a/dependency/nomad_services_test.go b/dependency/nomad_services_test.go +index cca70d91c..db2fe40c4 100644 +--- a/dependency/nomad_services_test.go ++++ b/dependency/nomad_services_test.go +@@ -37,6 +37,40 @@ func TestNewNomadServicesQueryQuery(t *testing.T) { + }, + false, + }, ++ { ++ "namespace", ++ "?ns=foo", ++ &NomadServicesQuery{ ++ namespace: "foo", ++ }, ++ false, ++ }, ++ { ++ "namespace_region", ++ "?ns=foo@us-east-1", ++ &NomadServicesQuery{ ++ region: "us-east-1", ++ namespace: "foo", ++ }, ++ false, ++ }, ++ { ++ "wildcard_namespace", ++ "?ns=*", ++ &NomadServicesQuery{ ++ namespace: "*", ++ }, ++ false, ++ }, ++ { ++ "wildcard_namespace_region", ++ "?ns=*@us-east-1", ++ &NomadServicesQuery{ ++ region: "us-east-1", ++ namespace: "*", ++ }, ++ false, ++ }, + } + + for i, tc := range cases { +@@ -66,8 +100,9 @@ func TestNomadServicesQuery_Fetch_1arg(t *testing.T) { + service: "", + exp: []*NomadServicesSnippet{ + { +- Name: "example-cache", +- Tags: ServiceTags([]string{"tag1", "tag2"}), ++ Name: "example-cache", ++ Namespace: "default", ++ Tags: ServiceTags([]string{"tag1", "tag2"}), + }, + }, + }, +@@ -106,6 +141,26 @@ func TestNomadServicesQuery_String(t *testing.T) { + "@us-east-1", + "nomad.services(@us-east-1)", + }, ++ { ++ "namespace", ++ "?ns=foo", ++ "nomad.services(?ns=foo)", ++ }, ++ { ++ "namespace_region", ++ "?ns=foo@us-east-1", ++ "nomad.services(?ns=foo@us-east-1)", ++ }, ++ { ++ "wildcard_namespace", ++ "?ns=*", ++ "nomad.services(?ns=*)", ++ }, ++ { ++ "wildcard_namespace_region", ++ "?ns=*@us-east-1", ++ "nomad.services(?ns=*@us-east-1)", ++ }, + } + + for i, tc := range cases { diff --git a/srcpkgs/consul-template/template b/srcpkgs/consul-template/template index defc35ae997617..4e836e298eb75f 100644 --- a/srcpkgs/consul-template/template +++ b/srcpkgs/consul-template/template @@ -1,14 +1,14 @@ # Template file for 'consul-template' pkgname=consul-template -version=0.42.1 +version=0.43.1 revision=1 build_style=go go_import_path="github.com/hashicorp/consul-template" short_desc="Template rendering, notifier, and supervisor for Consul and Vault data" -maintainer="Orphaned " +maintainer="Gabriel M. Dutra " license="MPL-2.0" homepage="https://github.com/hashicorp/consul-template" -distfiles="$homepage/archive/v$version.tar.gz" -checksum=def64b66c47dd38d98e37bfa1b571584ed9ab5f98be0dce09304c68b7ac966eb +distfiles="https://github.com/hashicorp/consul-template/archive/v$version.tar.gz" +checksum=97c588a368c49e0478a65337a65b97031affb8a718446a4486759c1d3da6202d # consul-template has integration tests that rely on pre-existing substrate, vault, consul and syslog server make_check=no