You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@dubbo.apache.org by xu...@apache.org on 2026/04/27 03:25:03 UTC
(dubbo-go-pixiu) branch develop updated: use hot reload update gateway (#892)
This is an automated email from the ASF dual-hosted git repository.
Alanxtl pushed a commit to branch develop
in repository https://gitbox.apache.org/repos/asf/dubbo-go-pixiu.git
The following commit(s) were added to refs/heads/develop by this push:
new ad9b844e use hot reload update gateway (#892)
ad9b844e is described below
commit ad9b844e2d1dfe9528d9efbbc9f60d89c04da553
Author: Joe Zhong <11...@qq.com>
AuthorDate: Mon Apr 27 11:24:58 2026 +0800
use hot reload update gateway (#892)
* use hot reload update gateway
fix gofmt
fix imports-formatter
fix golangci-lint
fix typo
fix typo
fix gofmt
fix imports-formatter
chore: trigger CI to recheck linter
fix: rewrite http_handler to fix gofmt issue
fix: split variable declaration to fix gofmt issue
fix: inline map to avoid gofmt issue
fix: apply gofmt formatting to http_handler.go
fix: replace interface{} with string map and handle Body.Close error
fix: guard against nil server in GetRouterManager to prevent panic in tests
* Potential fix for pull request finding
Co-authored-by: Copilot Autofix powered by AI <17...@users.noreply.github.com>
* build(deps): bump minimatch from 3.1.2 to 3.1.5 in /admin/web (#883)
Bumps [minimatch](https://github.com/isaacs/minimatch) from 3.1.2 to 3.1.5.
- [Changelog](https://github.com/isaacs/minimatch/blob/main/changelog.md)
- [Commits](https://github.com/isaacs/minimatch/compare/v3.1.2...v3.1.5)
---
updated-dependencies:
- dependency-name: minimatch
dependency-version: 3.1.5
dependency-type: indirect
...
Signed-off-by: dependabot[bot] <su...@github.com>
Co-authored-by: dependabot[bot] <49...@users.noreply.github.com>
* Admin opa backend (#877)
* add the OPA on the admin without readme
* fmt
* add the description of change in readme
* remove the log
* fix the issue
* fix the issue
* delete the log and improve the yml of docker
* remove the redundent -
* add the newLine
* fix(admin): honor OPA request timeout with context and add 30s fallback
* build(deps): bump go.opentelemetry.io/otel/sdk in /controllers (#887)
Bumps [go.opentelemetry.io/otel/sdk](https://github.com/open-telemetry/opentelemetry-go) from 1.37.0 to 1.40.0.
- [Release notes](https://github.com/open-telemetry/opentelemetry-go/releases)
- [Changelog](https://github.com/open-telemetry/opentelemetry-go/blob/main/CHANGELOG.md)
- [Commits](https://github.com/open-telemetry/opentelemetry-go/compare/v1.37.0...v1.40.0)
---
updated-dependencies:
- dependency-name: go.opentelemetry.io/otel/sdk
dependency-version: 1.40.0
dependency-type: indirect
...
Signed-off-by: dependabot[bot] <su...@github.com>
Co-authored-by: dependabot[bot] <49...@users.noreply.github.com>
* feat: Add KVCache offload funtion in PIXIU gateway (#878)
* feat: KV Cache
* fix: fix some problems
* feat: add KVCache feats
* feat: v2
* feat: v2
* chore: ignore .worktrees
* fix: fix some bugs
* feat: v3
* feat: v4
* feat: fix some problems
* fix: delete some unuesd gomod
* fix: fix some problems
* fix: fix some problems
* add apache lisences
* fix: fix some problems
* fix: add unit test and fix some problems
* fix: delete some unused code
* fix: add docs
* feat: add some new features
* build(deps): bump go.opentelemetry.io/otel/sdk from 1.21.0 to 1.40.0 (#890)
Bumps [go.opentelemetry.io/otel/sdk](https://github.com/open-telemetry/opentelemetry-go) from 1.21.0 to 1.40.0.
- [Release notes](https://github.com/open-telemetry/opentelemetry-go/releases)
- [Changelog](https://github.com/open-telemetry/opentelemetry-go/blob/main/CHANGELOG.md)
- [Commits](https://github.com/open-telemetry/opentelemetry-go/compare/v1.21.0...v1.40.0)
---
updated-dependencies:
- dependency-name: go.opentelemetry.io/otel/sdk
dependency-version: 1.40.0
dependency-type: direct:production
...
Signed-off-by: dependabot[bot] <su...@github.com>
Co-authored-by: dependabot[bot] <49...@users.noreply.github.com>
* feat(auth/saml): add SAML authentication filter (#893)
* feat(auth/saml): add initial SAML auth filter scaffold
* feat(auth/saml): implement core SAML authentication logic
* test(auth/saml): add unit tests for SAML filter
* fix(auth/saml): address code review findings
- Distinguish ErrNoSession from other session errors in Decode()
- DeepCopy config in PrepareFilterChain to avoid pointer sharing
- Strip client-supplied SAML-controlled headers to prevent spoofing
- Set CookieSameSite for cross-site ACS POST compatibility
- Fix gofmt formatting in config_test.go
* docs(auth/saml): add SAML filter user documentation
* chore: revert .gitignore to upstream state
* style: format plugin registry
* refactor(auth/saml): reduce Apply complexity
* style(auth/saml): format imports with imports-formatter
* docs(auth/saml): add Chinese user guide
* build(deps): bump github.com/buger/jsonparser in /tools/benchmark (#898)
Bumps [github.com/buger/jsonparser](https://github.com/buger/jsonparser) from 1.1.1 to 1.1.2.
- [Release notes](https://github.com/buger/jsonparser/releases)
- [Commits](https://github.com/buger/jsonparser/compare/v1.1.1...v1.1.2)
---
updated-dependencies:
- dependency-name: github.com/buger/jsonparser
dependency-version: 1.1.2
dependency-type: indirect
...
Signed-off-by: dependabot[bot] <su...@github.com>
Co-authored-by: dependabot[bot] <49...@users.noreply.github.com>
* build(deps-dev): bump picomatch from 2.3.1 to 2.3.2 in /admin/web (#899)
Bumps [picomatch](https://github.com/micromatch/picomatch) from 2.3.1 to 2.3.2.
- [Release notes](https://github.com/micromatch/picomatch/releases)
- [Changelog](https://github.com/micromatch/picomatch/blob/master/CHANGELOG.md)
- [Commits](https://github.com/micromatch/picomatch/compare/2.3.1...2.3.2)
---
updated-dependencies:
- dependency-name: picomatch
dependency-version: 2.3.2
dependency-type: indirect
...
Signed-off-by: dependabot[bot] <su...@github.com>
Co-authored-by: dependabot[bot] <49...@users.noreply.github.com>
* fix 1
* fix 2
* fix 3
* fix 4
* fix 5
* fix 6
* fix 7
* fix 8
* fix check
* fix lint
* fix 9
* fix 10
* fix 11
* fix 12
* fix check
---------
Signed-off-by: dependabot[bot] <su...@github.com>
Co-authored-by: Copilot Autofix powered by AI <17...@users.noreply.github.com>
Co-authored-by: dependabot[bot] <49...@users.noreply.github.com>
Co-authored-by: nanjiek <12...@users.noreply.github.com>
Co-authored-by: 陈乐樂 <12...@qq.com>
Co-authored-by: linmao <lm...@gmail.com>
---
controllers/internal/controller/config/config.go | 2 +-
.../internal/controller/gateway_controller.go | 295 +++++++++++++++++++--
controllers/internal/converter/converter.go | 9 +-
controllers/internal/converter/pixiu_config.go | 3 +-
controllers/internal/converter/policy_applier.go | 19 +-
pkg/cmd/gateway.go | 10 +-
pkg/common/http/manager.go | 4 +
pkg/common/router/router.go | 29 +-
pkg/config/config_load.go | 18 +-
pkg/hotreload/cluster_reloader.go | 164 ++++++++++++
pkg/hotreload/hotreload.go | 4 +-
pkg/hotreload/http_handler.go | 289 ++++++++++++++++++++
pkg/hotreload/logger.go | 4 -
pkg/hotreload/route_reloader.go | 51 ++--
pkg/server/listener_manager.go | 9 +-
pkg/server/pixiu_start.go | 3 +
pkg/server/router_manager.go | 59 ++++-
17 files changed, 906 insertions(+), 66 deletions(-)
diff --git a/controllers/internal/controller/config/config.go b/controllers/internal/controller/config/config.go
index a60d9db4..16570ad4 100644
--- a/controllers/internal/controller/config/config.go
+++ b/controllers/internal/controller/config/config.go
@@ -33,7 +33,7 @@ const (
DefaultLogLevel = "info"
DefaultMetricsAddr = ":8080"
DefaultProbeAddr = ":8081"
- DefaultGatewayImage = "dubboregistry/pixiu-proxy:v1.1.0"
+ DefaultGatewayImage = "dubbogopixiu/pixiu-proxy:v1.1.0"
DefaultImagePullPolicy = "IfNotPresent"
)
diff --git a/controllers/internal/controller/gateway_controller.go b/controllers/internal/controller/gateway_controller.go
index d630ea07..03eb9ef2 100644
--- a/controllers/internal/controller/gateway_controller.go
+++ b/controllers/internal/controller/gateway_controller.go
@@ -24,8 +24,12 @@ import (
"encoding/json"
"errors"
"fmt"
+ "io"
+ "net/http"
"reflect"
"strings"
+ "sync"
+ "time"
)
import (
@@ -529,18 +533,80 @@ func (r *GatewayReconciler) ensureGatewayConfigMap(ctx context.Context, gateway
isGatewayPolicy := policy.Spec.TargetRef.Kind == "Gateway" &&
string(policy.Spec.TargetRef.Name) == gateway.Name
+ r.Log.Info("processing cluster policy", "policy", policy.Name, "isGatewayPolicy", isGatewayPolicy)
+
if isGatewayPolicy {
for j := range policy.Spec.ClusterRef {
clusterConfig := &policy.Spec.ClusterRef[j]
clusterConfigMap[clusterConfig.Name] = clusterConfig
+ r.Log.Info("added cluster config", "clusterName", clusterConfig.Name, "endpointCount", len(clusterConfig.Endpoints))
}
} else {
for j := range policy.Spec.ServiceRef {
serviceConfig := &policy.Spec.ServiceRef[j]
serviceConfigMap[serviceConfig.Name] = serviceConfig
+ r.Log.Info("added service config", "serviceName", serviceConfig.Name, "endpointCount", len(serviceConfig.Endpoints))
}
}
}
+
+ r.Log.Info("cluster policy maps", "clusterConfigCount", len(clusterConfigMap), "serviceConfigCount", len(serviceConfigMap))
+
+ for _, cluster := range pixiuConfig.StaticResources.Clusters {
+ r.Log.Info("generated cluster", "name", cluster.Name, "endpointCount", len(cluster.Endpoints))
+ }
+
+ for _, cluster := range pixiuConfig.StaticResources.Clusters {
+ originalEndpoints := cluster.Endpoints
+ originalEndpointCount := len(originalEndpoints)
+
+ r.Log.Info("cluster before policy", "cluster", cluster.Name, "endpointCount", originalEndpointCount)
+
+ if clusterConfig, ok := clusterConfigMap[cluster.Name]; ok {
+ r.Log.Info("applying cluster config (exact match)", "cluster", cluster.Name, "hasEndpoints", len(clusterConfig.Endpoints) > 0)
+ if err := r.resolveClusterEndpoints(ctx, gateway.Namespace, cluster, clusterConfig); err != nil {
+ r.Log.Error(err, "failed to resolve cluster endpoints", "cluster", cluster.Name)
+ }
+ converter.ApplyClusterConfig(cluster, clusterConfig)
+ } else {
+ // match without namespace prefix (e.g., "default-service" -> "service")
+ parts := strings.SplitN(cluster.Name, "-", 2)
+ if len(parts) == 2 {
+ shortName := parts[1]
+ if clusterConfig, ok := clusterConfigMap[shortName]; ok {
+ r.Log.Info("applying cluster config (short name match)", "cluster", cluster.Name, "shortName", shortName, "hasEndpoints", len(clusterConfig.Endpoints) > 0)
+ if err := r.resolveClusterEndpoints(ctx, gateway.Namespace, cluster, clusterConfig); err != nil {
+ r.Log.Error(err, "failed to resolve cluster endpoints", "cluster", cluster.Name)
+ }
+ converter.ApplyClusterConfig(cluster, clusterConfig)
+ }
+ }
+ }
+
+ if serviceConfig, ok := serviceConfigMap[cluster.Name]; ok {
+ r.Log.Info("applying service cluster config (exact match)", "cluster", cluster.Name, "hasEndpoints", len(serviceConfig.Endpoints) > 0)
+ r.resolveServiceClusterEndpoints(ctx, gateway.Namespace, cluster, serviceConfig)
+ converter.ApplyClusterPolicy(cluster, serviceConfig)
+ } else {
+ parts := strings.SplitN(cluster.Name, "-", 2)
+ if len(parts) == 2 {
+ shortName := parts[1]
+ if serviceConfig, ok := serviceConfigMap[shortName]; ok {
+ r.Log.Info("applying service cluster config (short name match)", "cluster", cluster.Name, "shortName", shortName, "hasEndpoints", len(serviceConfig.Endpoints) > 0)
+ r.resolveServiceClusterEndpoints(ctx, gateway.Namespace, cluster, serviceConfig)
+ converter.ApplyClusterPolicy(cluster, serviceConfig)
+ }
+ }
+ }
+
+ if len(cluster.Endpoints) == 0 && originalEndpointCount > 0 {
+ r.Log.Info("policy resulted in no endpoints, restoring original endpoints",
+ "cluster", cluster.Name, "originalCount", originalEndpointCount)
+ cluster.Endpoints = originalEndpoints
+ }
+
+ r.Log.Info("cluster after policy", "cluster", cluster.Name, "endpointCount", len(cluster.Endpoints))
+ }
}
var filterPolicyList v1alpha1.PixiuFilterPolicyList
@@ -618,6 +684,12 @@ func (r *GatewayReconciler) ensureGatewayConfigMap(ctx context.Context, gateway
return "", fmt.Errorf("failed to update configmap: %w", err)
}
r.Log.Info("updated gateway configmap", "gateway", gateway.GetName(), "configmap", configMapName)
+
+ deploymentName := fmt.Sprintf("%s-%s", gateway.GetName(), string(gateway.GetUID())[:8])
+ if err := r.triggerHotReload(ctx, gateway, deploymentName); err != nil {
+ return "", fmt.Errorf("failed to trigger hot reload after configmap update: %w", err)
+ }
+ r.Log.Info("hot reload triggered successfully after configmap update", "gateway", gateway.GetName())
}
}
@@ -684,6 +756,11 @@ func (r *GatewayReconciler) ensureDataPlane(ctx context.Context, gateway *gatewa
ContainerPort: 8888,
Protocol: corev1.ProtocolTCP,
},
+ {
+ Name: "reload",
+ ContainerPort: 18380,
+ Protocol: corev1.ProtocolTCP,
+ },
},
VolumeMounts: []corev1.VolumeMount{
{
@@ -729,12 +806,20 @@ func (r *GatewayReconciler) ensureDataPlane(ctx context.Context, gateway *gatewa
needsUpdate := false
existingHash := existingDeployment.Spec.Template.Annotations["pixiu.apache.org/config-hash"]
if existingHash != configHash {
- r.Log.Info("config hash changed, triggering deployment update",
+ r.Log.Info("config hash changed, triggering hot reload",
"gateway", gateway.GetName(),
"deployment", deploymentName,
"oldHash", existingHash,
"newHash", configHash)
- needsUpdate = true
+
+ if err := r.triggerHotReload(ctx, gateway, deploymentName); err != nil {
+ r.Log.Error(err, "failed to trigger hot reload, will update deployment", "gateway", gateway.GetName())
+ needsUpdate = true
+ } else {
+ // Update annotation only after successful hot reload
+ existingDeployment.Spec.Template.Annotations["pixiu.apache.org/config-hash"] = configHash
+ needsUpdate = true
+ }
}
if !reflect.DeepEqual(existingDeployment.Spec, deployment.Spec) {
needsUpdate = true
@@ -962,10 +1047,28 @@ func (r *GatewayReconciler) resolveClusterEndpoints(ctx context.Context, namespa
}
resolvedEndpoints := []*converter.Endpoint{}
+ resolveFailed := false
for _, epConfig := range clusterConfig.Endpoints {
if !isIPAddress(epConfig.Address) {
serviceName, serviceNamespace := parseServiceAddress(epConfig.Address, namespace)
+ r.Log.Info("resolving service DNS to Pod IPs", "address", epConfig.Address, "serviceName", serviceName, "namespace", serviceNamespace)
+
+ podEndpoints, err := r.resolveServiceEndpoints(ctx, serviceNamespace, serviceName, epConfig.Port)
+ if err == nil && len(podEndpoints) > 0 {
+ r.Log.Info("resolved service to Pod endpoints", "service", serviceName, "endpointCount", len(podEndpoints))
+ for _, podEp := range podEndpoints {
+ resolvedEndpoints = append(resolvedEndpoints, &converter.Endpoint{
+ ID: len(resolvedEndpoints) + 1,
+ SocketAddress: converter.SocketAddress{
+ Address: podEp.Address,
+ Port: int(podEp.Port),
+ },
+ })
+ }
+ continue
+ }
+ r.Log.Info("failed to resolve to Pod IPs, trying Service ClusterIP", "service", serviceName, "error", err)
clusterIP, svcPort, err := r.resolveServiceClusterIP(ctx, serviceNamespace, serviceName, epConfig.Port)
if err == nil && clusterIP != "" {
resolvedEndpoints = append(resolvedEndpoints, &converter.Endpoint{
@@ -983,18 +1086,8 @@ func (r *GatewayReconciler) resolveClusterEndpoints(ctx context.Context, namespa
continue
}
- resolvedEndpoints = append(resolvedEndpoints, &converter.Endpoint{
- ID: func() int {
- if epConfig.ID != nil {
- return int(*epConfig.ID)
- }
- return len(resolvedEndpoints) + 1
- }(),
- SocketAddress: converter.SocketAddress{
- Address: epConfig.Address,
- Port: int(epConfig.Port),
- },
- })
+ resolveFailed = true
+ r.Log.Info("failed to resolve service, skipping this endpoint", "address", epConfig.Address, "error", err)
continue
}
@@ -1012,9 +1105,14 @@ func (r *GatewayReconciler) resolveClusterEndpoints(ctx context.Context, namespa
})
}
- if len(resolvedEndpoints) > 0 {
- cluster.Endpoints = resolvedEndpoints
+ if len(resolvedEndpoints) == 0 {
+ if resolveFailed {
+ return fmt.Errorf("failed to resolve configured endpoints from ClusterPolicy")
+ }
+ return fmt.Errorf("ClusterPolicy configured no usable endpoints")
}
+
+ cluster.Endpoints = resolvedEndpoints
return nil
}
@@ -1046,14 +1144,16 @@ func (r *GatewayReconciler) resolveServiceEndpoints(ctx context.Context, namespa
for _, endpointPort := range endpointSlice.Ports {
if endpointPort.Port != nil && endpointPort.Name != nil {
targetPort = int32(*endpointPort.Port)
- return nil, nil
+ break // Found port, break to use it
}
}
- for _, endpointPort := range endpointSlice.Ports {
- if endpointPort.Port != nil {
- targetPort = int32(*endpointPort.Port)
- return nil, nil
+ if targetPort == port {
+ for _, endpointPort := range endpointSlice.Ports {
+ if endpointPort.Port != nil {
+ targetPort = int32(*endpointPort.Port)
+ break // Found port, break to use it
+ }
}
}
}
@@ -1159,3 +1259,156 @@ func isNumeric(s string) bool {
}
return len(s) > 0
}
+
+// resolveServiceClusterEndpoints resolves Service DNS names in ServiceClusterConfig endpoints to actual IPs
+func (r *GatewayReconciler) resolveServiceClusterEndpoints(ctx context.Context, namespace string, cluster *converter.Cluster, serviceConfig *v1alpha1.ServiceClusterConfig) {
+ if len(serviceConfig.Endpoints) == 0 {
+ return
+ }
+
+ resolved := make([]v1alpha1.EndpointConfig, 0, len(serviceConfig.Endpoints))
+ idCounter := 1
+
+ for i := range serviceConfig.Endpoints {
+ ep := &serviceConfig.Endpoints[i]
+ if isIPAddress(ep.Address) {
+ // Keep IP addresses as-is
+ resolved = append(resolved, *ep)
+ idCounter++
+ continue
+ }
+
+ serviceName, serviceNamespace := parseServiceAddress(ep.Address, namespace)
+ r.Log.Info("resolving service DNS", "address", ep.Address, "serviceName", serviceName, "namespace", serviceNamespace)
+
+ endpoints, err := r.resolveServiceEndpoints(ctx, serviceNamespace, serviceName, ep.Port)
+ if err == nil && len(endpoints) > 0 {
+ r.Log.Info("resolved service to endpoints", "service", serviceName, "endpointCount", len(endpoints))
+ for _, resolvedEp := range endpoints {
+ id := int32(idCounter)
+ resolved = append(resolved, v1alpha1.EndpointConfig{
+ ID: &id,
+ Address: resolvedEp.Address,
+ Port: resolvedEp.Port,
+ })
+ idCounter++
+ }
+ } else {
+ r.Log.Info("failed to resolve service, keeping original address", "service", serviceName, "error", err)
+ // Keep the original unresolved entry
+ resolved = append(resolved, *ep)
+ idCounter++
+ }
+ }
+
+ serviceConfig.Endpoints = resolved
+}
+
+// triggerHotReload triggers hot reload on all pods in the deployment
+func (r *GatewayReconciler) triggerHotReload(ctx context.Context, gateway *gatewayv1.Gateway, _ string) error {
+ configMapName := fmt.Sprintf("%s-config", gateway.GetName())
+ configMap := &corev1.ConfigMap{}
+ if err := r.Get(ctx, client.ObjectKey{
+ Name: configMapName,
+ Namespace: gateway.GetNamespace(),
+ }, configMap); err != nil {
+ return fmt.Errorf("failed to get configmap: %w", err)
+ }
+
+ configYAML, ok := configMap.Data["conf.yaml"]
+ if !ok {
+ return fmt.Errorf("conf.yaml not found in configmap")
+ }
+
+ httpClient := &http.Client{
+ Timeout: 10 * time.Second,
+ }
+
+ podList := &corev1.PodList{}
+ if err := r.List(ctx, podList,
+ client.InNamespace(gateway.GetNamespace()),
+ client.MatchingLabels{
+ "app.kubernetes.io/name": "pixiu-gateway",
+ "gateway.networking.k8s.io/gateway-name": gateway.GetName(),
+ }); err != nil {
+ return fmt.Errorf("failed to list pods: %w", err)
+ }
+
+ if len(podList.Items) == 0 {
+ r.Log.Info("no pods found for hot reload", "gateway", gateway.GetName())
+ return nil
+ }
+
+ var wg sync.WaitGroup
+ var mu sync.Mutex
+ var successCount int
+ var failureCount int
+
+ for _, pod := range podList.Items {
+ pod := pod
+ wg.Add(1)
+ go func() {
+ defer wg.Done()
+
+ if pod.Status.Phase != corev1.PodRunning {
+ r.Log.Info("skipping non-running pod", "pod", pod.Name, "phase", pod.Status.Phase)
+ return
+ }
+
+ podIP := pod.Status.PodIP
+ if podIP == "" {
+ r.Log.Info("pod has no IP address", "pod", pod.Name)
+ return
+ }
+
+ reloadURL := fmt.Sprintf("http://%s:18380/-/reload", podIP)
+ r.Log.Info("triggering hot reload", "pod", pod.Name, "url", reloadURL)
+
+ req, err := http.NewRequestWithContext(ctx, http.MethodPost, reloadURL, strings.NewReader(configYAML))
+ if err != nil {
+ r.Log.Error(err, "failed to create reload request", "pod", pod.Name)
+ mu.Lock()
+ failureCount++
+ mu.Unlock()
+ return
+ }
+ req.Header.Set("Content-Type", "application/x-yaml")
+
+ resp, err := httpClient.Do(req)
+ if err != nil {
+ r.Log.Error(err, "failed to trigger hot reload", "pod", pod.Name, "url", reloadURL)
+ mu.Lock()
+ failureCount++
+ mu.Unlock()
+ return
+ }
+
+ _, _ = io.Copy(io.Discard, resp.Body)
+ if closeErr := resp.Body.Close(); closeErr != nil {
+ r.Log.Error(closeErr, "failed to close reload response body", "pod", pod.Name)
+ }
+
+ mu.Lock()
+ defer mu.Unlock()
+ if resp.StatusCode == http.StatusOK {
+ r.Log.Info("hot reload successful", "pod", pod.Name)
+ successCount++
+ return
+ }
+
+ failureCount++
+ r.Log.Error(fmt.Errorf("unexpected status code: %d", resp.StatusCode),
+ "hot reload failed", "pod", pod.Name)
+ }()
+ }
+
+ wg.Wait()
+
+ if successCount == 0 {
+ return fmt.Errorf("hot reload failed on all pods")
+ }
+
+ r.Log.Info("hot reload completed", "gateway", gateway.GetName(),
+ "successCount", successCount, "failureCount", failureCount, "totalPods", len(podList.Items))
+ return nil
+}
diff --git a/controllers/internal/converter/converter.go b/controllers/internal/converter/converter.go
index 062e8cca..df48a4c0 100644
--- a/controllers/internal/converter/converter.go
+++ b/controllers/internal/converter/converter.go
@@ -184,7 +184,8 @@ func (c *Converter) convertHTTPListener(httpListener *ir.HTTPListener, clusters
hcmConfig := HTTPConnectionManagerConfig{
RouteConfig: RouteConfiguration{
- Routes: routes,
+ Routes: routes,
+ Dynamic: true,
},
HTTPFilters: httpFilters,
}
@@ -298,7 +299,8 @@ func (c *Converter) convertTripleListener(tcpListener *ir.TCPListener, clusters
dubboConfig := DubboConnectionManagerConfig{
RouteConfig: RouteConfiguration{
- Routes: routes,
+ Routes: routes,
+ Dynamic: true,
},
DubboFilters: dubboFilters,
}
@@ -359,7 +361,8 @@ func (c *Converter) convertTCPListener(tcpListener *ir.TCPListener, clusters []*
dubboConfig := DubboConnectionManagerConfig{
RouteConfig: RouteConfiguration{
- Routes: routes,
+ Routes: routes,
+ Dynamic: true,
},
DubboFilters: dubboFilters,
}
diff --git a/controllers/internal/converter/pixiu_config.go b/controllers/internal/converter/pixiu_config.go
index 1805d760..68cf7325 100644
--- a/controllers/internal/converter/pixiu_config.go
+++ b/controllers/internal/converter/pixiu_config.go
@@ -73,7 +73,8 @@ type DubboFilter struct {
}
type RouteConfiguration struct {
- Routes []*Route `yaml:"routes" json:"routes"`
+ Routes []*Route `yaml:"routes" json:"routes"`
+ Dynamic bool `yaml:"dynamic" json:"dynamic"`
}
type Route struct {
diff --git a/controllers/internal/converter/policy_applier.go b/controllers/internal/converter/policy_applier.go
index 44c22712..4060a9e8 100644
--- a/controllers/internal/converter/policy_applier.go
+++ b/controllers/internal/converter/policy_applier.go
@@ -154,8 +154,23 @@ func ApplyClusterConfig(cluster *Cluster, clusterConfig *v1alpha1.ClusterConfig)
cluster.Type = clusterConfig.Type
}
- // Endpoints are already resolved in gateway_controller.go
- // This function is called after endpoints are resolved
+ if len(clusterConfig.Endpoints) > 0 {
+ cluster.Endpoints = []*Endpoint{}
+ for i, ep := range clusterConfig.Endpoints {
+ endpoint := &Endpoint{
+ SocketAddress: SocketAddress{
+ Address: ep.Address,
+ Port: int(ep.Port),
+ },
+ }
+ if ep.ID != nil {
+ endpoint.ID = int(*ep.ID)
+ } else {
+ endpoint.ID = i + 1
+ }
+ cluster.Endpoints = append(cluster.Endpoints, endpoint)
+ }
+ }
}
// ApplyFilterPolicy applies PixiuFilterPolicy config to ir.HTTPFilter
diff --git a/pkg/cmd/gateway.go b/pkg/cmd/gateway.go
index 84a7a992..7accdc37 100644
--- a/pkg/cmd/gateway.go
+++ b/pkg/cmd/gateway.go
@@ -116,6 +116,14 @@ func (d *DefaultDeployer) initialize() error {
hotreload.StartHotReload(d.configManger, d.bootstrap)
+ // Set config path for hot reload
+ hotreload.SetConfigPath(configPath)
+
+ // Start HTTP reload endpoint on port 18380
+ if err := hotreload.StartReloadServer(18380, ""); err != nil {
+ logger.Warnf("[startGatewayCmd] failed to start reload server: %s", err.Error())
+ }
+
return err
}
@@ -125,7 +133,7 @@ func (d *DefaultDeployer) start() error {
}
func (d *DefaultDeployer) stop() error {
- //TODO implement me
+ // TODO implement me
panic("implement me")
}
diff --git a/pkg/common/http/manager.go b/pkg/common/http/manager.go
index 80e9b44c..5177bcad 100644
--- a/pkg/common/http/manager.go
+++ b/pkg/common/http/manager.go
@@ -66,6 +66,10 @@ func CreateHttpConnectionManager(hcmc *model.HttpConnectionManagerConfig) *HttpC
route.Match.Methods = []string{}
}
}
+
+ // Force enable dynamic routing for hot reload
+ hcmc.RouteConfig.Dynamic = true
+
hcm.routerCoordinator = router2.CreateRouterCoordinator(&hcmc.RouteConfig)
hcm.filterManager = filter.NewFilterManager(hcmc.HTTPFilters)
hcm.filterManager.Load()
diff --git a/pkg/common/router/router.go b/pkg/common/router/router.go
index 6a8393c5..3d970196 100644
--- a/pkg/common/router/router.go
+++ b/pkg/common/router/router.go
@@ -47,6 +47,9 @@ type RouterCoordinator struct {
timer *time.Timer // debounce timer
debounce time.Duration // merge window, default 50ms
+
+ needsRegistration atomic.Bool // whether needs to register as RouterListener
+ dynamic bool // whether dynamic routing is enabled
}
// CreateRouterCoordinator create coordinator for http connection manager
@@ -54,9 +57,16 @@ func CreateRouterCoordinator(routeConfig *model.RouteConfiguration) *RouterCoord
rc := &RouterCoordinator{
nextSnapshot: make([]*model.Router, 0, len(routeConfig.Routes)),
debounce: 50 * time.Millisecond, // merge window
+ dynamic: routeConfig.Dynamic,
}
if routeConfig.Dynamic {
- server.GetRouterManager().AddRouterListener(rc)
+ rm := server.GetRouterManager()
+ if rm != nil {
+ rm.AddRouterListener(rc)
+ } else {
+ // RouterManager not initialized yet, will register later
+ rc.needsRegistration.Store(true)
+ }
}
// build initial config and store snapshot
rc.mainSnapshot.Store(model.ToSnapshot(buildRouteConfiguration(routeConfig.Routes).Routes))
@@ -65,7 +75,24 @@ func CreateRouterCoordinator(routeConfig *model.RouteConfiguration) *RouterCoord
return rc
}
+func (rm *RouterCoordinator) Close() {
+ if rm.dynamic {
+ routerMgr := server.GetRouterManager()
+ if routerMgr != nil {
+ routerMgr.RemoveRouterListener(rm)
+ }
+ }
+}
+
func (rm *RouterCoordinator) Route(hc *http.HttpContext) (*model.RouteAction, error) {
+ if rm.dynamic && rm.needsRegistration.CompareAndSwap(true, false) {
+ routerMgr := server.GetRouterManager()
+ if routerMgr != nil {
+ routerMgr.AddRouterListener(rm)
+ } else {
+ rm.needsRegistration.Store(true)
+ }
+ }
return rm.route(hc.Request)
}
diff --git a/pkg/config/config_load.go b/pkg/config/config_load.go
index 9e0d519a..ffd84b3a 100644
--- a/pkg/config/config_load.go
+++ b/pkg/config/config_load.go
@@ -23,6 +23,7 @@ import (
"path/filepath"
"strings"
"sync"
+ "sync/atomic"
)
import (
@@ -44,7 +45,7 @@ import (
var (
configPath string
- config *model.Bootstrap
+ config atomic.Pointer[model.Bootstrap]
configLoadFunc LoadFunc = LoadYAMLConfig
once sync.Once
@@ -55,7 +56,12 @@ type LoadFunc func(path string) *model.Bootstrap
// GetBootstrap get config global, need a better name
func GetBootstrap() *model.Bootstrap {
- return config
+ return config.Load()
+}
+
+// SetBootstrap set config global
+func SetBootstrap(cfg *model.Bootstrap) {
+ config.Store(cfg)
}
// Load config file and parse
@@ -66,9 +72,9 @@ func Load(path string) *model.Bootstrap {
RegisterConfigLoadFunc(LoadYAMLConfig)
}
if cfg := configLoadFunc(configPath); cfg != nil {
- config = cfg
+ config.Store(cfg)
}
- return config
+ return config.Load()
}
// RegisterConfigLoadFunc can replace a new config load function instead of default
@@ -207,7 +213,7 @@ func (m *ConfigManager) LoadBootConfig(path string) *model.Bootstrap {
}
}
- config = configs
+ config.Store(configs)
err := m.check()
@@ -274,5 +280,5 @@ func (m *ConfigManager) ViewRemoteConfig() *model.Bootstrap {
func (m *ConfigManager) check() error {
- return Adapter(config)
+ return Adapter(config.Load())
}
diff --git a/pkg/hotreload/cluster_reloader.go b/pkg/hotreload/cluster_reloader.go
new file mode 100644
index 00000000..6ea3bd81
--- /dev/null
+++ b/pkg/hotreload/cluster_reloader.go
@@ -0,0 +1,164 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package hotreload
+
+import (
+ "github.com/pkg/errors"
+)
+
+import (
+ "github.com/apache/dubbo-go-pixiu/pkg/logger"
+ "github.com/apache/dubbo-go-pixiu/pkg/model"
+ "github.com/apache/dubbo-go-pixiu/pkg/server"
+)
+
+type ClusterReloader struct{}
+
+// CheckUpdate compares the old and new cluster configurations to determine if a reload is needed.
+func (c *ClusterReloader) CheckUpdate(oldConfig, newConfig *model.Bootstrap) bool {
+ oldClusters := oldConfig.StaticResources.Clusters
+ newClusters := newConfig.StaticResources.Clusters
+
+ if len(oldClusters) != len(newClusters) {
+ logger.Infof("Cluster count changed: old=%d, new=%d", len(oldClusters), len(newClusters))
+ return true
+ }
+
+ oldClusterMap := make(map[string]*model.ClusterConfig)
+ for _, cluster := range oldClusters {
+ oldClusterMap[cluster.Name] = cluster
+ }
+
+ for _, newCluster := range newClusters {
+ oldCluster, exists := oldClusterMap[newCluster.Name]
+ if !exists {
+ logger.Infof("New cluster found: %s", newCluster.Name)
+ return true
+ }
+
+ if len(oldCluster.Endpoints) != len(newCluster.Endpoints) {
+ logger.Infof("Cluster %s endpoint count changed: old=%d, new=%d",
+ newCluster.Name, len(oldCluster.Endpoints), len(newCluster.Endpoints))
+ return true
+ }
+
+ for i := range newCluster.Endpoints {
+ if i >= len(oldCluster.Endpoints) {
+ return true
+ }
+ oldEp := oldCluster.Endpoints[i]
+ newEp := newCluster.Endpoints[i]
+ if oldEp.Address.Address != newEp.Address.Address ||
+ oldEp.Address.Port != newEp.Address.Port {
+ logger.Infof("Cluster %s endpoint changed: old=%s:%d, new=%s:%d",
+ newCluster.Name,
+ oldEp.Address.Address, oldEp.Address.Port,
+ newEp.Address.Address, newEp.Address.Port)
+ return true
+ }
+ }
+
+ if oldCluster.LbStr != newCluster.LbStr {
+ logger.Infof("Cluster %s lb policy changed: old=%s, new=%s",
+ newCluster.Name, oldCluster.LbStr, newCluster.LbStr)
+ return true
+ }
+ }
+
+ return false
+}
+
+// HotReload applies the new cluster configuration.
+func (c *ClusterReloader) HotReload(oldConfig, newConfig *model.Bootstrap) error {
+ logger.Info("Starting cluster hot reload")
+
+ srv := server.GetServer()
+ if srv == nil {
+ logger.Error("Server instance is nil")
+ return errors.New("server instance is nil")
+ }
+
+ clusterManager := srv.GetClusterManager()
+ if clusterManager == nil {
+ logger.Error("Cluster manager is nil")
+ return errors.New("cluster manager is nil")
+ }
+
+ oldClusterMap := make(map[string]*model.ClusterConfig)
+ for _, cluster := range oldConfig.StaticResources.Clusters {
+ oldClusterMap[cluster.Name] = cluster
+ }
+
+ newClusterMap := make(map[string]*model.ClusterConfig)
+ for _, cluster := range newConfig.StaticResources.Clusters {
+ newClusterMap[cluster.Name] = cluster
+ }
+
+ clustersToRemove := []string{}
+ for name := range oldClusterMap {
+ if _, exists := newClusterMap[name]; !exists {
+ clustersToRemove = append(clustersToRemove, name)
+ }
+ }
+ if len(clustersToRemove) > 0 {
+ logger.Infof("Removing %d cluster(s): %v", len(clustersToRemove), clustersToRemove)
+ clusterManager.RemoveCluster(clustersToRemove)
+ }
+
+ updated := 0
+ added := 0
+ for _, newCluster := range newConfig.StaticResources.Clusters {
+ if oldCluster, exists := oldClusterMap[newCluster.Name]; exists {
+ if c.clusterChanged(oldCluster, newCluster) {
+ logger.Infof("Updating cluster: %s (endpoints: %d)", newCluster.Name, len(newCluster.Endpoints))
+ clusterManager.UpdateCluster(newCluster)
+ updated++
+ }
+ } else {
+ logger.Infof("Adding new cluster: %s (endpoints: %d)", newCluster.Name, len(newCluster.Endpoints))
+ clusterManager.AddCluster(newCluster)
+ added++
+ }
+ }
+
+ logger.Infof("Cluster hot reload completed: added=%d, updated=%d, removed=%d",
+ added, updated, len(clustersToRemove))
+ logger.Info("Cluster hot reload completed successfully")
+ return nil
+}
+
+// clusterChanged checks if a cluster configuration has changed
+func (c *ClusterReloader) clusterChanged(old, new *model.ClusterConfig) bool {
+ if len(old.Endpoints) != len(new.Endpoints) {
+ return true
+ }
+
+ for i := range new.Endpoints {
+ if i >= len(old.Endpoints) {
+ return true
+ }
+ oldEp := old.Endpoints[i]
+ newEp := new.Endpoints[i]
+ if oldEp.Address.Address != newEp.Address.Address ||
+ oldEp.Address.Port != newEp.Address.Port {
+ return true
+ }
+ }
+
+ return old.LbStr != new.LbStr
+}
diff --git a/pkg/hotreload/hotreload.go b/pkg/hotreload/hotreload.go
index 133a234e..ea665dea 100644
--- a/pkg/hotreload/hotreload.go
+++ b/pkg/hotreload/hotreload.go
@@ -46,10 +46,9 @@ type Coordinator struct {
manager *config.ConfigManager // Configuration manager
}
-var coordinator = Coordinator{reloaders: []HotReloader{&LoggerReloader{}, &RouteReloader{}}}
+var coordinator = Coordinator{reloaders: []HotReloader{&LoggerReloader{}, &RouteReloader{}, &ClusterReloader{}}}
// StartHotReload initializes the hot reload process.
-// It should be called when the project starts, e.g., in cmd/gateway.go.
func StartHotReload(manager *config.ConfigManager, boot *model.Bootstrap) {
if manager == nil || boot == nil {
logger.Warn("ConfigManager or Bootstrap is nil, hot reload will not start")
@@ -100,7 +99,6 @@ func (c *Coordinator) hotReload(newBoot *model.Bootstrap) {
}
}
-// equal checks if two string slices are equal.
func equal(s1, s2 []string) bool {
if len(s1) != len(s2) {
return false
diff --git a/pkg/hotreload/http_handler.go b/pkg/hotreload/http_handler.go
new file mode 100644
index 00000000..737f66a9
--- /dev/null
+++ b/pkg/hotreload/http_handler.go
@@ -0,0 +1,289 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package hotreload
+
+import (
+ "context"
+ "encoding/json"
+ "fmt"
+ "io"
+ "net"
+ "net/http"
+ "os"
+ "sync"
+ "time"
+)
+
+import (
+ "gopkg.in/yaml.v3"
+)
+
+import (
+ "github.com/apache/dubbo-go-pixiu/pkg/config"
+ "github.com/apache/dubbo-go-pixiu/pkg/logger"
+ "github.com/apache/dubbo-go-pixiu/pkg/model"
+)
+
+var (
+ reloadMutex sync.Mutex
+ configPath string
+ reloadServer *http.Server
+ reloadServerMu sync.Mutex
+ reloadSecret string // shared secret for authentication
+)
+
+func SetConfigPath(path string) {
+ configPath = path
+}
+
+func SetReloadSecret(secret string) {
+ reloadSecret = secret
+}
+
+// ReloadHandler handles HTTP reload requests
+type ReloadHandler struct{}
+
+// checkAuth validates the request authentication
+func checkAuth(r *http.Request) bool {
+ // Allow localhost without authentication
+ host, _, err := net.SplitHostPort(r.RemoteAddr)
+ if err == nil && (host == "127.0.0.1" || host == "::1" || host == "localhost") {
+ return true
+ }
+
+ // Check shared secret if configured
+ if reloadSecret != "" {
+ token := r.Header.Get("X-Reload-Token")
+ return token == reloadSecret
+ }
+
+ // If no secret configured and not localhost, deny
+ return false
+}
+
+// ServeHTTP handles the reload HTTP request
+func (h *ReloadHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+ if r.Method != http.MethodPost {
+ http.Error(w, "Method not allowed, use POST", http.StatusMethodNotAllowed)
+ return
+ }
+
+ if !checkAuth(r) {
+ logger.Warnf("Unauthorized reload request from %s", r.RemoteAddr)
+ http.Error(w, "Unauthorized", http.StatusUnauthorized)
+ return
+ }
+
+ logger.Info("Received reload request via HTTP")
+
+ var err error
+ // Try to read from body first (handles chunked encoding where ContentLength == -1)
+ // If body is empty, fallback to file reload
+ if r.Body != nil {
+ content, readErr := io.ReadAll(r.Body)
+
+ if readErr != nil {
+ logger.Errorf("Failed to read request body: %v", readErr)
+ http.Error(w, fmt.Sprintf("Failed to read request body: %v", readErr), http.StatusBadRequest)
+ return
+ }
+
+ if len(content) > 0 {
+ // Body has content, use it
+ reloadMutex.Lock()
+ err = reloadFromYAML(content)
+ reloadMutex.Unlock()
+ } else {
+ // Body is empty, fallback to file reload
+ err = triggerConfigReload()
+ }
+ } else {
+ err = triggerConfigReload()
+ }
+
+ if err != nil {
+ logger.Errorf("Reload failed: %v", err)
+ http.Error(w, fmt.Sprintf("Reload failed: %v", err), http.StatusInternalServerError)
+ return
+ }
+
+ w.Header().Set("Content-Type", "application/json")
+ w.WriteHeader(http.StatusOK)
+ writeJSONResponse(w, "success", "Configuration reloaded successfully")
+ logger.Info("Reload completed successfully")
+}
+
+func writeJSONResponse(w http.ResponseWriter, status, message string) {
+ response := map[string]string{
+ "status": status,
+ "message": message,
+ "time": time.Now().Format(time.RFC3339),
+ }
+ if err := json.NewEncoder(w).Encode(response); err != nil {
+ logger.Errorf("Failed to encode response: %v", err)
+ }
+}
+
+// HealthHandler handles health check requests
+type HealthHandler struct{}
+
+// ServeHTTP handles the health check HTTP request
+func (h *HealthHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+ if !checkAuth(r) {
+ logger.Warnf("Unauthorized health check request from %s", r.RemoteAddr)
+ http.Error(w, "Unauthorized", http.StatusUnauthorized)
+ return
+ }
+
+ w.Header().Set("Content-Type", "application/json")
+ w.WriteHeader(http.StatusOK)
+ writeJSONResponse(w, "healthy", "")
+}
+
+// triggerConfigReload reloads configuration from file
+func triggerConfigReload() error {
+ reloadMutex.Lock()
+ defer reloadMutex.Unlock()
+
+ if configPath == "" {
+ return fmt.Errorf("config path not set")
+ }
+
+ logger.Infof("Reloading configuration from: %s", configPath)
+
+ content, err := os.ReadFile(configPath)
+ if err != nil {
+ return fmt.Errorf("failed to read config file: %w", err)
+ }
+
+ return reloadFromYAML(content)
+}
+
+// reloadFromYAML performs the actual reload from YAML content
+func reloadFromYAML(content []byte) error {
+ newConfig := &model.Bootstrap{}
+ if err := yaml.Unmarshal(content, newConfig); err != nil {
+ return fmt.Errorf("failed to parse config: %w", err)
+ }
+
+ if err := config.Adapter(newConfig); err != nil {
+ return fmt.Errorf("failed to adapt config: %w", err)
+ }
+
+ oldConfig := config.GetBootstrap()
+ if oldConfig == nil {
+ return fmt.Errorf("current config is nil")
+ }
+
+ logger.Infof("Old config has %d listeners, new config has %d listeners",
+ len(oldConfig.StaticResources.Listeners), len(newConfig.StaticResources.Listeners))
+
+ // Execute reloaders serially with CheckUpdate validation
+ for _, reloader := range coordinator.reloaders {
+ // Check if update is needed before executing reload
+ if !reloader.CheckUpdate(oldConfig, newConfig) {
+ logger.Debugf("No update needed for %T", reloader)
+ continue
+ }
+
+ logger.Infof("Triggering reload for %T", reloader)
+ if err := reloader.HotReload(oldConfig, newConfig); err != nil {
+ logger.Errorf("Hot reload failed for %T: %v", reloader, err)
+ return fmt.Errorf("reload failed for %T: %w", reloader, err)
+ }
+ }
+
+ config.SetBootstrap(newConfig)
+ logger.Info("Configuration reloaded successfully and global config updated")
+ return nil
+}
+
+// StartReloadServer starts the HTTP server for reload endpoint
+// port: the port to listen on (0 means use default 8888)
+// secret: optional shared secret for authentication (empty means localhost-only)
+func StartReloadServer(port int, secret string) error {
+ reloadServerMu.Lock()
+ defer reloadServerMu.Unlock()
+
+ if reloadServer != nil {
+ return fmt.Errorf("reload server already running")
+ }
+
+ if port <= 0 {
+ port = 8888 // default port
+ }
+
+ if secret != "" {
+ reloadSecret = secret
+ }
+
+ addr := fmt.Sprintf(":%d", port)
+ logger.Infof("Starting reload HTTP server on %s", addr)
+
+ // Try to bind the port first to catch errors early
+ listener, err := net.Listen("tcp", addr)
+ if err != nil {
+ return fmt.Errorf("failed to bind port %d: %w", port, err)
+ }
+
+ mux := http.NewServeMux()
+ mux.Handle("/-/reload", &ReloadHandler{})
+ mux.Handle("/-/health", &HealthHandler{})
+
+ reloadServer = &http.Server{
+ Handler: mux,
+ ReadTimeout: 10 * time.Second,
+ WriteTimeout: 10 * time.Second,
+ }
+
+ // Start server in goroutine
+ go func() {
+ if err := reloadServer.Serve(listener); err != nil && err != http.ErrServerClosed {
+ logger.Errorf("Reload HTTP server failed: %v", err)
+ }
+ }()
+
+ logger.Infof("Reload HTTP server started successfully on port %d", port)
+ return nil
+}
+
+// StopReloadServer gracefully stops the reload HTTP server
+func StopReloadServer(timeout time.Duration) error {
+ reloadServerMu.Lock()
+ defer reloadServerMu.Unlock()
+
+ if reloadServer == nil {
+ return nil
+ }
+
+ logger.Info("Stopping reload HTTP server")
+
+ ctx, cancel := context.WithTimeout(context.Background(), timeout)
+ defer cancel()
+
+ err := reloadServer.Shutdown(ctx)
+ reloadServer = nil
+
+ if err != nil {
+ logger.Errorf("Error stopping reload server: %v", err)
+ return err
+ }
+
+ logger.Info("Reload HTTP server stopped successfully")
+ return nil
+}
diff --git a/pkg/hotreload/logger.go b/pkg/hotreload/logger.go
index 6bc00424..a3bf5df4 100644
--- a/pkg/hotreload/logger.go
+++ b/pkg/hotreload/logger.go
@@ -42,7 +42,6 @@ func (r *LoggerReloader) CheckUpdate(oldConfig, newConfig *model.Bootstrap) bool
return true
}
- // Check if any logger configuration fields have changed.
if oc.Level != nc.Level ||
oc.Development != nc.Development ||
oc.DisableCaller != nc.DisableCaller ||
@@ -51,17 +50,14 @@ func (r *LoggerReloader) CheckUpdate(oldConfig, newConfig *model.Bootstrap) bool
return true
}
- // Check sampling configuration.
if !r.checkSampling(oc.Sampling, nc.Sampling) {
return true
}
- // Check encoder configuration.
if !r.checkEncoderConfig(oc.EncoderConfig, nc.EncoderConfig) {
return true
}
- // Check output paths.
if !equal(oc.OutputPaths, nc.OutputPaths) {
return true
}
diff --git a/pkg/hotreload/route_reloader.go b/pkg/hotreload/route_reloader.go
index 53a1ac30..8a830345 100644
--- a/pkg/hotreload/route_reloader.go
+++ b/pkg/hotreload/route_reloader.go
@@ -39,12 +39,10 @@ type RouteReloader struct{}
func (r *RouteReloader) CheckUpdate(oldConfig, newConfig *model.Bootstrap) bool {
oldRoutes := extractRoutes(oldConfig)
newRoutes := extractRoutes(newConfig)
- // Compare the number of routes
if len(oldRoutes.Routes) != len(newRoutes.Routes) || oldRoutes.Dynamic != newRoutes.Dynamic {
return true
}
- // Compare each route
for i := range newRoutes.Routes {
if oldRoutes.Routes[i].Match.Prefix != newRoutes.Routes[i].Match.Prefix ||
oldRoutes.Routes[i].Route.Cluster != newRoutes.Routes[i].Route.Cluster {
@@ -56,16 +54,44 @@ func (r *RouteReloader) CheckUpdate(oldConfig, newConfig *model.Bootstrap) bool
// HotReload applies the new route configuration.
func (r *RouteReloader) HotReload(oldConfig, newConfig *model.Bootstrap) error {
- oldRoutes := extractRoutes(oldConfig)
- newRoutes := extractRoutes(newConfig)
+ logger.Info("Starting route hot reload")
+
+ srv := server.GetServer()
+ if srv == nil {
+ logger.Error("Server instance is nil")
+ return errors.New("server instance is nil")
+ }
+ logger.Info("Got server instance")
+
+ logger.Info("Reinitializing server components...")
+
+ listenerManager := srv.GetListenerManager()
+ if listenerManager == nil {
+ logger.Error("Listener manager is nil")
+ return errors.New("listener manager is nil")
+ }
+
+ srv.GetRouterManager().ClearRouterListeners()
+
+ refreshed := 0
+ for _, listener := range newConfig.StaticResources.Listeners {
+ logger.Infof("Refreshing listener: name=%s, protocol=%s", listener.Name, listener.ProtocolStr)
+
+ if err := listenerManager.UpdateListener(listener); err != nil {
+ logger.Errorf("Failed to refresh listener %s: %v", listener.Name, err)
+ return errors.Wrapf(err, "failed to refresh listener %s", listener.Name)
+ }
+ logger.Infof("Successfully refreshed listener: %s", listener.Name)
+ refreshed++
+ }
- // Update routes in the RouterManager
- err := server.GetRouterManager().UpdateRoutes(oldRoutes.Routes, newRoutes.Routes)
- if err != nil {
- logger.Infof("Failed to Routes reloaded.")
- return err
+ if refreshed == 0 {
+ logger.Warn("No listeners were refreshed")
+ } else {
+ logger.Infof("Successfully refreshed %d listener(s)", refreshed)
}
+ logger.Info("Route hot reload completed successfully")
return nil
}
@@ -78,7 +104,6 @@ func extractRoutes(config *model.Bootstrap) model.RouteConfiguration {
for _, listener := range config.StaticResources.Listeners {
for _, filterChain := range listener.FilterChain.Filters {
if filterChain.Name == constant.HTTPConnectManagerFilter {
- // Extract route_config
rawRouteConfig, ok := filterChain.Config["route_config"]
if !ok {
logger.Debugf("No route_config found in filter chain: %+v", filterChain)
@@ -86,14 +111,12 @@ func extractRoutes(config *model.Bootstrap) model.RouteConfiguration {
}
logger.Debugf("Raw route_config: %+v", rawRouteConfig)
- // Convert route_config to JSON bytes
routeConfigBytes, err := json.Marshal(rawRouteConfig)
if err != nil {
logger.Errorf("Failed to marshal route_config: %v", err)
continue
}
- // Parse JSON bytes into model.RouteConfiguration
if err := json.Unmarshal(routeConfigBytes, &routeConfig); err != nil {
logger.Errorf("Failed to unmarshal route_config: %v", err)
continue
@@ -101,7 +124,6 @@ func extractRoutes(config *model.Bootstrap) model.RouteConfiguration {
logger.Debugf("Parsed route_config: %+v", routeConfig)
- // Validate and filter routes
validRoutes := make([]*model.Router, 0, len(routeConfig.Routes))
for _, route := range routeConfig.Routes {
if err := validateRoute(route); err != nil {
@@ -115,7 +137,6 @@ func extractRoutes(config *model.Bootstrap) model.RouteConfiguration {
routeConfig.Routes = validRoutes
logger.Debugf("Valid routes after filtering: %+v", validRoutes)
- // Return if we have valid routes
if len(validRoutes) > 0 {
return routeConfig
}
@@ -131,12 +152,10 @@ func extractRoutes(config *model.Bootstrap) model.RouteConfiguration {
// validateRoute validates a single route, returning an error if invalid.
func validateRoute(route *model.Router) error {
- // Ensure route has a valid match condition
if route.Match.Prefix == "" && route.Match.Path == "" {
return errors.Errorf("route %s has no prefix or path defined", route.ID)
}
- // Ensure cluster is specified
if route.Route.Cluster == "" {
return errors.Errorf("route %s has no cluster defined", route.ID)
}
diff --git a/pkg/server/listener_manager.go b/pkg/server/listener_manager.go
index e27b2c6b..0543d126 100644
--- a/pkg/server/listener_manager.go
+++ b/pkg/server/listener_manager.go
@@ -147,11 +147,14 @@ func (lm *ListenerManager) UpdateListener(m *model.Listener) error {
// lock
lm.rwLock.Lock()
defer lm.rwLock.Unlock()
- ls, ok := lm.activeListenerService[m.Name]
+
+ // Use resolveListenerName to get the correct key
+ listenerKey := resolveListenerName(m)
+ ls, ok := lm.activeListenerService[listenerKey]
if !ok {
- return errors.New("ListenerManager UpdateListener error: listener not found")
+ return errors.Errorf("ListenerManager UpdateListener error: listener not found with key %s", listenerKey)
}
- logger.Infof("Update Listener %s", m.Name)
+ logger.Infof("Update Listener %s (key: %s)", m.Name, listenerKey)
ls.config = m
err := ls.Refresh(*m)
if err != nil {
diff --git a/pkg/server/pixiu_start.go b/pkg/server/pixiu_start.go
index 6473f402..3f04746d 100644
--- a/pkg/server/pixiu_start.go
+++ b/pkg/server/pixiu_start.go
@@ -141,6 +141,9 @@ func GetClusterManager() *ClusterManager {
}
func GetRouterManager() *RouterManager {
+ if server == nil {
+ return nil
+ }
return server.GetRouterManager()
}
diff --git a/pkg/server/router_manager.go b/pkg/server/router_manager.go
index 9301f532..4bc3670e 100644
--- a/pkg/server/router_manager.go
+++ b/pkg/server/router_manager.go
@@ -17,6 +17,10 @@
package server
+import (
+ "sync"
+)
+
import (
"github.com/pkg/errors"
)
@@ -33,6 +37,7 @@ type (
}
RouterManager struct {
+ mu sync.RWMutex
rls []RouterListener
}
)
@@ -43,19 +48,53 @@ func CreateDefaultRouterManager(server *Server, bs *model.Bootstrap) *RouterMana
}
func (rm *RouterManager) AddRouterListener(l RouterListener) {
+ rm.mu.Lock()
+ defer rm.mu.Unlock()
+
rm.rls = append(rm.rls, l)
}
+func (rm *RouterManager) RemoveRouterListener(l RouterListener) {
+ rm.mu.Lock()
+ defer rm.mu.Unlock()
+
+ for i, listener := range rm.rls {
+ if listener == l {
+ rm.rls = append(rm.rls[:i], rm.rls[i+1:]...)
+ return
+ }
+ }
+}
+
+func (rm *RouterManager) ClearRouterListeners() {
+ rm.mu.Lock()
+ defer rm.mu.Unlock()
+
+ rm.rls = nil
+}
+
func (rm *RouterManager) AddRouter(r *model.Router) {
logger.Infof("add router: %v", r)
- for _, l := range rm.rls {
+
+ rm.mu.RLock()
+ listeners := make([]RouterListener, len(rm.rls))
+ copy(listeners, rm.rls)
+ rm.mu.RUnlock()
+
+ for _, l := range listeners {
l.OnAddRouter(r)
}
}
func (rm *RouterManager) DeleteRouter(r *model.Router) {
logger.Infof("del router: %v", r)
- for _, l := range rm.rls {
+
+ rm.mu.RLock()
+ listeners := make([]RouterListener, len(rm.rls))
+ copy(listeners, rm.rls)
+ rm.mu.RUnlock()
+
+ for _, l := range listeners {
l.OnDeleteRouter(r)
}
}
@@ -73,7 +112,13 @@ func (rm *RouterManager) UpdateRoutes(oldRoutes []*model.Router, newRoutes []*mo
// Notify listeners to delete existing routes
for _, route := range oldRoutes {
logger.Debugf("Notifying listeners to delete route: %s", route.String())
- for _, listener := range rm.rls {
+
+ rm.mu.RLock()
+ listeners := make([]RouterListener, len(rm.rls))
+ copy(listeners, rm.rls)
+ rm.mu.RUnlock()
+
+ for _, listener := range listeners {
listener.OnDeleteRouter(route)
}
}
@@ -81,7 +126,13 @@ func (rm *RouterManager) UpdateRoutes(oldRoutes []*model.Router, newRoutes []*mo
// Notify listeners to add new routes
for _, route := range newRoutes {
logger.Debugf("Notifying listeners to add route: %s", route.String())
- for _, listener := range rm.rls {
+
+ rm.mu.RLock()
+ listeners := make([]RouterListener, len(rm.rls))
+ copy(listeners, rm.rls)
+ rm.mu.RUnlock()
+
+ for _, listener := range listeners {
listener.OnAddRouter(route)
}
}