| true | +|||
| addresses | +[]object | +
+ Requests for addresses beyond the ones the interface holds inside its
+network, such as a public IPv4 address in front of a private one. Each is
+reported in the interface's `externalAddresses` status.
+
+Omit this field for ordinary private addressing, which is the common case. + + Validations: |
+ false | +
| ipFamilies | +[]enum | +
+ The address families the interface must carry, in priority order. List
+[IPv6, IPv4] for a dual-stack interface. The first family listed holds the
+interface's primary address, which is the one reported as the instance's
+network IP.
+
+Every family listed must be satisfiable or the interface is never
+published, so asking for a family the network does not carry fails rather
+than yielding a partially addressed interface. + + Validations: + Default: [IPv6] + |
+ false | +
| name | +string | +
+ The name of the interface, such as eth0 or eth1. It is both the device
+name the guest operating system sees and the suffix of the interface
+claim's name, which is what keeps an interface's addresses with the
+instance slot across replacement.
+
+Immutable, because the guest is configured against it and the claim is
+named after it. + + Validations: + |
+ false |
| networkPolicy | object | @@ -160,6 +219,29 @@ will be of the lowest priority, and can effectively be prohibited from influencing network connectivity.false | +|
| reclaimPolicy | +enum | +
+ What becomes of the interface, and its addresses, when the instance slot
+it serves goes away.
+
+Delete returns the addresses to IPAM, so an instance recreated later comes
+back on different addresses. Retain keeps them reserved, and billable, so a
+later instance filling the same slot returns to the same addresses. Choose
+Retain when an address is published in DNS, allowed through a firewall, or
+otherwise depended on from outside.
+
+Both policies keep the addresses for as long as the slot exists, including
+across instance replacement. They differ only on scale-down and deletion.
+
+Immutable. An address keeps the policy it was allocated under. + + Validations: + Default: Delete + |
+ false |
| Name | +Type | +Description | +Required | +
|---|---|---|---|
| class | +string | +
+ The IPAM class to allocate from, such as public-ipv4.
+
+A class names a kind of address, and the platform decides which pool and
+prefix length serve it. A class never names a pool, a prefix length, or a
+CIDR, so a class cannot be used to ask for a particular address. + |
+ true | +
| Name | +Type | +Description | +Required | +||
|---|---|---|---|---|---|
| address | +string | +
+ The address the interface holds, in CIDR notation, such as 10.128.0.2/32
+or 2001:db8:a001::1/128.
+
+For IPv6 this may be a block delegated to the interface rather than a
+single address, such as 2001:db8:a001::/96. The interface owns the whole
+block and assigns within it. + |
+ true | +||
| family | +enum | +
+ The address family of this entry. + Enum: IPv4, IPv6 + |
+ true | +||
| class | +string | +
+ The IPAM class this address was allocated from, such as private-ipv6. It
+is empty for addresses requested by family rather than by class. + |
+ false | +||
| gateway | +string | +
+ The next hop the interface routes through for this family, such as
+10.128.0.1. It is empty until the subnet backing the network in this
+location exists. + |
+ false | +||
| primary | +boolean | +
+ Marks the address projected into `assignments.networkIP`.
+
+Exactly one address is primary for the interface as a whole, not one per
+family. It is the address of the first family listed in `ipFamilies`. |
false |
| string |
The external IP address used for the interface. A one to one NAT will be
-performed for this address with the interface's network IP. +performed for this address with the interface's network IP. It is a +projection of the first entry in the interface's `externalAddresses`. |
false | |
| networkIP | string |
- The IP address assigned as the primary IP from the attached network. + The IP address assigned as the primary IP from the attached network. It is +a projection of the primary entry in the interface's `addresses`. + |
+ false | +
| Name | +Type | +Description | +Required | +
|---|---|---|---|
| lastTransitionTime | +string | +
+ lastTransitionTime is the last time the condition transitioned from one status to another.
+This should be when the underlying condition changed. If that is not known, then using the time when the API field changed is acceptable. + + Format: date-time + |
+ true | +
| message | +string | +
+ message is a human readable message indicating details about the transition.
+This may be an empty string. + |
+ true | +
| reason | +string | +
+ reason contains a programmatic identifier indicating the reason for the condition's last transition.
+Producers of specific condition types may define expected values and meanings for this field,
+and whether the values are considered a guaranteed API.
+The value should be a CamelCase string.
+This field may not be empty. + |
+ true | +
| status | +enum | +
+ status of the condition, one of True, False, Unknown. + + Enum: True, False, Unknown + |
+ true | +
| type | +string | +
+ type of condition in CamelCase or in foo.example.com/CamelCase. + |
+ true | +
| observedGeneration | +integer | +
+ observedGeneration represents the .metadata.generation that the condition was set based upon.
+For instance, if .metadata.generation is currently 12, but the .status.conditions[x].observedGeneration is 9, the condition is out of date
+with respect to the current state of the instance. + + Format: int64 + Minimum: 0 |
false |
| Name | +Type | +Description | +Required | +
|---|---|---|---|
| address | +string | +
+ The externally reachable address, such as 203.0.113.10. It carries no
+prefix length. + |
+ true | +
| class | +string | +
+ The IPAM class this address was allocated from, such as public-ipv4. It
+matches a class requested in the interface's `addresses`. + |
+ true | +
| family | +enum | +
+ The address family of this entry. + + Enum: IPv4, IPv6 + |
+ true | +
| Name | +Type | +Description | +Required | +
|---|---|---|---|
| name | +string | +
+ name is the network interface name. + |
+ true | +
| Name | +Type | +Description | +Required | +
|---|---|---|---|
| apiVersion | +string | +compute.datumapis.com/v1alpha | +true | +
| kind | +string | +RuntimeClass | +true | +
| metadata | +object | +Refer to the Kubernetes API documentation for the fields of the `metadata` field. | +true | +
| spec | +object | +
+ Spec is the published contract for this execution tier. + |
+ false | +
| status | +object | +
+ Status is what the controller implementing this class reports about it. + + Default: map[conditions:[map[lastTransitionTime:1970-01-01T00:00:00Z message:Waiting for the class controller reason:Pending status:Unknown type:Accepted]]] + |
+ false | +
| Name | +Type | +Description | +Required | +
|---|---|---|---|
| capabilities | +object | +
+ What this class can serve, and what it cannot. + |
+ true | +
| controllerName | +string | +
+ The controller that implements this class. A provider watches for classes
+carrying its own controller name, claims them, and reports through the
+Accepted condition whether it can honor what they declare. A class whose
+controller never appears stays unclaimed, which this field makes visible.
+
+The field says which provider realizes the class. It does not say where
+the class can run. Cells advertise that separately, and placement uses
+their declaration. + + Validations: |
+ true | +
| isolation | +object | +
+ What separates a workload in this class from other tenants' workloads. + |
+ true | +
| default | +boolean | +
+ Whether an instance that selects no class runs in this one.
+
+Admission stamps the default onto a workload and never resolves it at
+read time. Moving the marker changes what new workloads get and leaves
+running ones in the tier, cost, and startup profile they were created
+with. At most one class in the catalog may set it. + |
+ false | +
| description | +string | +
+ What this tier is for and who should choose it. + |
+ false | +
| displayName | +string | +
+ The name to show a customer choosing a tier, for example "Unikernel fast
+path". + |
+ false | +
| lifecycle | +object | +
+ How quickly instances in this class start, and what can be done to them
+once they are running. + |
+ false | +
| Name | +Type | +Description | +Required | +
|---|---|---|---|
| compatibility | +string | +
+ What runs unmodified in this class and what does not. Customers need this
+statement before committing an image to the tier. + |
+ false | +
| features | +[]enum | +
+ The optional parts of the instance API this class serves. Anything absent
+is unsupported, so a class that omits a feature rejects requests for it
+rather than serving it by accident. + + Enum: sandboxRuntime, virtualMachineRuntime, configMapVolumes, secretVolumes, diskVolumes, deviceVolumeAttachments, envFrom, imagePullSecrets + |
+ false | +
| Name | +Type | +Description | +Required | +
|---|---|---|---|
| boundary | +string | +
+ A short, stable token for the boundary, for example "unikernel" or
+"virtual-machine". The values are deliberately not enumerated. The
+boundaries the platform offers grow with the catalog, and fixing them in
+the schema would make each new tier an API change. + |
+ true | +
| description | +string | +
+ A description of the boundary and what it separates, suitable for a
+customer to show an auditor. + |
+ false | +
| Name | +Type | +Description | +Required | +
|---|---|---|---|
| description | +string | +
+ Anything about startup or lifecycle a customer needs that the fields
+above cannot express. + |
+ false | +
| operations | +[]enum | +
+ The lifecycle operations this class offers. Declaring none is accurate
+for a class whose isolation boundary does not allow them. + + Enum: Suspend, Resume, Snapshot + |
+ false | +
| typicalStartupTime | +string | +
+ The cold start a customer should plan for, measured from instance
+creation to the instance running. Startup time is the main difference
+between tiers, so the class publishes it rather than leaving customers to
+measure it. + |
+ false | +
| Name | +Type | +Description | +Required | +
|---|---|---|---|
| conditions | +[]object | +
+ + |
+ false | +
| Name | +Type | +Description | +Required | +
|---|---|---|---|
| lastTransitionTime | +string | +
+ lastTransitionTime is the last time the condition transitioned from one status to another.
+This should be when the underlying condition changed. If that is not known, then using the time when the API field changed is acceptable. + + Format: date-time + |
+ true | +
| message | +string | +
+ message is a human readable message indicating details about the transition.
+This may be an empty string. + |
+ true | +
| reason | +string | +
+ reason contains a programmatic identifier indicating the reason for the condition's last transition.
+Producers of specific condition types may define expected values and meanings for this field,
+and whether the values are considered a guaranteed API.
+The value should be a CamelCase string.
+This field may not be empty. + |
+ true | +
| status | +enum | +
+ status of the condition, one of True, False, Unknown. + + Enum: True, False, Unknown + |
+ true | +
| type | +string | +
+ type of condition in CamelCase or in foo.example.com/CamelCase. + |
+ true | +
| observedGeneration | +integer | +
+ observedGeneration represents the .metadata.generation that the condition was set based upon.
+For instance, if .metadata.generation is currently 12, but the .status.conditions[x].observedGeneration is 9, the condition is out of date
+with respect to the current state of the instance. + + Format: int64 + Minimum: 0 + |
+ false | +
| Name | +Type | +Description | +Required | +
|---|---|---|---|
| name | +string | +
+ Name of a datum location + |
+ true | +
| true | +|||
| addresses | +[]object | +
+ Requests for addresses beyond the ones the interface holds inside its
+network, such as a public IPv4 address in front of a private one. Each is
+reported in the interface's `externalAddresses` status.
+
+Omit this field for ordinary private addressing, which is the common case. + + Validations: |
+ false | +
| ipFamilies | +[]enum | +
+ The address families the interface must carry, in priority order. List
+[IPv6, IPv4] for a dual-stack interface. The first family listed holds the
+interface's primary address, which is the one reported as the instance's
+network IP.
+
+Every family listed must be satisfiable or the interface is never
+published, so asking for a family the network does not carry fails rather
+than yielding a partially addressed interface. + + Validations: + Default: [IPv6] + |
+ false | +
| name | +string | +
+ The name of the interface, such as eth0 or eth1. It is both the device
+name the guest operating system sees and the suffix of the interface
+claim's name, which is what keeps an interface's addresses with the
+instance slot across replacement.
+
+Immutable, because the guest is configured against it and the claim is
+named after it. + + Validations: + |
+ false |
| networkPolicy | object | @@ -419,6 +505,29 @@ will be of the lowest priority, and can effectively be prohibited from influencing network connectivity.false | +|
| reclaimPolicy | +enum | +
+ What becomes of the interface, and its addresses, when the instance slot
+it serves goes away.
+
+Delete returns the addresses to IPAM, so an instance recreated later comes
+back on different addresses. Retain keeps them reserved, and billable, so a
+later instance filling the same slot returns to the same addresses. Choose
+Retain when an address is published in DNS, allowed through a firewall, or
+otherwise depended on from outside.
+
+Both policies keep the addresses for as long as the slot exists, including
+across instance replacement. They differ only on scale-down and deletion.
+
+Immutable. An address keeps the policy it was allocated under. + + Validations: + Default: Delete + |
+ false |
| Name | +Type | +Description | +Required | +
|---|---|---|---|
| class | +string | +
+ The IPAM class to allocate from, such as public-ipv4.
+
+A class names a kind of address, and the platform decides which pool and
+prefix length serve it. A class never names a pool, a prefix length, or a
+CIDR, so a class cannot be used to ask for a particular address. + |
+ true | +
| Name | -Type | -Description | -Required | -
|---|---|---|---|
| name | -string | -
- Name of a datum location - |
- true | -
| namespace | -string | -
- Namespace for the datum location - |
- true | -
| Name | +Type | +Description | +Required | +
|---|---|---|---|
| matchExpressions | +[]object | +
+ matchExpressions is a list of label selector requirements. The requirements are ANDed. + |
+ false | +
| matchLabels | +map[string]string | +
+ matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels
+map is equivalent to an element of matchExpressions, whose key field is "key", the
+operator is "In", and the values array contains only "value". The requirements are ANDed. + |
+ false | +
| Name | +Type | +Description | +Required | +
|---|---|---|---|
| key | +string | +
+ key is the label key that the selector applies to. + |
+ true | +
| operator | +string | +
+ operator represents a key's relationship to a set of values.
+Valid operators are In, NotIn, Exists and DoesNotExist. + |
+ true | +
| values | +[]string | +
+ values is an array of string values. If the operator is In or NotIn,
+the values array must be non-empty. If the operator is Exists or DoesNotExist,
+the values array must be empty. This array is replaced during a strategic
+merge patch. + |
+ false | +
| Name | +Type | +Description | +Required | +
|---|---|---|---|
| name | +string | +
+ Name of a datum location + |
+ true | +
| true | +|||
| addresses | +[]object | +
+ Requests for addresses beyond the ones the interface holds inside its
+network, such as a public IPv4 address in front of a private one. Each is
+reported in the interface's `externalAddresses` status.
+
+Omit this field for ordinary private addressing, which is the common case. + + Validations: |
+ false | +
| ipFamilies | +[]enum | +
+ The address families the interface must carry, in priority order. List
+[IPv6, IPv4] for a dual-stack interface. The first family listed holds the
+interface's primary address, which is the one reported as the instance's
+network IP.
+
+Every family listed must be satisfiable or the interface is never
+published, so asking for a family the network does not carry fails rather
+than yielding a partially addressed interface. + + Validations: + Default: [IPv6] + |
+ false | +
| name | +string | +
+ The name of the interface, such as eth0 or eth1. It is both the device
+name the guest operating system sees and the suffix of the interface
+claim's name, which is what keeps an interface's addresses with the
+instance slot across replacement.
+
+Immutable, because the guest is configured against it and the claim is
+named after it. + + Validations: + |
+ false |
| networkPolicy | object | @@ -430,6 +630,29 @@ will be of the lowest priority, and can effectively be prohibited from influencing network connectivity.false | +|
| reclaimPolicy | +enum | +
+ What becomes of the interface, and its addresses, when the instance slot
+it serves goes away.
+
+Delete returns the addresses to IPAM, so an instance recreated later comes
+back on different addresses. Retain keeps them reserved, and billable, so a
+later instance filling the same slot returns to the same addresses. Choose
+Retain when an address is published in DNS, allowed through a firewall, or
+otherwise depended on from outside.
+
+Both policies keep the addresses for as long as the slot exists, including
+across instance replacement. They differ only on scale-down and deletion.
+
+Immutable. An address keeps the policy it was allocated under. + + Validations: + Default: Delete + |
+ false |
| Name | +Type | +Description | +Required | +
|---|---|---|---|
| class | +string | +
+ The IPAM class to allocate from, such as public-ipv4.
+
+A class names a kind of address, and the platform decides which pool and
+prefix length serve it. A class never names a pool, a prefix length, or a
+CIDR, so a class cannot be used to ask for a particular address. + |
+ true | +
| Name | +Type | +Description | +Required | +
|---|---|---|---|
| name | +string | +
+ Name of a datum location + |
+ true | +
and
+// city--class-, and selected on the topology.datum.net/city-code
+// label, which is how the remaining users are counted. A deployment whose hub
+// copy is already gone leaves no city to clean up by, and is logged.
+func (r *WorkloadDeploymentFederator) cleanupLegacyPropagationPolicies(ctx context.Context, downstreamNS, city string) error {
+ logger := log.FromContext(ctx)
+ if city == "" {
+ logger.Info("legacy deployment carries no city on its hub copy; leaving its PropagationPolicy for a later cleanup", "downstreamNamespace", downstreamNS)
+ return nil
+ }
+
+ var remaining computev1alpha.WorkloadDeploymentList
+ if err := r.FederationClient.List(ctx, &remaining,
+ client.InNamespace(downstreamNS),
+ client.MatchingLabels{networkingv1alpha.TopologyCityCodeKey: city},
+ ); err != nil {
+ return fmt.Errorf("failed to list remaining legacy downstream deployments for city %q: %w", city, err)
+ }
+ if len(remaining.Items) > 0 {
+ return nil
+ }
+
+ var policies karmadapolicyv1alpha1.PropagationPolicyList
+ if err := r.FederationClient.List(ctx, &policies, client.InNamespace(downstreamNS)); err != nil {
+ return fmt.Errorf("failed to list PropagationPolicies in %s: %w", downstreamNS, err)
+ }
+
+ prefix := "city-" + sanitizePolicyNameSegment(city)
+ for i := range policies.Items {
+ policy := &policies.Items[i]
+ if policy.Name != prefix && !strings.HasPrefix(policy.Name, prefix+"-class-") {
+ continue
+ }
+ if err := r.FederationClient.Delete(ctx, policy); client.IgnoreNotFound(err) != nil {
+ return fmt.Errorf("failed to delete legacy PropagationPolicy %s/%s: %w", downstreamNS, policy.Name, err)
+ }
+ logger.Info("deleted legacy PropagationPolicy (no more deployments for city)", "policy", policy.Name, "city", city, "downstreamNamespace", downstreamNS)
+ }
+ return nil
+}
+
// recordFederationNamespace stamps the resolved hub namespace onto the project
// WorkloadDeployment. It patches only when the value changes, so it adds no
// write traffic in the steady state.
@@ -323,7 +381,7 @@ func (r *WorkloadDeploymentFederator) upsertDownstreamDeployment(
if kd.Labels == nil {
kd.Labels = make(map[string]string)
}
- kd.Labels[cityCodeLabel] = deployment.Spec.CityCode
+ kd.Labels[locationLabel] = deployment.Spec.LocationRef.Name
kd.Labels[downstreamclient.UpstreamOwnerNamespaceLabel] = deployment.Namespace
// A class-aware PropagationPolicy selects on this label, so the label
// must track the policy that propagates this deployment. A leftover
@@ -375,21 +433,21 @@ func (r *WorkloadDeploymentFederator) upsertDownstreamDeployment(
}
// ensurePropagationPolicy creates or updates a PropagationPolicy in the downstream
-// namespace that selects all WorkloadDeployments with the given city-code label
+// namespace that selects all WorkloadDeployments with the given location label
// and targets clusters carrying the same label.
//
-// A non-empty runtimeClass narrows both halves of that match to the (city,
+// A non-empty runtimeClass narrows both halves of that match to the (location,
// class) pair. Only deployments in the class are selected, and only cells that
// advertise they serve the class are targeted. An empty runtimeClass adds no
// class selector, so cells that advertise no class remain eligible.
func (r *WorkloadDeploymentFederator) ensurePropagationPolicy(
ctx context.Context,
downstreamNS string,
- cityCode string,
+ locationName string,
runtimeClass string,
) error {
- deploymentLabels := map[string]string{cityCodeLabel: cityCode}
- clusterLabels := map[string]string{cityCodeLabel: cityCode}
+ deploymentLabels := map[string]string{locationLabel: locationName}
+ clusterLabels := map[string]string{locationLabel: locationName}
if runtimeClass != "" {
deploymentLabels[computev1alpha.RuntimeClassLabel] = runtimeClass
clusterLabels[computev1alpha.RuntimeClassServedLabel(runtimeClass)] = computev1alpha.RuntimeClassServedLabelValue
@@ -397,17 +455,17 @@ func (r *WorkloadDeploymentFederator) ensurePropagationPolicy(
pp := &karmadapolicyv1alpha1.PropagationPolicy{
ObjectMeta: metav1.ObjectMeta{
- Name: propagationPolicyNameFor(cityCode, runtimeClass),
+ Name: propagationPolicyNameFor(locationName, runtimeClass),
Namespace: downstreamNS,
},
}
result, err := controllerutil.CreateOrPatch(ctx, r.FederationClient, pp, func() error {
pp.Spec = karmadapolicyv1alpha1.PropagationSpec{
- // Select WorkloadDeployments by city-code label, plus ALL
+ // Select WorkloadDeployments by location label, plus ALL
// companion ConfigMaps and Secrets in this namespace that carry the
// referenced-data label. The label selector on ConfigMap/Secret is
- // city-code-agnostic — companions are shared across city codes when
+ // location-agnostic — companions are shared across locations when
// multiple WDs reference the same source. Karmada propagates the
// entire set to matching clusters in one policy, so companions
// co-arrive with their WorkloadDeployment.
@@ -426,7 +484,7 @@ func (r *WorkloadDeploymentFederator) ensurePropagationPolicy(
{
// Propagate companion ConfigMaps alongside WorkloadDeployments.
// The referenced-data label is the only selector needed; there
- // is no per-city partitioning of companions.
+ // is no per-location partitioning of companions.
APIVersion: corev1.SchemeGroupVersion.String(),
Kind: kindConfigMap,
LabelSelector: &metav1.LabelSelector{
@@ -447,7 +505,7 @@ func (r *WorkloadDeploymentFederator) ensurePropagationPolicy(
},
},
Placement: karmadapolicyv1alpha1.Placement{
- // Route to clusters that carry the same city-code label. POP-cell
+ // Route to clusters that carry the same location label. POP-cell
// clusters registered with the downstream control plane must be
// labeled accordingly.
ClusterAffinity: &karmadapolicyv1alpha1.ClusterAffinity{
@@ -460,10 +518,10 @@ func (r *WorkloadDeploymentFederator) ensurePropagationPolicy(
return nil
})
if err != nil {
- return fmt.Errorf("failed to upsert PropagationPolicy for city %q in %s: %w", cityCode, downstreamNS, err)
+ return fmt.Errorf("failed to upsert PropagationPolicy for location %q in %s: %w", locationName, downstreamNS, err)
}
- log.FromContext(ctx).Info("upserted PropagationPolicy", "result", result, "cityCode", cityCode, "runtimeClass", runtimeClass, "downstreamNamespace", downstreamNS)
+ log.FromContext(ctx).Info("upserted PropagationPolicy", "result", result, "location", locationName, "runtimeClass", runtimeClass, "downstreamNamespace", downstreamNS)
return nil
}
@@ -538,27 +596,27 @@ func (r *WorkloadDeploymentFederator) syncStatusFromDownstream(
}
// cleanupPropagationPolicyIfUnused deletes the PropagationPolicy for the given
-// city code and runtime class if no WorkloadDeployments propagated by it remain
+// location and runtime class if no WorkloadDeployments propagated by it remain
// in the downstream namespace.
//
-// Usage is counted by the (city, class) pair because the policy is keyed by
-// that pair. Counting the city alone would keep a class policy alive for
-// deployments in another class, and would keep the no-class policy alive for
-// deployments that no longer use it.
+// Usage is counted by the (location, class) pair because the policy is keyed
+// by that pair. Counting the location alone would keep a class policy alive
+// for deployments in another class, and would keep the no-class policy alive
+// for deployments that no longer use it.
func (r *WorkloadDeploymentFederator) cleanupPropagationPolicyIfUnused(
ctx context.Context,
downstreamNS string,
- cityCode string,
+ locationName string,
runtimeClass string,
) error {
- // The webhook requires cityCode, so an empty value here is corruption. An
+ // The webhook requires locationRef.name, so an empty value here is corruption. An
// empty-valued label selector would match the wrong deployment set and
// mis-decide whether the PropagationPolicy is still in use.
- if cityCode == "" {
- return fmt.Errorf("cannot evaluate PropagationPolicy usage in namespace %q: city code is empty", downstreamNS)
+ if locationName == "" {
+ return fmt.Errorf("cannot evaluate PropagationPolicy usage in namespace %q: location name is empty", downstreamNS)
}
- selector, err := r.propagationPolicyUsageSelector(cityCode, runtimeClass)
+ selector, err := r.propagationPolicyUsageSelector(locationName, runtimeClass)
if err != nil {
return err
}
@@ -568,7 +626,7 @@ func (r *WorkloadDeploymentFederator) cleanupPropagationPolicyIfUnused(
client.InNamespace(downstreamNS),
selector,
); err != nil {
- return fmt.Errorf("failed to list remaining downstream deployments for city %q: %w", cityCode, err)
+ return fmt.Errorf("failed to list remaining downstream deployments for location %q: %w", locationName, err)
}
if len(remaining.Items) > 0 {
@@ -578,15 +636,15 @@ func (r *WorkloadDeploymentFederator) cleanupPropagationPolicyIfUnused(
pp := &karmadapolicyv1alpha1.PropagationPolicy{
ObjectMeta: metav1.ObjectMeta{
- Name: propagationPolicyNameFor(cityCode, runtimeClass),
+ Name: propagationPolicyNameFor(locationName, runtimeClass),
Namespace: downstreamNS,
},
}
if err := r.FederationClient.Delete(ctx, pp); client.IgnoreNotFound(err) != nil {
- return fmt.Errorf("failed to delete PropagationPolicy for city %q in %s: %w", cityCode, downstreamNS, err)
+ return fmt.Errorf("failed to delete PropagationPolicy for location %q in %s: %w", locationName, downstreamNS, err)
}
- log.FromContext(ctx).Info("deleted PropagationPolicy (no more deployments for city)", "cityCode", cityCode, "runtimeClass", runtimeClass, "downstreamNamespace", downstreamNS)
+ log.FromContext(ctx).Info("deleted PropagationPolicy (no more deployments for location)", "location", locationName, "runtimeClass", runtimeClass, "downstreamNamespace", downstreamNS)
return nil
}
@@ -604,33 +662,33 @@ func (r *WorkloadDeploymentFederator) propagationRuntimeClass(deployment *comput
}
// propagationPolicyUsageSelector returns the selector matching exactly the
-// deployments a (city, class) policy propagates.
+// deployments a (location, class) policy propagates.
//
// The no-class policy matches only deployments that carry no class label, so a
// class-labeled deployment does not keep that policy alive.
-func (r *WorkloadDeploymentFederator) propagationPolicyUsageSelector(cityCode, runtimeClass string) (client.ListOption, error) {
+func (r *WorkloadDeploymentFederator) propagationPolicyUsageSelector(locationName, runtimeClass string) (client.ListOption, error) {
if runtimeClass != "" {
return client.MatchingLabels{
- cityCodeLabel: cityCode,
+ locationLabel: locationName,
computev1alpha.RuntimeClassLabel: runtimeClass,
}, nil
}
if !r.RuntimeClassesEnabled {
- return client.MatchingLabels{cityCodeLabel: cityCode}, nil
+ return client.MatchingLabels{locationLabel: locationName}, nil
}
unclassed, err := labels.NewRequirement(computev1alpha.RuntimeClassLabel, selection.DoesNotExist, nil)
if err != nil {
- return nil, fmt.Errorf("failed to build runtime class selector for city %q: %w", cityCode, err)
+ return nil, fmt.Errorf("failed to build runtime class selector for location %q: %w", locationName, err)
}
return client.MatchingLabelsSelector{
- Selector: labels.SelectorFromSet(labels.Set{cityCodeLabel: cityCode}).Add(*unclassed),
+ Selector: labels.SelectorFromSet(labels.Set{locationLabel: locationName}).Add(*unclassed),
}, nil
}
-// runtimeClassPlacementRefusal reports that no cell in the deployment's city
-// advertises its runtime class. The Cluster read targets the federation hub,
+// runtimeClassPlacementRefusal reports that no cell serving the deployment's
+// location advertises its runtime class. The Cluster read targets the federation hub,
// which the hand-written compute-manager ClusterRole in
// config/base/downstream-rbac grants. The generated role covers the project
// control planes and is not involved.
@@ -640,7 +698,7 @@ func (r *WorkloadDeploymentFederator) propagationPolicyUsageSelector(cityCode, r
// because the customer can change either one.
func (r *WorkloadDeploymentFederator) runtimeClassPlacementRefusal(
ctx context.Context,
- cityCode string,
+ locationName string,
runtimeClass string,
) (*metav1.Condition, error) {
if runtimeClass == "" {
@@ -649,10 +707,10 @@ func (r *WorkloadDeploymentFederator) runtimeClassPlacementRefusal(
var cells karmadaclusterv1alpha1.ClusterList
if err := r.FederationClient.List(ctx, &cells, client.MatchingLabels{
- cityCodeLabel: cityCode,
+ locationLabel: locationName,
computev1alpha.RuntimeClassServedLabel(runtimeClass): computev1alpha.RuntimeClassServedLabelValue,
}); err != nil {
- return nil, fmt.Errorf("failed to list cells serving runtime class %q in city %q: %w", runtimeClass, cityCode, err)
+ return nil, fmt.Errorf("failed to list cells serving runtime class %q at location %q: %w", runtimeClass, locationName, err)
}
if len(cells.Items) > 0 {
@@ -665,7 +723,7 @@ func (r *WorkloadDeploymentFederator) runtimeClassPlacementRefusal(
Reason: computev1alpha.WorkloadDeploymentReasonRuntimeClassNotServed,
Message: fmt.Sprintf(
"No cell in %s serves runtime class %q, so no instance for this deployment can be placed. Select a runtime class the location offers, or a location that offers this class.",
- cityCode, runtimeClass),
+ locationName, runtimeClass),
}, nil
}
@@ -866,19 +924,19 @@ func projectClusterNameFromLabel(encoded string) string {
return name
}
-// propagationPolicyNameFor returns the PropagationPolicy name for a given city
-// code and runtime class. The name is stable and deterministic so that multiple
-// reconciles of different deployments sharing the same pair converge on the
-// same policy.
+// propagationPolicyNameFor returns the PropagationPolicy name for a given
+// location and runtime class. The name is stable and deterministic so that
+// multiple reconciles of different deployments sharing the same pair converge
+// on the same policy.
//
-// An empty runtimeClass yields a city-only name. Renaming an existing policy
-// would orphan it and briefly leave running deployments unpropagated.
-func propagationPolicyNameFor(cityCode, runtimeClass string) string {
- sanitized := sanitizePolicyNameSegment(cityCode)
+// An empty runtimeClass yields a location-only name. Renaming an existing
+// policy would orphan it and briefly leave running deployments unpropagated.
+func propagationPolicyNameFor(locationName, runtimeClass string) string {
+ sanitized := sanitizePolicyNameSegment(locationName)
if runtimeClass == "" {
- return fmt.Sprintf("city-%s", sanitized)
+ return fmt.Sprintf("location-%s", sanitized)
}
- return fmt.Sprintf("city-%s-class-%s", sanitized, sanitizePolicyNameSegment(runtimeClass))
+ return fmt.Sprintf("location-%s-class-%s", sanitized, sanitizePolicyNameSegment(runtimeClass))
}
func sanitizePolicyNameSegment(segment string) string {
diff --git a/internal/controller/workloaddeployment_federator_runtimeclass_test.go b/internal/controller/workloaddeployment_federator_runtimeclass_test.go
index f39ff2b8..4f5febd1 100644
--- a/internal/controller/workloaddeployment_federator_runtimeclass_test.go
+++ b/internal/controller/workloaddeployment_federator_runtimeclass_test.go
@@ -18,11 +18,12 @@ import (
"sigs.k8s.io/controller-runtime/pkg/client"
computev1alpha "go.datum.net/compute/api/v1alpha"
+ locationsv1alpha1 "go.miloapis.com/locations/api/v1alpha1"
)
-// testCityPolicyLAX is the PropagationPolicy name for the test city when no
-// runtime class is selected.
-const testCityPolicyLAX = "city-lax"
+// testLocationPolicy is the PropagationPolicy name for the test location when
+// no runtime class is selected.
+const testLocationPolicy = "location-us-west-2"
// These runtime class names are invented rather than the ones the platform
// ships. Propagation must key off whatever class the deployment carries, and
@@ -38,11 +39,11 @@ func withRuntimeClass(class string) func(*computev1alpha.WorkloadDeployment) {
}
}
-// testCell returns a Karmada Cluster serving the given runtime classes in the
-// given city. A cell is a point-of-presence cluster registered with the
+// testCell returns a Karmada Cluster serving the given runtime classes at the
+// given location. A cell is a point-of-presence cluster registered with the
// federation hub.
-func testCell(name, cityCode string, classes ...string) *karmadaclusterv1alpha1.Cluster {
- cellLabels := map[string]string{cityCodeLabel: cityCode}
+func testCell(name, location string, classes ...string) *karmadaclusterv1alpha1.Cluster {
+ cellLabels := map[string]string{locationLabel: location}
for _, class := range classes {
cellLabels[computev1alpha.RuntimeClassServedLabel(class)] = computev1alpha.RuntimeClassServedLabelValue
}
@@ -53,9 +54,9 @@ func testCell(name, cityCode string, classes ...string) *karmadaclusterv1alpha1.
// hubSiblingDeployment returns a hub-namespace WorkloadDeployment other than
// the one under test. It carries the labels the federator stamps for the given
-// city and runtime class.
-func hubSiblingDeployment(cityCode, runtimeClass string) *computev1alpha.WorkloadDeployment {
- wdLabels := map[string]string{cityCodeLabel: cityCode}
+// location and runtime class.
+func hubSiblingDeployment(location, runtimeClass string) *computev1alpha.WorkloadDeployment {
+ wdLabels := map[string]string{locationLabel: location}
if runtimeClass != "" {
wdLabels[computev1alpha.RuntimeClassLabel] = runtimeClass
}
@@ -66,7 +67,7 @@ func hubSiblingDeployment(cityCode, runtimeClass string) *computev1alpha.Workloa
Labels: wdLabels,
},
Spec: computev1alpha.WorkloadDeploymentSpec{
- CityCode: cityCode,
+ LocationRef: locationsv1alpha1.LocationReference{Name: location},
PlacementName: testDefaultPlacement,
WorkloadRef: computev1alpha.WorkloadReference{Name: rdTestWorkloadName},
ScaleSettings: computev1alpha.HorizontalScaleSettings{MinReplicas: 1},
@@ -93,34 +94,34 @@ func TestWorkloadDeploymentFederator_ClassAwarePropagation(t *testing.T) {
name: "gate off, class selected — propagates class-blind",
classesEnabled: false,
specClass: testClassBasalt,
- wantPolicyName: testCityPolicyLAX,
+ wantPolicyName: testLocationPolicy,
wantWDLabel: "",
- wantClusterLabels: map[string]string{cityCodeLabel: testCityCodeLAX},
+ wantClusterLabels: map[string]string{locationLabel: testFederatorLocation},
},
{
name: "gate off, no class — propagates class-blind",
classesEnabled: false,
specClass: "",
- wantPolicyName: testCityPolicyLAX,
+ wantPolicyName: testLocationPolicy,
wantWDLabel: "",
- wantClusterLabels: map[string]string{cityCodeLabel: testCityCodeLAX},
+ wantClusterLabels: map[string]string{locationLabel: testFederatorLocation},
},
{
name: "gate on, no class — propagates class-blind",
classesEnabled: true,
specClass: "",
- wantPolicyName: testCityPolicyLAX,
+ wantPolicyName: testLocationPolicy,
wantWDLabel: "",
- wantClusterLabels: map[string]string{cityCodeLabel: testCityCodeLAX},
+ wantClusterLabels: map[string]string{locationLabel: testFederatorLocation},
},
{
name: "gate on, class selected — propagates to cells serving it",
classesEnabled: true,
specClass: testClassBasalt,
- wantPolicyName: "city-lax-class-basalt",
+ wantPolicyName: "location-us-west-2-class-basalt",
wantWDLabel: testClassBasalt,
wantClusterLabels: map[string]string{
- cityCodeLabel: testCityCodeLAX,
+ locationLabel: testFederatorLocation,
computev1alpha.RuntimeClassServedLabel(testClassBasalt): computev1alpha.RuntimeClassServedLabelValue,
},
},
@@ -133,7 +134,7 @@ func TestWorkloadDeploymentFederator_ClassAwarePropagation(t *testing.T) {
wd := testWorkloadDeployment(withFinalizer, withRuntimeClass(tt.specClass))
projectClient := newProjectFakeClient(testProjectNamespace(), wd)
karmadaClient := newKarmadaFakeClient(
- testCell("lax-cell", testCityCodeLAX, testClassBasalt),
+ testCell("lax-cell", testFederatorLocation, testClassBasalt),
)
r := newTestFederator(projectClient, karmadaClient)
r.RuntimeClassesEnabled = tt.classesEnabled
@@ -147,7 +148,7 @@ func TestWorkloadDeploymentFederator_ClassAwarePropagation(t *testing.T) {
Name: testWDName,
Namespace: testKarmadaNSStr,
}, &karmadaWD))
- assert.Equal(t, testCityCodeLAX, karmadaWD.Labels[cityCodeLabel])
+ assert.Equal(t, testFederatorLocation, karmadaWD.Labels[locationLabel])
assert.Equal(t, tt.wantWDLabel, karmadaWD.Labels[computev1alpha.RuntimeClassLabel])
var pp karmadapolicyv1alpha1.PropagationPolicy
@@ -161,7 +162,7 @@ func TestWorkloadDeploymentFederator_ClassAwarePropagation(t *testing.T) {
require.Len(t, pp.Spec.ResourceSelectors, 3)
wdSel := pp.Spec.ResourceSelectors[0]
require.NotNil(t, wdSel.LabelSelector)
- assert.Equal(t, testCityCodeLAX, wdSel.LabelSelector.MatchLabels[cityCodeLabel])
+ assert.Equal(t, testFederatorLocation, wdSel.LabelSelector.MatchLabels[locationLabel])
assert.Equal(t, tt.wantWDLabel, wdSel.LabelSelector.MatchLabels[computev1alpha.RuntimeClassLabel])
require.NotNil(t, pp.Spec.Placement.ClusterAffinity)
@@ -171,17 +172,17 @@ func TestWorkloadDeploymentFederator_ClassAwarePropagation(t *testing.T) {
}
}
-// TestCleanupPropagationPolicyIfUnused_PerCityAndClass verifies the policy is
+// TestCleanupPropagationPolicyIfUnused_PerLocationAndClass verifies the policy is
// removed only when no deployment it propagates remains. A deployment in
// another runtime class must not keep a class policy alive, and a class-labeled
// deployment must not keep the no-class policy alive.
-func TestCleanupPropagationPolicyIfUnused_PerCityAndClass(t *testing.T) {
+func TestCleanupPropagationPolicyIfUnused_PerLocationAndClass(t *testing.T) {
t.Parallel()
tests := []struct {
name string
classesEnabled bool
- cityCode string
+ location string
runtimeClass string
remaining []client.Object
wantPPGone bool
@@ -189,54 +190,54 @@ func TestCleanupPropagationPolicyIfUnused_PerCityAndClass(t *testing.T) {
{
name: "gate off, no siblings — removed",
classesEnabled: false,
- cityCode: testCityCodeLAX,
+ location: testFederatorLocation,
wantPPGone: true,
},
{
- name: "gate off, city sibling — kept",
+ name: "gate off, location sibling — kept",
classesEnabled: false,
- cityCode: testCityCodeLAX,
- remaining: []client.Object{hubSiblingDeployment(testCityCodeLAX, "")},
+ location: testFederatorLocation,
+ remaining: []client.Object{hubSiblingDeployment(testFederatorLocation, "")},
wantPPGone: false,
},
{
- name: "same city and class — kept",
+ name: "same location and class — kept",
classesEnabled: true,
- cityCode: testCityCodeLAX,
+ location: testFederatorLocation,
runtimeClass: testClassAzurite,
- remaining: []client.Object{hubSiblingDeployment(testCityCodeLAX, testClassAzurite)},
+ remaining: []client.Object{hubSiblingDeployment(testFederatorLocation, testClassAzurite)},
wantPPGone: false,
},
{
- name: "same city, other class — removed",
+ name: "same location, other class — removed",
classesEnabled: true,
- cityCode: testCityCodeLAX,
+ location: testFederatorLocation,
runtimeClass: testClassAzurite,
- remaining: []client.Object{hubSiblingDeployment(testCityCodeLAX, testClassBasalt)},
+ remaining: []client.Object{hubSiblingDeployment(testFederatorLocation, testClassBasalt)},
wantPPGone: true,
},
{
- name: "other city, same class — removed",
+ name: "other location, same class — removed",
classesEnabled: true,
- cityCode: testCityCodeLAX,
+ location: testFederatorLocation,
runtimeClass: testClassAzurite,
- remaining: []client.Object{hubSiblingDeployment("SEA", testClassAzurite)},
+ remaining: []client.Object{hubSiblingDeployment(testWestLocationName, testClassAzurite)},
wantPPGone: true,
},
{
name: "class-blind policy, class-labeled sibling — removed",
classesEnabled: true,
- cityCode: testCityCodeLAX,
+ location: testFederatorLocation,
runtimeClass: "",
- remaining: []client.Object{hubSiblingDeployment(testCityCodeLAX, testClassAzurite)},
+ remaining: []client.Object{hubSiblingDeployment(testFederatorLocation, testClassAzurite)},
wantPPGone: true,
},
{
name: "class-blind policy, unclassed sibling — kept",
classesEnabled: true,
- cityCode: testCityCodeLAX,
+ location: testFederatorLocation,
runtimeClass: "",
- remaining: []client.Object{hubSiblingDeployment(testCityCodeLAX, "")},
+ remaining: []client.Object{hubSiblingDeployment(testFederatorLocation, "")},
wantPPGone: false,
},
}
@@ -245,7 +246,7 @@ func TestCleanupPropagationPolicyIfUnused_PerCityAndClass(t *testing.T) {
t.Run(tt.name, func(t *testing.T) {
t.Parallel()
- ppName := propagationPolicyNameFor(tt.cityCode, tt.runtimeClass)
+ ppName := propagationPolicyNameFor(tt.location, tt.runtimeClass)
objs := []client.Object{
&corev1.Namespace{ObjectMeta: metav1.ObjectMeta{Name: testKarmadaNSStr}},
&karmadapolicyv1alpha1.PropagationPolicy{
@@ -259,7 +260,7 @@ func TestCleanupPropagationPolicyIfUnused_PerCityAndClass(t *testing.T) {
r.RuntimeClassesEnabled = tt.classesEnabled
ctx := context.Background()
- require.NoError(t, r.cleanupPropagationPolicyIfUnused(ctx, testKarmadaNSStr, tt.cityCode, tt.runtimeClass))
+ require.NoError(t, r.cleanupPropagationPolicyIfUnused(ctx, testKarmadaNSStr, tt.location, tt.runtimeClass))
var pp karmadapolicyv1alpha1.PropagationPolicy
err := karmadaClient.Get(ctx, types.NamespacedName{Name: ppName, Namespace: testKarmadaNSStr}, &pp)
@@ -286,24 +287,24 @@ func TestWorkloadDeploymentFederator_UnservedRuntimeClassCondition(t *testing.T)
wantReason string
}{
{
- name: "no cell in the city serves the class",
+ name: "no cell at the location serves the class",
classesEnabled: true,
specClass: testClassBasalt,
- cells: []client.Object{testCell("lax-cell", testCityCodeLAX, testClassAzurite)},
+ cells: []client.Object{testCell("lax-cell", testFederatorLocation, testClassAzurite)},
wantReason: computev1alpha.WorkloadDeploymentReasonRuntimeClassNotServed,
},
{
name: "the class is served elsewhere, not here",
classesEnabled: true,
specClass: testClassBasalt,
- cells: []client.Object{testCell("sea-cell", "SEA", testClassBasalt)},
+ cells: []client.Object{testCell("sea-cell", testWestLocationName, testClassBasalt)},
wantReason: computev1alpha.WorkloadDeploymentReasonRuntimeClassNotServed,
},
{
name: "a cell serves the class",
classesEnabled: true,
specClass: testClassBasalt,
- cells: []client.Object{testCell("lax-cell", testCityCodeLAX, testClassBasalt)},
+ cells: []client.Object{testCell("lax-cell", testFederatorLocation, testClassBasalt)},
wantReason: "",
},
{
@@ -344,7 +345,7 @@ func TestWorkloadDeploymentFederator_UnservedRuntimeClassCondition(t *testing.T)
require.NotNil(t, cond, "an unplaceable deployment must carry an Available condition")
assert.Equal(t, metav1.ConditionFalse, cond.Status)
assert.Equal(t, tt.wantReason, cond.Reason)
- assert.Contains(t, cond.Message, testCityCodeLAX)
+ assert.Contains(t, cond.Message, testFederatorLocation)
assert.Contains(t, cond.Message, tt.specClass)
assert.NotContains(t, cond.Message, "Pod")
})
diff --git a/internal/controller/workloaddeployment_federator_test.go b/internal/controller/workloaddeployment_federator_test.go
index e2180f46..02097c5c 100644
--- a/internal/controller/workloaddeployment_federator_test.go
+++ b/internal/controller/workloaddeployment_federator_test.go
@@ -21,18 +21,20 @@ import (
mcreconcile "sigs.k8s.io/multicluster-runtime/pkg/reconcile"
computev1alpha "go.datum.net/compute/api/v1alpha"
+ networkingv1alpha "go.datum.net/network-services-operator/api/v1alpha"
+ locationsv1alpha1 "go.miloapis.com/locations/api/v1alpha1"
"go.miloapis.com/milo/pkg/downstreamclient"
)
// ─── Shared test constants ────────────────────────────────────────────────────
const (
- testCluster = "test-project-cluster"
- testProjNS = "my-project"
- testProjNSUID = types.UID("aabbccdd-0000-1111-2222-333344445555")
- testKarmadaNSStr = "ns-aabbccdd-0000-1111-2222-333344445555"
- testWDName = "my-workload-deployment"
- testCityCodeLAX = "LAX"
+ testCluster = "test-project-cluster"
+ testProjNS = "my-project"
+ testProjNSUID = types.UID("aabbccdd-0000-1111-2222-333344445555")
+ testKarmadaNSStr = "ns-aabbccdd-0000-1111-2222-333344445555"
+ testWDName = "my-workload-deployment"
+ testFederatorLocation = "us-west-2"
)
// ─── Test helpers ─────────────────────────────────────────────────────────────
@@ -57,7 +59,7 @@ func testWorkloadDeployment(opts ...func(*computev1alpha.WorkloadDeployment)) *c
UID: "wd-uid-1111",
},
Spec: computev1alpha.WorkloadDeploymentSpec{
- CityCode: testCityCodeLAX,
+ LocationRef: locationsv1alpha1.LocationReference{Name: testFederatorLocation},
WorkloadRef: computev1alpha.WorkloadReference{
Name: rdTestWorkloadName,
},
@@ -264,23 +266,24 @@ func TestPropagationPolicyNameFor(t *testing.T) {
tests := []struct {
name string
- cityCode string
+ location string
runtimeClass string
want string
}{
- {"LAX", testCityCodeLAX, "", "city-lax"},
- {"lax", "lax", "", "city-lax"},
- {"New York", "New York", "", "city-new-york"},
- {"LOS ANGELES", "LOS ANGELES", "", "city-los-angeles"},
- {"SEA", "SEA", "", "city-sea"},
- {"LAX with a class", testCityCodeLAX, testClassAzurite, "city-lax-class-azurite"},
- {"LAX with another class", testCityCodeLAX, testClassBasalt, "city-lax-class-basalt"},
+ {"LAX", "LAX", "", "location-lax"},
+ {"lax", "lax", "", "location-lax"},
+ {"New York", "New York", "", "location-new-york"},
+ {"LOS ANGELES", "LOS ANGELES", "", "location-los-angeles"},
+ {"SEA", "SEA", "", "location-sea"},
+ {"us-west-2", testFederatorLocation, "", "location-us-west-2"},
+ {"us-west-2 with a class", testFederatorLocation, testClassAzurite, "location-us-west-2-class-azurite"},
+ {"us-west-2 with another class", testFederatorLocation, testClassBasalt, "location-us-west-2-class-basalt"},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
t.Parallel()
- got := propagationPolicyNameFor(tt.cityCode, tt.runtimeClass)
+ got := propagationPolicyNameFor(tt.location, tt.runtimeClass)
assert.Equal(t, tt.want, got)
})
}
@@ -351,7 +354,7 @@ func TestWorkloadDeploymentFederator_AddsFinalizerOnFirstSeen(t *testing.T) {
// TestWorkloadDeploymentFederator_FederatesToKarmada verifies that a
// WorkloadDeployment with the finalizer already set is fully federated:
-// the Karmada namespace, WorkloadDeployment (with city-code label), and
+// the Karmada namespace, WorkloadDeployment (with location label), and
// PropagationPolicy are all created.
func TestWorkloadDeploymentFederator_FederatesToKarmada(t *testing.T) {
t.Parallel()
@@ -372,20 +375,20 @@ func TestWorkloadDeploymentFederator_FederatesToKarmada(t *testing.T) {
err = karmadaClient.Get(ctx, types.NamespacedName{Name: testKarmadaNSStr}, &karmadaNS)
require.NoError(t, err, "Karmada namespace %q should exist", testKarmadaNSStr)
- // Karmada WorkloadDeployment must exist with the city-code label.
+ // Karmada WorkloadDeployment must exist with the location label.
var karmadaWD computev1alpha.WorkloadDeployment
err = karmadaClient.Get(ctx, types.NamespacedName{
Name: testWDName,
Namespace: testKarmadaNSStr,
}, &karmadaWD)
require.NoError(t, err, "Karmada WorkloadDeployment should exist")
- assert.Equal(t, testCityCodeLAX, karmadaWD.Labels[cityCodeLabel],
- "city-code label should be set on Karmada WD")
- assert.Equal(t, testCityCodeLAX, karmadaWD.Spec.CityCode,
- "spec.cityCode should be copied from project WD")
+ assert.Equal(t, testFederatorLocation, karmadaWD.Labels[locationLabel],
+ "location label should be set on Karmada WD")
+ assert.Equal(t, testFederatorLocation, karmadaWD.Spec.LocationRef.Name,
+ "spec.locationRef should be copied from project WD")
- // PropagationPolicy for the city code must exist.
- ppName := propagationPolicyNameFor(testCityCodeLAX, "")
+ // PropagationPolicy for the location must exist.
+ ppName := propagationPolicyNameFor(testFederatorLocation, "")
var pp karmadapolicyv1alpha1.PropagationPolicy
err = karmadaClient.Get(ctx, types.NamespacedName{
Name: ppName,
@@ -393,7 +396,7 @@ func TestWorkloadDeploymentFederator_FederatesToKarmada(t *testing.T) {
}, &pp)
require.NoError(t, err, "PropagationPolicy %q should exist", ppName)
- // The PP must have three selectors: WorkloadDeployment (city-code), ConfigMap
+ // The PP must have three selectors: WorkloadDeployment (location), ConfigMap
// (referenced-data), and Secret (referenced-data).
require.Len(t, pp.Spec.ResourceSelectors, 3)
@@ -401,7 +404,7 @@ func TestWorkloadDeploymentFederator_FederatesToKarmada(t *testing.T) {
assert.Equal(t, computev1alpha.GroupVersion.String(), wdSel.APIVersion)
assert.Equal(t, kindWorkloadDeployment, wdSel.Kind)
require.NotNil(t, wdSel.LabelSelector)
- assert.Equal(t, testCityCodeLAX, wdSel.LabelSelector.MatchLabels[cityCodeLabel])
+ assert.Equal(t, testFederatorLocation, wdSel.LabelSelector.MatchLabels[locationLabel])
cmSel := pp.Spec.ResourceSelectors[1]
assert.Equal(t, "v1", cmSel.APIVersion)
@@ -415,11 +418,11 @@ func TestWorkloadDeploymentFederator_FederatesToKarmada(t *testing.T) {
require.NotNil(t, secretSel.LabelSelector)
assert.Equal(t, computev1alpha.ReferencedDataLabelValue, secretSel.LabelSelector.MatchLabels[computev1alpha.ReferencedDataLabel])
- // The PP cluster affinity must target clusters carrying the same city-code.
+ // The PP cluster affinity must target clusters carrying the same location.
require.NotNil(t, pp.Spec.Placement.ClusterAffinity)
require.NotNil(t, pp.Spec.Placement.ClusterAffinity.LabelSelector)
- assert.Equal(t, testCityCodeLAX,
- pp.Spec.Placement.ClusterAffinity.LabelSelector.MatchLabels[cityCodeLabel])
+ assert.Equal(t, testFederatorLocation,
+ pp.Spec.Placement.ClusterAffinity.LabelSelector.MatchLabels[locationLabel])
}
// TestWorkloadDeploymentFederator_Finalization covers the deletion scenarios:
@@ -427,7 +430,7 @@ func TestWorkloadDeploymentFederator_FederatesToKarmada(t *testing.T) {
func TestWorkloadDeploymentFederator_Finalization(t *testing.T) {
t.Parallel()
- ppName := propagationPolicyNameFor(testCityCodeLAX, "")
+ ppName := propagationPolicyNameFor(testFederatorLocation, "")
tests := []struct {
name string
@@ -436,22 +439,22 @@ func TestWorkloadDeploymentFederator_Finalization(t *testing.T) {
wantPPGone bool
}{
{
- name: "last WD for city — PropagationPolicy removed",
+ name: "last WD for location — PropagationPolicy removed",
karmadaExtra: nil,
wantPPGone: true,
},
{
- name: "other WD for same city remains — PropagationPolicy kept",
+ name: "other WD for same location remains — PropagationPolicy kept",
karmadaExtra: []client.Object{
- // A sibling WD in the same Karmada namespace with the same city-code.
+ // A sibling WD in the same Karmada namespace with the same location.
&computev1alpha.WorkloadDeployment{
ObjectMeta: metav1.ObjectMeta{
Name: "other-deployment",
Namespace: testKarmadaNSStr,
- Labels: map[string]string{cityCodeLabel: testCityCodeLAX},
+ Labels: map[string]string{locationLabel: testFederatorLocation},
},
Spec: computev1alpha.WorkloadDeploymentSpec{
- CityCode: testCityCodeLAX,
+ LocationRef: locationsv1alpha1.LocationReference{Name: testFederatorLocation},
PlacementName: "other",
WorkloadRef: computev1alpha.WorkloadReference{Name: "other"},
ScaleSettings: computev1alpha.HorizontalScaleSettings{MinReplicas: 1},
@@ -475,10 +478,10 @@ func TestWorkloadDeploymentFederator_Finalization(t *testing.T) {
ObjectMeta: metav1.ObjectMeta{
Name: testWDName,
Namespace: testKarmadaNSStr,
- Labels: map[string]string{cityCodeLabel: testCityCodeLAX},
+ Labels: map[string]string{locationLabel: testFederatorLocation},
},
Spec: computev1alpha.WorkloadDeploymentSpec{
- CityCode: testCityCodeLAX,
+ LocationRef: locationsv1alpha1.LocationReference{Name: testFederatorLocation},
PlacementName: testDefaultPlacement,
WorkloadRef: computev1alpha.WorkloadReference{Name: rdTestWorkloadName},
ScaleSettings: computev1alpha.HorizontalScaleSettings{MinReplicas: 1},
@@ -541,10 +544,10 @@ func TestWorkloadDeploymentFederator_Finalization(t *testing.T) {
}
}
-// TestCleanupPropagationPolicyIfUnused_EmptyCityCode verifies the guard
-// against listing with an empty city-code label value, which would match the
+// TestCleanupPropagationPolicyIfUnused_EmptyLocation verifies the guard
+// against listing with an empty location label value, which would match the
// wrong deployment set and mis-decide PropagationPolicy cleanup.
-func TestCleanupPropagationPolicyIfUnused_EmptyCityCode(t *testing.T) {
+func TestCleanupPropagationPolicyIfUnused_EmptyLocation(t *testing.T) {
t.Parallel()
projectClient := newProjectFakeClient(testProjectNamespace())
@@ -553,13 +556,13 @@ func TestCleanupPropagationPolicyIfUnused_EmptyCityCode(t *testing.T) {
err := r.cleanupPropagationPolicyIfUnused(context.Background(), testKarmadaNSStr, "", "")
require.Error(t, err)
- assert.Contains(t, err.Error(), "city code is empty")
+ assert.Contains(t, err.Error(), "location name is empty")
}
// TestWorkloadDeploymentFederator_PropagationPolicyHasReferencedDataSelectors
// verifies that the PropagationPolicy always includes ConfigMap and Secret
// selectors for the referenced-data label in addition to the WorkloadDeployment
-// city-code selector. This is the always-on companion co-propagation.
+// location selector. This is the always-on companion co-propagation.
func TestWorkloadDeploymentFederator_PropagationPolicyHasReferencedDataSelectors(t *testing.T) {
t.Parallel()
@@ -571,7 +574,7 @@ func TestWorkloadDeploymentFederator_PropagationPolicyHasReferencedDataSelectors
_, err := r.Reconcile(context.Background(), reconcileRequest())
require.NoError(t, err)
- ppName := propagationPolicyNameFor(testCityCodeLAX, "")
+ ppName := propagationPolicyNameFor(testFederatorLocation, "")
var pp karmadapolicyv1alpha1.PropagationPolicy
require.NoError(t, karmadaClient.Get(context.Background(), types.NamespacedName{
Name: ppName,
@@ -730,7 +733,7 @@ func TestWorkloadDeploymentFederator_FinalizeIsSelfContained(t *testing.T) {
ObjectMeta: metav1.ObjectMeta{
Name: testWDName,
Namespace: testKarmadaNSStr,
- Labels: map[string]string{cityCodeLabel: testCityCodeLAX},
+ Labels: map[string]string{locationLabel: testFederatorLocation},
},
Spec: wd.Spec,
}
@@ -765,3 +768,86 @@ func TestWorkloadDeploymentFederator_FinalizeHoldsWhenUnresolvable(t *testing.T)
_, err := r.Finalize(ctx, wd)
require.Error(t, err, "an unresolvable hub namespace must hold the finalizer")
}
+
+// TestWorkloadDeploymentFederator_FinalizesLegacyDeployment covers deleting a
+// deployment stored before placement moved to locations. It has no location
+// to key a PropagationPolicy by; the city it was routed by is read off its
+// hub copy, and the city-keyed policies from that era are removed once no hub
+// deployment routed by the city remains. Policies keyed by location are not
+// touched.
+func TestWorkloadDeploymentFederator_FinalizesLegacyDeployment(t *testing.T) {
+ t.Parallel()
+
+ const legacyCity = "LAX"
+ withoutLocation := func(wd *computev1alpha.WorkloadDeployment) {
+ wd.Spec.LocationRef = locationsv1alpha1.LocationReference{}
+ }
+
+ tests := []struct {
+ name string
+ siblingLabels map[string]string
+ wantCityPPs bool
+ }{
+ {
+ name: "last legacy deployment for the city removes its policies",
+ wantCityPPs: false,
+ },
+ {
+ name: "another legacy deployment routed by the city keeps them",
+ siblingLabels: map[string]string{networkingv1alpha.TopologyCityCodeKey: legacyCity},
+ wantCityPPs: true,
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ t.Parallel()
+
+ wd := testWorkloadDeployment(withFinalizer, withDeletionTimestamp, withoutLocation)
+ projectClient := newProjectFakeClient(testProjectNamespace(), wd)
+
+ hubCopy := &computev1alpha.WorkloadDeployment{
+ ObjectMeta: metav1.ObjectMeta{
+ Name: testWDName,
+ Namespace: testKarmadaNSStr,
+ Labels: map[string]string{networkingv1alpha.TopologyCityCodeKey: legacyCity},
+ },
+ }
+ policy := func(name string) *karmadapolicyv1alpha1.PropagationPolicy {
+ return &karmadapolicyv1alpha1.PropagationPolicy{ObjectMeta: metav1.ObjectMeta{Name: name, Namespace: testKarmadaNSStr}}
+ }
+ karmadaObjs := []client.Object{
+ &corev1.Namespace{ObjectMeta: metav1.ObjectMeta{Name: testKarmadaNSStr}},
+ hubCopy,
+ policy("city-lax"),
+ policy("city-lax-class-basalt"),
+ policy("city-sea"),
+ policy(propagationPolicyNameFor(testFederatorLocation, "")),
+ }
+ if tt.siblingLabels != nil {
+ karmadaObjs = append(karmadaObjs, &computev1alpha.WorkloadDeployment{
+ ObjectMeta: metav1.ObjectMeta{Name: "legacy-sibling", Namespace: testKarmadaNSStr, Labels: tt.siblingLabels},
+ })
+ }
+ karmadaClient := newKarmadaFakeClient(karmadaObjs...)
+
+ r := newTestFederator(projectClient, karmadaClient)
+ _, err := r.Reconcile(context.Background(), reconcileRequest())
+ require.NoError(t, err, "a deployment without a location must still finalize")
+
+ ctx := context.Background()
+ var gone computev1alpha.WorkloadDeployment
+ err = karmadaClient.Get(ctx, types.NamespacedName{Name: testWDName, Namespace: testKarmadaNSStr}, &gone)
+ assert.True(t, apierrors.IsNotFound(err), "the hub copy is deleted")
+
+ exists := func(name string) bool {
+ var pp karmadapolicyv1alpha1.PropagationPolicy
+ return karmadaClient.Get(ctx, types.NamespacedName{Name: name, Namespace: testKarmadaNSStr}, &pp) == nil
+ }
+ assert.Equal(t, tt.wantCityPPs, exists("city-lax"))
+ assert.Equal(t, tt.wantCityPPs, exists("city-lax-class-basalt"))
+ assert.True(t, exists("city-sea"), "another city's policies are not touched")
+ assert.True(t, exists(propagationPolicyNameFor(testFederatorLocation, "")), "location-keyed policies are not touched")
+ })
+ }
+}
diff --git a/internal/controller/workloaddeployment_hpa_controller.go b/internal/controller/workloaddeployment_hpa_controller.go
index be20c84f..17e83771 100644
--- a/internal/controller/workloaddeployment_hpa_controller.go
+++ b/internal/controller/workloaddeployment_hpa_controller.go
@@ -132,7 +132,7 @@ func workloadDeploymentHPALabels(deployment *computev1alpha.WorkloadDeployment)
computev1alpha.WorkloadDeploymentNameLabel: deployment.Name,
computev1alpha.WorkloadNameLabel: deployment.Spec.WorkloadRef.Name,
computev1alpha.PlacementNameLabel: deployment.Spec.PlacementName,
- computev1alpha.CityCodeLabel: deployment.Spec.CityCode,
+ computev1alpha.LocationLabel: deployment.Spec.LocationRef.Name,
}
}
diff --git a/internal/controller/workloaddeployment_hpa_controller_test.go b/internal/controller/workloaddeployment_hpa_controller_test.go
index df6cca4e..cdc8c95b 100644
--- a/internal/controller/workloaddeployment_hpa_controller_test.go
+++ b/internal/controller/workloaddeployment_hpa_controller_test.go
@@ -20,6 +20,7 @@ import (
mcreconcile "sigs.k8s.io/multicluster-runtime/pkg/reconcile"
computev1alpha "go.datum.net/compute/api/v1alpha"
+ locationsv1alpha1 "go.miloapis.com/locations/api/v1alpha1"
)
const (
@@ -37,7 +38,7 @@ func hpaTestDeployment() *computev1alpha.WorkloadDeployment {
UID: wdControllerTestUID,
},
Spec: computev1alpha.WorkloadDeploymentSpec{
- CityCode: wdControllerTestCityCode,
+ LocationRef: locationsv1alpha1.LocationReference{Name: wdControllerTestLocation},
PlacementName: testDefaultPlacement,
WorkloadRef: computev1alpha.WorkloadReference{Name: wdControllerTestWorkload},
ScaleSettings: computev1alpha.HorizontalScaleSettings{
@@ -105,7 +106,7 @@ func TestWorkloadDeploymentHPAReconciler_CreatesHPA(t *testing.T) {
computev1alpha.WorkloadDeploymentNameLabel: deployment.Name,
computev1alpha.WorkloadNameLabel: deployment.Spec.WorkloadRef.Name,
computev1alpha.PlacementNameLabel: deployment.Spec.PlacementName,
- computev1alpha.CityCodeLabel: deployment.Spec.CityCode,
+ computev1alpha.LocationLabel: deployment.Spec.LocationRef.Name,
}, hpa.Labels)
require.Len(t, hpa.OwnerReferences, 1)
assert.Equal(t, deployment.Name, hpa.OwnerReferences[0].Name)
diff --git a/internal/controller/workloaddeployment_location_test.go b/internal/controller/workloaddeployment_location_test.go
index 20e5739f..497a1dd9 100644
--- a/internal/controller/workloaddeployment_location_test.go
+++ b/internal/controller/workloaddeployment_location_test.go
@@ -20,7 +20,10 @@ import (
mcreconcile "sigs.k8s.io/multicluster-runtime/pkg/reconcile"
computev1alpha "go.datum.net/compute/api/v1alpha"
+ "go.datum.net/compute/internal/locations"
networkingv1alpha "go.datum.net/network-services-operator/api/v1alpha"
+ locationsv1alpha1 "go.miloapis.com/locations/api/v1alpha1"
+ servicesv1alpha1 "go.miloapis.com/service-catalog/api/v1alpha1"
"go.datum.net/compute/internal/controller/instancecontrol"
)
@@ -29,8 +32,8 @@ const (
// locTestCityCode / locTestOtherCityCode: deployments under test target
// locTestCityCode; locTestOtherCityCode identifies the city a mis-delivered
// cell serves.
- locTestCityCode = "DFW"
- locTestOtherCityCode = "ORD"
+ locTestLocation = "us-central-1"
+ locTestOtherLocation = "us-central-2"
// locTestWDNamespace is the namespace of the deployments under test.
locTestWDNamespace = "default"
@@ -41,18 +44,17 @@ func newNetworkingScheme() *runtime.Scheme {
s := runtime.NewScheme()
_ = computev1alpha.AddToScheme(s)
_ = networkingv1alpha.AddToScheme(s)
+ _ = locationsv1alpha1.AddToScheme(s)
+ _ = servicesv1alpha1.AddToScheme(s)
return s
}
// newTestServingLocation builds a ServingLocation fixture shaped like the one a
// cell is delivered: cluster scoped, and carrying its city under the
// topology.datum.net/city-code key.
-func newTestServingLocation(name, cityCode string) *networkingv1alpha.ServingLocation {
- return &networkingv1alpha.ServingLocation{
+func newTestServingLocation(name, _ string) *locationsv1alpha1.ServingLocation {
+ return &locationsv1alpha1.ServingLocation{
ObjectMeta: metav1.ObjectMeta{Name: name},
- Spec: networkingv1alpha.ServingLocationSpec{
- Topology: map[string]string{networkingv1alpha.TopologyCityCodeKey: cityCode},
- },
}
}
@@ -60,7 +62,7 @@ func newTestServingLocation(name, cityCode string) *networkingv1alpha.ServingLoc
// serves the city the deployment asked for.
func resolvedTestLocation() servingLocationResult {
return servingLocationResult{
- reference: &networkingv1alpha.LocationReference{Name: "loc-dfw-1"},
+ reference: &locationsv1alpha1.LocationReference{Name: "loc-dfw-1"},
}
}
@@ -68,7 +70,7 @@ func newLocationTestDeployment(name string) *computev1alpha.WorkloadDeployment {
return &computev1alpha.WorkloadDeployment{
ObjectMeta: metav1.ObjectMeta{Name: name, Namespace: locTestWDNamespace},
Spec: computev1alpha.WorkloadDeploymentSpec{
- CityCode: locTestCityCode,
+ LocationRef: locationsv1alpha1.LocationReference{Name: locTestLocation},
},
}
}
@@ -83,12 +85,13 @@ func TestResolveLocation_ExactlyOneServingLocation(t *testing.T) {
cl := fake.NewClientBuilder().
WithScheme(newNetworkingScheme()).
- WithObjects(newTestServingLocation(locationName, locTestCityCode)).
+ WithObjects(newTestServingLocation(locationName, locTestLocation)).
Build()
deployment := newLocationTestDeployment("test-wd")
+ deployment.Spec.LocationRef = locationsv1alpha1.LocationReference{Name: locationName}
- r := &WorkloadDeploymentReconciler{}
+ r := &WorkloadDeploymentReconciler{LocationSource: locations.SourceLocations}
result, err := r.resolveLocation(context.Background(), cl)
require.NoError(t, err)
result.evaluate(deployment)
@@ -110,7 +113,7 @@ func TestResolveLocation_NoServingLocation_IsNonGating(t *testing.T) {
deployment := newLocationTestDeployment("test-wd")
- r := &WorkloadDeploymentReconciler{}
+ r := &WorkloadDeploymentReconciler{LocationSource: locations.SourceLocations}
result, err := r.resolveLocation(context.Background(), cl)
require.NoError(t, err, "an unidentified cell must not surface as an error")
result.evaluate(deployment)
@@ -119,10 +122,8 @@ func TestResolveLocation_NoServingLocation_IsNonGating(t *testing.T) {
assert.False(t, result.blocked,
"a cell that has not been identified yet must never hold instances back")
assert.Equal(t, computev1alpha.WorkloadDeploymentReasonNoMatchingLocation, result.reason)
- assert.Contains(t, result.message, networkingv1alpha.ServingLocationTopologyLabel,
+ assert.Contains(t, result.message, locationsv1alpha1.ServingLocationTopologyLabel,
"the message must name the cluster label that fixes it")
- assert.Nil(t, deployment.Status.Location,
- "Status.Location must be left alone when nothing resolved")
}
// TestResolveLocation_MultipleServingLocations_RefusesToGuess verifies the
@@ -134,14 +135,14 @@ func TestResolveLocation_MultipleServingLocations_RefusesToGuess(t *testing.T) {
cl := fake.NewClientBuilder().
WithScheme(newNetworkingScheme()).
WithObjects(
- newTestServingLocation("loc-dfw-1", locTestCityCode),
- newTestServingLocation("loc-ord-1", locTestOtherCityCode),
+ newTestServingLocation("loc-dfw-1", locTestLocation),
+ newTestServingLocation("loc-ord-1", locTestOtherLocation),
).
Build()
deployment := newLocationTestDeployment("test-wd")
- r := &WorkloadDeploymentReconciler{}
+ r := &WorkloadDeploymentReconciler{LocationSource: locations.SourceLocations}
result, err := r.resolveLocation(context.Background(), cl)
require.NoError(t, err)
result.evaluate(deployment)
@@ -162,12 +163,12 @@ func TestResolveLocation_CityCodeMismatch(t *testing.T) {
cl := fake.NewClientBuilder().
WithScheme(newNetworkingScheme()).
- WithObjects(newTestServingLocation("loc-ord-1", locTestOtherCityCode)).
+ WithObjects(newTestServingLocation(locTestOtherLocation, locTestOtherLocation)).
Build()
deployment := newLocationTestDeployment("test-wd")
- r := &WorkloadDeploymentReconciler{}
+ r := &WorkloadDeploymentReconciler{LocationSource: locations.SourceLocations}
result, err := r.resolveLocation(context.Background(), cl)
require.NoError(t, err)
result.evaluate(deployment)
@@ -175,9 +176,9 @@ func TestResolveLocation_CityCodeMismatch(t *testing.T) {
assert.Nil(t, result.reference,
"the wrong cell's location must never be stamped on the deployment")
assert.True(t, result.blocked, "a misplaced deployment must not proceed silently")
- assert.Equal(t, computev1alpha.WorkloadDeploymentReasonCityCodeMismatch, result.reason)
- assert.Contains(t, result.message, locTestCityCode)
- assert.Contains(t, result.message, locTestOtherCityCode)
+ assert.Equal(t, computev1alpha.WorkloadDeploymentReasonLocationMismatch, result.reason)
+ assert.Contains(t, result.message, locTestLocation)
+ assert.Contains(t, result.message, locTestOtherLocation)
}
// newLocationTestWDReconciler builds a WorkloadDeploymentReconciler with
@@ -188,6 +189,7 @@ func newLocationTestWDReconciler(cl client.Client) *WorkloadDeploymentReconciler
r := &WorkloadDeploymentReconciler{
mgr: newFakeMCManager(testCluster, newFakeCluster(cl)),
NetworkingEnabled: true,
+ LocationSource: locations.SourceLocations,
}
feds := finalizer.NewFinalizers()
if err := feds.Register(workloadControllerFinalizer, r); err != nil {
@@ -211,7 +213,7 @@ func newLocationTestReconcilableWD(name string) *computev1alpha.WorkloadDeployme
Finalizers: []string{workloadControllerFinalizer},
},
Spec: computev1alpha.WorkloadDeploymentSpec{
- CityCode: locTestCityCode,
+ LocationRef: locationsv1alpha1.LocationReference{Name: locTestLocation},
WorkloadRef: computev1alpha.WorkloadReference{Name: "location-test-workload"},
Replicas: new(int32(1)),
ScaleSettings: computev1alpha.HorizontalScaleSettings{
@@ -287,13 +289,12 @@ func TestWorkloadDeploymentReconcile_UnidentifiedCell_SetsCondition(t *testing.T
require.NotNil(t, cond, "Available must be set while the cell has no location")
assert.Equal(t, metav1.ConditionFalse, cond.Status)
assert.Equal(t, computev1alpha.WorkloadDeploymentReasonNoMatchingLocation, cond.Reason)
- assert.Contains(t, cond.Message, networkingv1alpha.ServingLocationTopologyLabel,
+ assert.Contains(t, cond.Message, locationsv1alpha1.ServingLocationTopologyLabel,
"the condition message must name the label that identifies the cell")
- assert.Nil(t, updated.Status.Location)
// Deliver the cell's location; the next reconcile resolves it and must
// replace the waiting reason.
- servingLocation := newTestServingLocation("loc-dfw-2", locTestCityCode)
+ servingLocation := newTestServingLocation(locTestLocation, locTestLocation)
require.NoError(t, cl.Create(context.Background(), servingLocation))
_, err = r.Reconcile(context.Background(), req)
@@ -304,8 +305,7 @@ func TestWorkloadDeploymentReconcile_UnidentifiedCell_SetsCondition(t *testing.T
require.NotNil(t, cond)
assert.Equal(t, computev1alpha.WorkloadDeploymentReasonInstancesProvisioning, cond.Reason,
"the waiting reason must give way once the cell knows where it is")
- require.NotNil(t, updated.Status.Location)
- assert.Equal(t, servingLocation.Name, updated.Status.Location.Name)
+ assert.Equal(t, servingLocation.Name, updated.Spec.LocationRef.Name)
}
// TestWorkloadDeploymentReconcile_CityCodeMismatch_HoldsInstances verifies that a
@@ -320,7 +320,7 @@ func TestWorkloadDeploymentReconcile_CityCodeMismatch_HoldsInstances(t *testing.
cl := fake.NewClientBuilder().
WithScheme(newNetworkingScheme()).
- WithObjects(deployment, instance, newTestServingLocation("loc-ord-1", locTestOtherCityCode)).
+ WithObjects(deployment, instance, newTestServingLocation(locTestOtherLocation, locTestOtherLocation)).
WithStatusSubresource(deployment).
Build()
r := newLocationTestWDReconciler(cl)
@@ -334,10 +334,8 @@ func TestWorkloadDeploymentReconcile_CityCodeMismatch_HoldsInstances(t *testing.
cond := apimeta.FindStatusCondition(updated.Status.Conditions, computev1alpha.WorkloadDeploymentAvailable)
require.NotNil(t, cond)
- assert.Equal(t, computev1alpha.WorkloadDeploymentReasonCityCodeMismatch, cond.Reason,
+ assert.Equal(t, computev1alpha.WorkloadDeploymentReasonLocationMismatch, cond.Reason,
"a misplaced deployment must report the placement fault over any other blocker")
- assert.Nil(t, updated.Status.Location,
- "the wrong cell's location must never be written to status")
var updatedInstance computev1alpha.Instance
require.NoError(t, cl.Get(context.Background(), types.NamespacedName{
@@ -360,7 +358,7 @@ func TestWorkloadDeploymentReconcile_BackfillsInstanceLocation(t *testing.T) {
instance := newLocationTestInstance(deployment)
require.Nil(t, instance.Spec.Location, "the fixture must start without a location")
- servingLocation := newTestServingLocation("loc-dfw-1", locTestCityCode)
+ servingLocation := newTestServingLocation(locTestLocation, locTestLocation)
cl := fake.NewClientBuilder().
WithScheme(newNetworkingScheme()).
@@ -390,7 +388,7 @@ func TestEnqueueWorkloadDeploymentsForServingLocation(t *testing.T) {
wdDFW := newLocationTestDeployment("wd-dfw")
wdORD := newLocationTestDeployment("wd-ord")
- wdORD.Spec.CityCode = locTestOtherCityCode
+ wdORD.Spec.LocationRef.Name = locTestOtherLocation
cl := fake.NewClientBuilder().
WithScheme(newNetworkingScheme()).
diff --git a/internal/controller/workloaddeployment_network_binding.go b/internal/controller/workloaddeployment_network_binding.go
index ea132afd..da4d554c 100644
--- a/internal/controller/workloaddeployment_network_binding.go
+++ b/internal/controller/workloaddeployment_network_binding.go
@@ -43,11 +43,7 @@ func (r *WorkloadDeploymentFederator) ensureNetworkBinding(
ctx context.Context,
hubDeployment *computev1alpha.WorkloadDeployment,
) (*networkingv1alpha.NetworkBinding, error) {
- // The location is written by the cell that serves the deployment and reaches
- // the hub through Karmada status aggregation, so it is absent for as long as
- // nothing has placed the deployment. There is no presence to ask for until
- // then, and a binding without a location cannot be created at all.
- if hubDeployment.Status.Location == nil || hubDeployment.Status.Location.Name == "" {
+ if hubDeployment.Spec.LocationRef.Name == "" {
return nil, nil
}
@@ -55,7 +51,7 @@ func (r *WorkloadDeploymentFederator) ensureNetworkBinding(
if !ok {
return nil, nil
}
- location := *hubDeployment.Status.Location
+ location := networkingv1alpha.LocationReference{Name: hubDeployment.Spec.LocationRef.Name}
key := client.ObjectKey{Namespace: hubDeployment.Namespace, Name: hubDeployment.Name}
var existing networkingv1alpha.NetworkBinding
diff --git a/internal/controller/workloaddeployment_network_binding_test.go b/internal/controller/workloaddeployment_network_binding_test.go
index 8126b3c5..2d808265 100644
--- a/internal/controller/workloaddeployment_network_binding_test.go
+++ b/internal/controller/workloaddeployment_network_binding_test.go
@@ -18,13 +18,16 @@ import (
computev1alpha "go.datum.net/compute/api/v1alpha"
networkingv1alpha "go.datum.net/network-services-operator/api/v1alpha"
+ locationsv1alpha1 "go.miloapis.com/locations/api/v1alpha1"
"go.miloapis.com/milo/pkg/downstreamclient"
)
const (
- testNetworkName = "default"
- testLocationName = "dfw"
- testHubWDUID = types.UID("hub-wd-uid-9999")
+ testNetworkName = "default"
+ testLocationName = "dfw"
+ testOtherLocationName = "ord"
+ testWestLocationName = "us-west-1"
+ testHubWDUID = types.UID("hub-wd-uid-9999")
)
// testHubDeployment returns the hub copy of the test WorkloadDeployment, already
@@ -37,7 +40,7 @@ func testHubDeployment(opts ...func(*computev1alpha.WorkloadDeployment)) *comput
UID: testHubWDUID,
},
Spec: computev1alpha.WorkloadDeploymentSpec{
- CityCode: testCityCodeLAX,
+ LocationRef: locationsv1alpha1.LocationReference{Name: testLocationName},
Template: computev1alpha.InstanceTemplateSpec{
Spec: computev1alpha.InstanceSpec{
NetworkInterfaces: []computev1alpha.InstanceNetworkInterface{{
@@ -58,7 +61,7 @@ func testHubDeployment(opts ...func(*computev1alpha.WorkloadDeployment)) *comput
// which on the hub arrives through Karmada status aggregation.
func withServingLocation(name string) func(*computev1alpha.WorkloadDeployment) {
return func(wd *computev1alpha.WorkloadDeployment) {
- wd.Status.Location = &networkingv1alpha.LocationReference{Name: name}
+ wd.Spec.LocationRef = locationsv1alpha1.LocationReference{Name: name}
}
}
@@ -98,7 +101,7 @@ func TestEnsureNetworkBinding_DeclaresPresenceWhereDeploymentRuns(t *testing.T)
require.NoError(t, err)
assert.Equal(t, testNetworkName, stored.Spec.Network.Name)
- assert.Equal(t, testLocationName, stored.Spec.Location.Name)
+ assert.Equal(t, hubWD.Spec.LocationRef.Name, stored.Spec.Location.Name)
require.NotNil(t, stored.Spec.Consumer)
assert.Equal(t, computev1alpha.GroupVersion.Group, stored.Spec.Consumer.APIGroup)
@@ -129,10 +132,6 @@ func TestEnsureNetworkBinding_NothingToDeclareYet(t *testing.T) {
name string
hubWD *computev1alpha.WorkloadDeployment
}{
- {
- name: "no serving location",
- hubWD: testHubDeployment(),
- },
{
name: "no network interfaces",
hubWD: testHubDeployment(withServingLocation(testLocationName), func(wd *computev1alpha.WorkloadDeployment) {
@@ -246,9 +245,9 @@ func TestEnsureNetworkBinding_RecreatesOnDivergence(t *testing.T) {
},
{
name: "serving location changed",
- changed: withServingLocation("ord"),
+ changed: withServingLocation(testOtherLocationName),
wantNetwork: testNetworkName,
- wantLocation: "ord",
+ wantLocation: testOtherLocationName,
},
}
@@ -341,7 +340,7 @@ func TestWorkloadDeploymentFederator_CreatesNetworkBindingOnReconcile(t *testing
stored, err := getBinding(t, karmadaClient)
require.NoError(t, err)
assert.Equal(t, testNetworkName, stored.Spec.Network.Name)
- assert.Equal(t, testLocationName, stored.Spec.Location.Name)
+ assert.Equal(t, wd.Spec.LocationRef.Name, stored.Spec.Location.Name)
}
// TestMapNetworkBindingToRequest verifies the binding-to-deployment mapping: the
diff --git a/internal/controller/workloaddeployment_setup_test.go b/internal/controller/workloaddeployment_setup_test.go
index 29522bd2..edf451db 100644
--- a/internal/controller/workloaddeployment_setup_test.go
+++ b/internal/controller/workloaddeployment_setup_test.go
@@ -21,6 +21,7 @@ import (
computev1alpha "go.datum.net/compute/api/v1alpha"
networkingv1alpha "go.datum.net/network-services-operator/api/v1alpha"
+ locationsv1alpha1 "go.miloapis.com/locations/api/v1alpha1"
)
// TestWorkloadDeploymentSetupWithManager_CellModeNoNetworkingCRD asserts that with
@@ -42,6 +43,7 @@ func TestWorkloadDeploymentSetupWithManager_CellModeNoNetworkingCRD(t *testing.T
require.NoError(t, computev1alpha.AddToScheme(scheme))
require.NoError(t, corev1.AddToScheme(scheme))
require.NoError(t, networkingv1alpha.AddToScheme(scheme))
+ require.NoError(t, locationsv1alpha1.AddToScheme(scheme))
deploymentCluster, err := cluster.New(cfg, func(o *cluster.Options) { o.Scheme = scheme })
require.NoError(t, err)
diff --git a/internal/locations/locations.go b/internal/locations/locations.go
index 09c9026a..9dd2a9c0 100644
--- a/internal/locations/locations.go
+++ b/internal/locations/locations.go
@@ -11,19 +11,29 @@ package locations
import (
"context"
+ "errors"
"fmt"
+ "sort"
"strings"
apierrors "k8s.io/apimachinery/pkg/api/errors"
apimeta "k8s.io/apimachinery/pkg/api/meta"
+ metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+ "k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/runtime/schema"
"k8s.io/apimachinery/pkg/util/sets"
"sigs.k8s.io/controller-runtime/pkg/client"
networkingv1alpha "go.datum.net/network-services-operator/api/v1alpha"
locationsv1alpha1 "go.miloapis.com/locations/api/v1alpha1"
+ servicesv1alpha1 "go.miloapis.com/service-catalog/api/v1alpha1"
)
+// ComputeServiceName is the name the platform records compute availability
+// under: a ServiceAvailability whose spec.serviceRef.name is this value says
+// compute is deployed and validated at spec.locationRef.name.
+const ComputeServiceName = "compute"
+
const (
// TopologyCityCodeKey is the topology key holding a location's city.
TopologyCityCodeKey = locationsv1alpha1.TopologyCityCodeKey
@@ -63,6 +73,26 @@ func (s Source) Resolve() (Source, error) {
type PlacementLocation struct {
Name string
Topology map[string]string
+
+ // Ready reports whether the location itself is serving. A Location read
+ // from the locations service is Ready when its Ready condition is true. A
+ // LocationBinding carries no readiness contract that compute reads, so
+ // every binding is Ready.
+ Ready bool
+
+ // ServiceAvailable reports whether compute is deployed and validated at
+ // the location, read from the ServiceAvailability the platform mirrors
+ // into the project. A location can be Ready for the platform generally
+ // yet have no compute cell behind it; this is what tells the two apart.
+ // A control plane that does not serve the kind enforces no such gate, so
+ // every location there is available.
+ ServiceAvailable bool
+}
+
+// Placeable reports whether a placement may run at the location: it is Ready
+// and compute is available there.
+func (l PlacementLocation) Placeable() bool {
+ return l.Ready && l.ServiceAvailable
}
// CityCode returns the city the location serves, and whether it declares one.
@@ -101,9 +131,10 @@ func ListPlacementLocations(ctx context.Context, c client.Client, source Source)
found = append(found, PlacementLocation{
Name: binding.Name,
Topology: binding.Spec.Topology,
+ Ready: true,
})
}
- return found, nil
+ return markServiceAvailability(ctx, c, found)
}
var list locationsv1alpha1.LocationList
@@ -119,11 +150,67 @@ func ListPlacementLocations(ctx context.Context, c client.Client, source Source)
found = append(found, PlacementLocation{
Name: location.Name,
Topology: location.Spec.Topology,
+ Ready: apimeta.IsStatusConditionTrue(location.Status.Conditions, locationsv1alpha1.LocationConditionReady),
})
}
+ return markServiceAvailability(ctx, c, found)
+}
+
+// markServiceAvailability sets ServiceAvailable on each location from the
+// ServiceAvailability records the platform mirrors into the project.
+//
+// A location is available when a record for the compute service names it and
+// reports Available. A control plane that does not serve the kind has no
+// availability to consult, so every location is marked available and the
+// Ready gate alone decides, which is what placement did before the platform
+// began mirroring availability.
+func markServiceAvailability(ctx context.Context, c client.Client, found []PlacementLocation) ([]PlacementLocation, error) {
+ available, enforced, err := AvailableLocations(ctx, c)
+ if err != nil {
+ return nil, err
+ }
+ for i := range found {
+ found[i].ServiceAvailable = !enforced || available.Has(found[i].Name)
+ }
return found, nil
}
+// AvailableLocations returns the names of the locations where compute is
+// available, and whether the control plane serves availability at all. When
+// it does not, enforced is false and the set is empty.
+func AvailableLocations(ctx context.Context, c client.Client) (available sets.Set[string], enforced bool, err error) {
+ var list servicesv1alpha1.ServiceAvailabilityList
+ if err := c.List(ctx, &list); err != nil {
+ if kindNotInstalled(err) {
+ return sets.Set[string]{}, false, nil
+ }
+ return nil, false, fmt.Errorf("failed to list service availabilities: %w", err)
+ }
+
+ available = sets.Set[string]{}
+ for _, availability := range list.Items {
+ if availability.Spec.ServiceRef.Name != ComputeServiceName {
+ continue
+ }
+ if apimeta.IsStatusConditionTrue(availability.Status.Conditions, "Available") {
+ available.Insert(availability.Spec.LocationRef.Name)
+ }
+ }
+ return available, true, nil
+}
+
+// ServiceAvailabilityGVK returns the kind a controller watches to learn that
+// compute availability at a location changed.
+func ServiceAvailabilityGVK() schema.GroupVersionKind {
+ return servicesv1alpha1.GroupVersion.WithKind("ServiceAvailability")
+}
+
+// ServesServiceAvailabilityKind reports whether the control plane serves
+// ServiceAvailability, so a watch on it is safe to register.
+func ServesServiceAvailabilityKind(mapper apimeta.RESTMapper) (bool, error) {
+ return servesKind(mapper, ServiceAvailabilityGVK())
+}
+
// ListServingLocations returns the locations delivered to a cell.
func ListServingLocations(ctx context.Context, c client.Client, source Source) ([]ServingLocation, error) {
resolved, err := source.Resolve()
@@ -165,6 +252,90 @@ func ListServingLocations(ctx context.Context, c client.Client, source Source) (
return found, nil
}
+// Select returns the Ready locations whose topology matches the selector,
+// sorted by name so callers derive a stable set of deployments from it.
+//
+// An empty selector is an error rather than a match for every location. The
+// webhook rejects one, so reaching this with one means the stored object was
+// not admitted through it.
+func Select(found []PlacementLocation, selector *metav1.LabelSelector) ([]PlacementLocation, error) {
+ if selector == nil || (len(selector.MatchLabels) == 0 && len(selector.MatchExpressions) == 0) {
+ return nil, errors.New("location selector is empty")
+ }
+
+ sel, err := metav1.LabelSelectorAsSelector(selector)
+ if err != nil {
+ return nil, fmt.Errorf("invalid location selector: %w", err)
+ }
+
+ var matched []PlacementLocation
+ for _, location := range found {
+ if location.Placeable() && sel.Matches(labels.Set(location.Topology)) {
+ matched = append(matched, location)
+ }
+ }
+ sort.Slice(matched, func(i, j int) bool { return matched[i].Name < matched[j].Name })
+ return matched, nil
+}
+
+// PlacementLocationObject returns the object a controller watches to learn
+// that the locations a project may place workloads at have changed.
+func PlacementLocationObject(source Source) (client.Object, error) {
+ resolved, err := source.Resolve()
+ if err != nil {
+ return nil, err
+ }
+
+ if resolved == SourceNetworkServices {
+ return &networkingv1alpha.LocationBinding{}, nil
+ }
+ return &locationsv1alpha1.Location{}, nil
+}
+
+// PlacementLocationGVK returns the kind a controller watches to learn that the
+// locations a project may place workloads at have changed.
+func PlacementLocationGVK(source Source) (schema.GroupVersionKind, error) {
+ resolved, err := source.Resolve()
+ if err != nil {
+ return schema.GroupVersionKind{}, err
+ }
+
+ if resolved == SourceNetworkServices {
+ return networkingv1alpha.GroupVersion.WithKind("LocationBinding"), nil
+ }
+ return locationsv1alpha1.GroupVersion.WithKind("Location"), nil
+}
+
+// ServesPlacementLocationKind reports whether the control plane behind the
+// mapper serves the kind the source watches for placement locations.
+//
+// Unlike EnsureServingLocationKind this answers rather than refuses. A cell
+// serves the deployments it is asked about, so a missing serving location kind
+// there is a misconfiguration worth failing on. Placement locations are read
+// from many project control planes engaged one at a time, and a control plane
+// that does not carry the kind is skipped rather than taking the whole manager
+// down with it.
+func ServesPlacementLocationKind(mapper apimeta.RESTMapper, source Source) (bool, error) {
+ gvk, err := PlacementLocationGVK(source)
+ if err != nil {
+ return false, err
+ }
+ return servesKind(mapper, gvk)
+}
+
+// servesKind reports whether the control plane behind the mapper serves the
+// kind. A kind that is not installed reads as not served; any other mapper
+// failure is returned, since it says nothing about the kind.
+func servesKind(mapper apimeta.RESTMapper, gvk schema.GroupVersionKind) (bool, error) {
+ if _, err := mapper.RESTMapping(gvk.GroupKind(), gvk.Version); err != nil {
+ if kindNotInstalled(err) {
+ return false, nil
+ }
+ return false, fmt.Errorf("failed to determine whether %s is served: %w", gvk, err)
+ }
+ return true, nil
+}
+
// ServingLocationObject returns the object a controller watches to learn that
// a cell has been told where it sits.
func ServingLocationObject(source Source) (client.Object, error) {
@@ -233,6 +404,18 @@ func otherSource(source Source) Source {
return SourceLocations
}
+// PlaceableNames returns the names of the given locations a placement may run
+// at: those that are Ready and where compute is available.
+func PlaceableNames(found []PlacementLocation) sets.Set[string] {
+ names := sets.Set[string]{}
+ for _, location := range found {
+ if location.Placeable() {
+ names.Insert(location.Name)
+ }
+ }
+ return names
+}
+
// CityCodes returns the cities the given locations serve.
func CityCodes(found []PlacementLocation) sets.Set[string] {
codes := sets.Set[string]{}
diff --git a/internal/locations/locations_envtest_test.go b/internal/locations/locations_envtest_test.go
index 02b7a4a2..c33b7ddc 100644
--- a/internal/locations/locations_envtest_test.go
+++ b/internal/locations/locations_envtest_test.go
@@ -20,6 +20,7 @@ import (
"sigs.k8s.io/controller-runtime/pkg/envtest"
locationsv1alpha1 "go.miloapis.com/locations/api/v1alpha1"
+ servicesv1alpha1 "go.miloapis.com/service-catalog/api/v1alpha1"
)
// locationsCRDDir resolves the CRDs shipped by the locations module, so the
@@ -37,6 +38,25 @@ func locationsCRDDir(t *testing.T) string {
return dir
}
+// envtestLocationName is the one location every subtest below creates and
+// reads back.
+const envtestLocationName = "dfw"
+
+// serviceAvailabilityCRD resolves the ServiceAvailability CRD shipped by the
+// service-catalog module, for the same reason as locationsCRDDir.
+func serviceAvailabilityCRD(t *testing.T) string {
+ t.Helper()
+
+ out, err := exec.Command("go", "list", "-m", "-f", "{{.Dir}}", "go.miloapis.com/service-catalog").Output()
+ require.NoError(t, err, "the service-catalog module must be resolvable")
+
+ path := filepath.Join(strings.TrimSpace(string(out)), "config", "base", "crd", "bases",
+ "services.miloapis.com_serviceavailabilities.yaml")
+ _, err = os.Stat(path)
+ require.NoError(t, err)
+ return path
+}
+
// TestLocationsSource_AgainstAPIServer is the runtime half of the typed switch.
// Compiling against the locations types proves nothing about whether a client
// can resolve the kinds, so this runs both states against a real API server:
@@ -101,9 +121,9 @@ func TestLocationsSource_AgainstAPIServer(t *testing.T) {
t.Run("CRDs installed resolve and read back", func(t *testing.T) {
c := newClient()
- require.NoError(t, c.Create(ctx, newLocation("dfw", testCityCode)))
+ require.NoError(t, c.Create(ctx, newLocation(envtestLocationName, testCityCode)))
require.NoError(t, c.Create(ctx, &locationsv1alpha1.ServingLocation{
- ObjectMeta: metav1.ObjectMeta{Name: "dfw"},
+ ObjectMeta: metav1.ObjectMeta{Name: envtestLocationName},
Spec: locationsv1alpha1.ServingLocationSpec{
Topology: map[string]string{TopologyCityCodeKey: testCityCode},
},
@@ -117,7 +137,73 @@ func TestLocationsSource_AgainstAPIServer(t *testing.T) {
serving, err := ListServingLocations(ctx, c, SourceLocations)
require.NoError(t, err)
require.Len(t, serving, 1)
- assert.Equal(t, "dfw", serving[0].Name)
+ assert.Equal(t, envtestLocationName, serving[0].Name)
assert.Equal(t, testCityCode, serving[0].CityCode())
})
+
+ // markReady sets the Ready condition on the location through the status
+ // subresource, the way the locations controller does.
+ markReady := func(t *testing.T, c client.Client) {
+ t.Helper()
+ var location locationsv1alpha1.Location
+ require.NoError(t, c.Get(ctx, client.ObjectKey{Name: envtestLocationName}, &location))
+ location.Status.Conditions = []metav1.Condition{{
+ Type: locationsv1alpha1.LocationConditionReady, Status: metav1.ConditionTrue,
+ Reason: "Serving", LastTransitionTime: metav1.Now(),
+ }}
+ require.NoError(t, c.Status().Update(ctx, &location))
+ }
+
+ t.Run("availability CRD absent enforces no gate", func(t *testing.T) {
+ c := newClient()
+ markReady(t, c)
+
+ // The absence must be recognisable for the same reason as above: a
+ // wrapping change would turn every project without the mirror into
+ // one where nothing can be placed.
+ var absent servicesv1alpha1.ServiceAvailabilityList
+ rawErr := c.List(ctx, &absent)
+ require.Error(t, rawErr, "the CRD really is absent, so the degrade is under test")
+ assert.True(t, kindNotInstalled(rawErr), "an absent CRD must stay recognisable as such: %T / %v", rawErr, rawErr)
+
+ found, err := ListPlacementLocations(ctx, c, SourceLocations)
+ require.NoError(t, err)
+ require.Len(t, found, 1)
+ assert.True(t, found[0].Placeable(), "with no availability to consult, Ready alone decides")
+ })
+
+ _, err = envtest.InstallCRDs(cfg, envtest.CRDInstallOptions{
+ Paths: []string{serviceAvailabilityCRD(t)},
+ })
+ require.NoError(t, err)
+
+ t.Run("availability CRD installed gates on a compute record", func(t *testing.T) {
+ c := newClient()
+
+ found, err := ListPlacementLocations(ctx, c, SourceLocations)
+ require.NoError(t, err)
+ require.Len(t, found, 1)
+ assert.False(t, found[0].Placeable(), "the kind is served but no record says compute runs here")
+
+ availability := newComputeAvailability(envtestLocationName)
+ conditions := availability.Status.Conditions
+ availability.Status = servicesv1alpha1.ServiceAvailabilityStatus{}
+ require.NoError(t, c.Create(ctx, availability))
+ for i := range conditions {
+ conditions[i].Reason = "Available"
+ conditions[i].LastTransitionTime = metav1.Now()
+ }
+ availability.Status.Conditions = conditions
+ require.NoError(t, c.Status().Update(ctx, availability))
+
+ found, err = ListPlacementLocations(ctx, c, SourceLocations)
+ require.NoError(t, err)
+ require.Len(t, found, 1)
+ assert.True(t, found[0].Placeable(), "an Available compute record opens the gate")
+
+ available, enforced, err := AvailableLocations(ctx, c)
+ require.NoError(t, err)
+ assert.True(t, enforced)
+ assert.Equal(t, []string{envtestLocationName}, available.UnsortedList())
+ })
}
diff --git a/internal/locations/locations_test.go b/internal/locations/locations_test.go
index e32a732b..29f2ef43 100644
--- a/internal/locations/locations_test.go
+++ b/internal/locations/locations_test.go
@@ -12,17 +12,23 @@ import (
apimeta "k8s.io/apimachinery/pkg/api/meta"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/runtime"
+ "k8s.io/apimachinery/pkg/util/sets"
"sigs.k8s.io/controller-runtime/pkg/client"
"sigs.k8s.io/controller-runtime/pkg/client/fake"
"sigs.k8s.io/controller-runtime/pkg/client/interceptor"
networkingv1alpha "go.datum.net/network-services-operator/api/v1alpha"
locationsv1alpha1 "go.miloapis.com/locations/api/v1alpha1"
+ servicesv1alpha1 "go.miloapis.com/service-catalog/api/v1alpha1"
)
const (
testCityCode = "DFW"
testOtherCityCode = "ORD"
+
+ testLocationORD = "ord"
+ testLocationDFWA = "dfw-a"
+ testLocationDFWB = "dfw-b"
)
func testScheme(t *testing.T) *runtime.Scheme {
@@ -31,9 +37,35 @@ func testScheme(t *testing.T) *runtime.Scheme {
s := runtime.NewScheme()
require.NoError(t, networkingv1alpha.AddToScheme(s))
require.NoError(t, locationsv1alpha1.AddToScheme(s))
+ require.NoError(t, servicesv1alpha1.AddToScheme(s))
return s
}
+// newAvailability returns the mirrored record saying the named service is
+// deployed at the named location, Available or not.
+func newAvailability(service, location string, available bool) *servicesv1alpha1.ServiceAvailability {
+ status := metav1.ConditionFalse
+ if available {
+ status = metav1.ConditionTrue
+ }
+ return &servicesv1alpha1.ServiceAvailability{
+ ObjectMeta: metav1.ObjectMeta{Name: service + "--" + location},
+ Spec: servicesv1alpha1.ServiceAvailabilitySpec{
+ ServiceRef: servicesv1alpha1.ServiceRef{Name: service},
+ LocationRef: servicesv1alpha1.LocationRef{Name: location},
+ },
+ Status: servicesv1alpha1.ServiceAvailabilityStatus{
+ Conditions: []metav1.Condition{{Type: "Available", Status: status}},
+ },
+ }
+}
+
+// newComputeAvailability returns an Available record for compute at the
+// location.
+func newComputeAvailability(location string) *servicesv1alpha1.ServiceAvailability {
+ return newAvailability(ComputeServiceName, location, true)
+}
+
func newBinding(name, cityCode string) *networkingv1alpha.LocationBinding {
return &networkingv1alpha.LocationBinding{
ObjectMeta: metav1.ObjectMeta{Name: name},
@@ -54,6 +86,13 @@ func newLocation(name, cityCode string) *locationsv1alpha1.Location {
}
}
+// newReadyLocation is newLocation with its Ready condition set.
+func newReadyLocation(name, cityCode string) *locationsv1alpha1.Location {
+ location := newLocation(name, cityCode)
+ location.Status.Conditions = []metav1.Condition{{Type: locationsv1alpha1.LocationConditionReady, Status: metav1.ConditionTrue}}
+ return location
+}
+
// TestTopologyKeysAgreeAcrossSources guards the migration's central assumption:
// a city code means the same thing whichever source served it. If the two
// groups ever disagree, switching sources would silently repoint every
@@ -95,7 +134,7 @@ func TestListPlacementLocations_NetworkServices(t *testing.T) {
WithScheme(testScheme(t)).
WithObjects(
newBinding("dfw", testCityCode),
- newBinding("ord", testOtherCityCode),
+ newBinding(testLocationORD, testOtherCityCode),
// A binding with no city code contributes no placement city.
&networkingv1alpha.LocationBinding{ObjectMeta: metav1.ObjectMeta{Name: "nowhere"}},
// The locations service must not be read when network services is
@@ -117,7 +156,7 @@ func TestListPlacementLocations_Locations(t *testing.T) {
WithScheme(testScheme(t)).
WithObjects(
newLocation("dfw", testCityCode),
- newLocation("ord", testOtherCityCode),
+ newLocation(testLocationORD, testOtherCityCode),
// The network services source must not be read when the locations
// service is selected.
newBinding("lhr", "LHR"),
@@ -272,3 +311,159 @@ func TestServingLocationGVK(t *testing.T) {
_, err = ServingLocationGVK("Nonsense")
require.Error(t, err)
}
+
+// TestSelect covers selection over topology: a selector matches Ready
+// locations by their topology, the result is ordered by name, and an empty or
+// malformed selector is refused rather than matching everything.
+func TestSelect(t *testing.T) {
+ t.Parallel()
+
+ region := "topology.datum.net/region"
+ found := []PlacementLocation{
+ {Name: testLocationORD, Topology: map[string]string{TopologyCityCodeKey: testOtherCityCode, region: "us-central"}, Ready: true, ServiceAvailable: true},
+ {Name: testLocationDFWB, Topology: map[string]string{TopologyCityCodeKey: testCityCode, region: "us-south"}, Ready: true, ServiceAvailable: true},
+ {Name: testLocationDFWA, Topology: map[string]string{TopologyCityCodeKey: testCityCode, region: "us-south"}, Ready: true, ServiceAvailable: true},
+ {Name: "dfw-down", Topology: map[string]string{TopologyCityCodeKey: testCityCode}, Ready: false},
+ {Name: "nowhere", Ready: true, ServiceAvailable: true},
+ }
+
+ names := func(locations []PlacementLocation) []string {
+ out := make([]string, 0, len(locations))
+ for _, location := range locations {
+ out = append(out, location.Name)
+ }
+ return out
+ }
+
+ t.Run("match labels, sorted, Ready only", func(t *testing.T) {
+ t.Parallel()
+ matched, err := Select(found, &metav1.LabelSelector{
+ MatchLabels: map[string]string{TopologyCityCodeKey: testCityCode},
+ })
+ require.NoError(t, err)
+ assert.Equal(t, []string{testLocationDFWA, testLocationDFWB}, names(matched))
+ })
+
+ t.Run("match expressions", func(t *testing.T) {
+ t.Parallel()
+ matched, err := Select(found, &metav1.LabelSelector{
+ MatchExpressions: []metav1.LabelSelectorRequirement{{
+ Key: region, Operator: metav1.LabelSelectorOpIn, Values: []string{"us-central", "eu-west"},
+ }},
+ })
+ require.NoError(t, err)
+ assert.Equal(t, []string{testLocationORD}, names(matched))
+ })
+
+ t.Run("exists selects every location with the key", func(t *testing.T) {
+ t.Parallel()
+ matched, err := Select(found, &metav1.LabelSelector{
+ MatchExpressions: []metav1.LabelSelectorRequirement{{
+ Key: TopologyCityCodeKey, Operator: metav1.LabelSelectorOpExists,
+ }},
+ })
+ require.NoError(t, err)
+ assert.Equal(t, []string{testLocationDFWA, testLocationDFWB, testLocationORD}, names(matched))
+ })
+
+ t.Run("no match is empty, not an error", func(t *testing.T) {
+ t.Parallel()
+ matched, err := Select(found, &metav1.LabelSelector{
+ MatchLabels: map[string]string{TopologyCityCodeKey: "LHR"},
+ })
+ require.NoError(t, err)
+ assert.Empty(t, matched)
+ })
+
+ t.Run("empty selector is refused", func(t *testing.T) {
+ t.Parallel()
+ _, err := Select(found, &metav1.LabelSelector{})
+ require.Error(t, err)
+ _, err = Select(found, nil)
+ require.Error(t, err)
+ })
+
+ t.Run("malformed selector is refused", func(t *testing.T) {
+ t.Parallel()
+ _, err := Select(found, &metav1.LabelSelector{
+ MatchExpressions: []metav1.LabelSelectorRequirement{{
+ Key: TopologyCityCodeKey, Operator: metav1.LabelSelectorOpIn,
+ }},
+ })
+ require.Error(t, err)
+ })
+}
+
+// TestPlacementLocationObject pins which kind each source watches for the
+// locations a project may place at.
+func TestPlacementLocationObject(t *testing.T) {
+ t.Parallel()
+
+ obj, err := PlacementLocationObject("")
+ require.NoError(t, err)
+ assert.IsType(t, &networkingv1alpha.LocationBinding{}, obj)
+
+ obj, err = PlacementLocationObject(SourceLocations)
+ require.NoError(t, err)
+ assert.IsType(t, &locationsv1alpha1.Location{}, obj)
+
+ _, err = PlacementLocationObject("Nonsense")
+ require.Error(t, err)
+}
+
+// TestListPlacementLocations_ServiceAvailability covers the availability gate
+// under both sources: a location is placeable only when a record for compute
+// names it and reports Available. A record for another service, or one that
+// is not Available, leaves the location Ready but not placeable.
+func TestListPlacementLocations_ServiceAvailability(t *testing.T) {
+ t.Parallel()
+
+ for _, tt := range []struct {
+ name string
+ source Source
+ objects []client.Object
+ }{
+ {
+ name: "network services",
+ source: SourceNetworkServices,
+ objects: []client.Object{
+ newBinding(testLocationDFWA, testCityCode),
+ newBinding(testLocationORD, testOtherCityCode),
+ newBinding("lhr", "LHR"),
+ },
+ },
+ {
+ name: "locations service",
+ source: SourceLocations,
+ objects: []client.Object{
+ newReadyLocation(testLocationDFWA, testCityCode),
+ newReadyLocation(testLocationORD, testOtherCityCode),
+ newReadyLocation("lhr", "LHR"),
+ },
+ },
+ } {
+ t.Run(tt.name, func(t *testing.T) {
+ t.Parallel()
+
+ objects := append(tt.objects,
+ newComputeAvailability(testLocationDFWA),
+ newAvailability(ComputeServiceName, testLocationORD, false),
+ newAvailability("networking-datumapis-com", "lhr", true),
+ )
+ cl := fake.NewClientBuilder().WithScheme(testScheme(t)).WithObjects(objects...).Build()
+
+ found, err := ListPlacementLocations(context.Background(), cl, tt.source)
+ require.NoError(t, err)
+ require.Len(t, found, 3, "availability narrows what is placeable, not what is listed")
+
+ byName := map[string]PlacementLocation{}
+ for _, location := range found {
+ byName[location.Name] = location
+ }
+ assert.True(t, byName[testLocationDFWA].Placeable(), "an Available compute record makes the location placeable")
+ assert.False(t, byName[testLocationORD].Placeable(), "a compute record that is not Available does not")
+ assert.False(t, byName["lhr"].Placeable(), "another service's availability says nothing about compute")
+ assert.Equal(t, []string{testLocationDFWA}, sets.List(PlaceableNames(found)))
+ })
+ }
+}
diff --git a/internal/validation/instance_validation_test.go b/internal/validation/instance_validation_test.go
index cf56044b..6bbe3d95 100644
--- a/internal/validation/instance_validation_test.go
+++ b/internal/validation/instance_validation_test.go
@@ -422,7 +422,7 @@ func TestReferencedDataSAR(t *testing.T) {
Context: context.Background(),
Workload: tc.workload,
AdmissionRequest: admission.Request{},
- ValidCityCodes: []string{"DFW"},
+ ValidLocations: []string{"DFW"},
}
spec := tc.workload.Spec.Template.Spec
@@ -483,7 +483,7 @@ func TestBothRefsSetEnvFrom(t *testing.T) {
Context: context.Background(),
Workload: workload,
AdmissionRequest: admission.Request{},
- ValidCityCodes: []string{testCityCodeDFW},
+ ValidLocations: []string{testCityCodeDFW},
}
_ = validateReferencedDataAccess(workload.Spec.Template.Spec, specPath, opts)
if sarCount != sarCountBefore {
@@ -530,7 +530,7 @@ func TestReferencedDataSARInternalError(t *testing.T) {
Context: context.Background(),
Workload: workload,
AdmissionRequest: admission.Request{},
- ValidCityCodes: []string{testCityCodeDFW},
+ ValidLocations: []string{testCityCodeDFW},
}
errs := validateReferencedDataAccess(workload.Spec.Template.Spec, specPath, opts)
@@ -601,7 +601,7 @@ func TestValidateUpdateSARPath(t *testing.T) {
Context: context.Background(),
Workload: newWorkload,
AdmissionRequest: admission.Request{},
- ValidCityCodes: []string{testCityCodeDFW},
+ ValidLocations: []string{testCityCodeDFW},
}
// ValidateWorkloadCreate is called by ValidateUpdate in the webhook; here
@@ -693,7 +693,7 @@ func TestWorkloadWithReferencedDataE2E(t *testing.T) {
Client: fakeClient,
Context: context.Background(),
Workload: workload,
- ValidCityCodes: []string{"DFW"},
+ ValidLocations: []string{"DFW"},
}
errs := ValidateWorkloadCreate(workload, opts)
diff --git a/internal/validation/workload_validation.go b/internal/validation/workload_validation.go
index cf8b4c34..4f12c417 100644
--- a/internal/validation/workload_validation.go
+++ b/internal/validation/workload_validation.go
@@ -4,9 +4,15 @@ import (
"context"
"fmt"
"slices"
+ "sort"
+ "strings"
+ locationsv1alpha1 "go.miloapis.com/locations/api/v1alpha1"
k8scorev1 "k8s.io/api/core/v1"
apimachineryvalidation "k8s.io/apimachinery/pkg/api/validation"
+ metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+ metav1validation "k8s.io/apimachinery/pkg/apis/meta/v1/validation"
+ "k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/util/sets"
"k8s.io/apimachinery/pkg/util/validation/field"
"sigs.k8s.io/controller-runtime/pkg/client"
@@ -77,7 +83,12 @@ type WorkloadValidationOptions struct {
AdmissionRequest admission.Request
Context context.Context
Workload *computev1alpha.Workload
- ValidCityCodes []string
+ ValidLocations []string
+
+ // LocationTopologies is the topology of every location a placement may run
+ // at (Ready, with compute available), keyed by name. A placement's
+ // locationSelector must match at least one of them.
+ LocationTopologies map[string]map[string]string
// RuntimeClasses is the catalog of execution tiers this control plane
// publishes, read by the caller. The catalog is empty when runtime class
@@ -123,14 +134,32 @@ func validateWorkloadPlacement(placement computev1alpha.WorkloadPlacement, field
}
}
- cityCodesPath := fieldPath.Child("cityCodes")
- if len(placement.CityCodes) == 0 {
- allErrs = append(allErrs, field.Required(cityCodesPath, ""))
- } else {
- for i, cityCode := range placement.CityCodes {
- if !slices.Contains(opts.ValidCityCodes, cityCode) {
- allErrs = append(allErrs, field.NotSupported(cityCodesPath.Index(i), cityCode, opts.ValidCityCodes))
+ locationsPath := fieldPath.Child("locations")
+ selectorPath := fieldPath.Child("locationSelector")
+ switch {
+ case len(placement.CityCodes) > 0:
+ // Admission rewrites a lone cityCodes into a locationSelector before
+ // validation runs, so reaching this means it was set together with
+ // locations or a selector, or defaulting was bypassed. Either way the
+ // author has to say which they meant.
+ allErrs = append(allErrs, field.Forbidden(fieldPath.Child("cityCodes"),
+ "deprecated: place with locations or a locationSelector on "+locationsv1alpha1.TopologyCityCodeKey+"; a placement that only names city codes is rewritten on admission"))
+ case len(placement.Locations) == 0 && placement.LocationSelector == nil:
+ allErrs = append(allErrs, field.Required(locationsPath, "one of locations or locationSelector must be set"))
+ case len(placement.Locations) > 0 && placement.LocationSelector != nil:
+ allErrs = append(allErrs, field.Forbidden(selectorPath, "may not be set together with locations"))
+ case placement.LocationSelector != nil:
+ allErrs = append(allErrs, validateLocationSelector(placement.LocationSelector, selectorPath, opts)...)
+ default:
+ seen := sets.New[string]()
+ for i, location := range placement.Locations {
+ namePath := locationsPath.Index(i).Child("name")
+ if !slices.Contains(opts.ValidLocations, location.Name) {
+ allErrs = append(allErrs, field.NotSupported(namePath, location.Name, opts.ValidLocations))
+ } else if seen.Has(location.Name) {
+ allErrs = append(allErrs, field.Duplicate(namePath, location.Name))
}
+ seen.Insert(location.Name)
}
}
@@ -244,3 +273,40 @@ func validateMetricTarget(target computev1alpha.MetricTarget, fieldPath *field.P
return allErrs
}
+
+// validateLocationSelector checks a placement's selector the way the workload
+// controller will evaluate it: well formed, non-empty, and matching the
+// topology of at least one location where compute is available. A selector that matches nothing is rejected
+// for the same reason an unknown location name is: storing it would admit a
+// placement that never runs anywhere.
+func validateLocationSelector(selector *metav1.LabelSelector, fieldPath *field.Path, opts WorkloadValidationOptions) field.ErrorList {
+ allErrs := metav1validation.ValidateLabelSelector(selector, metav1validation.LabelSelectorValidationOptions{}, fieldPath)
+ if len(allErrs) > 0 {
+ return allErrs
+ }
+
+ if len(selector.MatchLabels) == 0 && len(selector.MatchExpressions) == 0 {
+ return append(allErrs, field.Required(fieldPath, fmt.Sprintf(
+ "an empty selector is not treated as matching every location; select at least one topology key, such as %s",
+ locationsv1alpha1.TopologyCityCodeKey)))
+ }
+
+ sel, err := metav1.LabelSelectorAsSelector(selector)
+ if err != nil {
+ return append(allErrs, field.Invalid(fieldPath, selector, err.Error()))
+ }
+
+ for _, topology := range opts.LocationTopologies {
+ if sel.Matches(labels.Set(topology)) {
+ return allErrs
+ }
+ }
+
+ names := make([]string, 0, len(opts.LocationTopologies))
+ for name := range opts.LocationTopologies {
+ names = append(names, name)
+ }
+ sort.Strings(names)
+ return append(allErrs, field.Invalid(fieldPath, sel.String(), fmt.Sprintf(
+ "matches none of the locations where compute is available (%s)", strings.Join(names, ", "))))
+}
diff --git a/internal/validation/workload_validation_test.go b/internal/validation/workload_validation_test.go
index b041de41..a2c070ff 100644
--- a/internal/validation/workload_validation_test.go
+++ b/internal/validation/workload_validation_test.go
@@ -23,6 +23,7 @@ import (
computev1alpha "go.datum.net/compute/api/v1alpha"
"go.datum.net/compute/pkg/runtimeclass"
networkingv1alpha "go.datum.net/network-services-operator/api/v1alpha"
+ locationsv1alpha1 "go.miloapis.com/locations/api/v1alpha1"
)
const (
@@ -49,26 +50,121 @@ func TestValidateWorkloads(t *testing.T) {
field.Required(field.NewPath("spec.placements"), ""),
},
},
- "missing cityCode": {
+ "location selector by city code": {
workload: MakeSandboxWorkload(
"test",
func(w *computev1alpha.Workload) {
- w.Spec.Placements[0].CityCodes = []string{}
+ w.Spec.Placements[0].Locations = nil
+ w.Spec.Placements[0].LocationSelector = &metav1.LabelSelector{
+ MatchLabels: map[string]string{locationsv1alpha1.TopologyCityCodeKey: testCityCodeDFW},
+ }
+ },
+ ),
+ expectedErrors: field.ErrorList{},
+ },
+ "location selector by expression": {
+ workload: MakeSandboxWorkload(
+ "test",
+ func(w *computev1alpha.Workload) {
+ w.Spec.Placements[0].Locations = nil
+ w.Spec.Placements[0].LocationSelector = &metav1.LabelSelector{
+ MatchExpressions: []metav1.LabelSelectorRequirement{{
+ Key: locationsv1alpha1.TopologyCityCodeKey,
+ Operator: metav1.LabelSelectorOpIn,
+ Values: []string{testCityCodeDFW, "ORD"},
+ }},
+ }
+ },
+ ),
+ expectedErrors: field.ErrorList{},
+ },
+ "location selector matching no ready location": {
+ workload: MakeSandboxWorkload(
+ "test",
+ func(w *computev1alpha.Workload) {
+ w.Spec.Placements[0].Locations = nil
+ w.Spec.Placements[0].LocationSelector = &metav1.LabelSelector{
+ MatchLabels: map[string]string{locationsv1alpha1.TopologyCityCodeKey: "LHR"},
+ }
},
),
expectedErrors: field.ErrorList{
- field.Required(field.NewPath("spec.placements[0].cityCodes"), ""),
+ field.Invalid(field.NewPath("spec.placements[0].locationSelector"), "", ""),
},
},
- "invalid cityCode": {
+ "empty location selector": {
workload: MakeSandboxWorkload(
"test",
func(w *computev1alpha.Workload) {
- w.Spec.Placements[0].CityCodes = []string{"TEST"}
+ w.Spec.Placements[0].Locations = nil
+ w.Spec.Placements[0].LocationSelector = &metav1.LabelSelector{}
},
),
expectedErrors: field.ErrorList{
- field.NotSupported(field.NewPath("spec.placements[0].cityCodes[0]"), "TEST", []string{}),
+ field.Required(field.NewPath("spec.placements[0].locationSelector"), ""),
+ },
+ },
+ "malformed location selector": {
+ workload: MakeSandboxWorkload(
+ "test",
+ func(w *computev1alpha.Workload) {
+ w.Spec.Placements[0].Locations = nil
+ w.Spec.Placements[0].LocationSelector = &metav1.LabelSelector{
+ MatchExpressions: []metav1.LabelSelectorRequirement{{
+ Key: locationsv1alpha1.TopologyCityCodeKey,
+ Operator: metav1.LabelSelectorOpIn,
+ }},
+ }
+ },
+ ),
+ expectedErrors: field.ErrorList{
+ field.Required(field.NewPath("spec.placements[0].locationSelector.matchExpressions[0].values"), ""),
+ },
+ },
+ "city codes are deprecated": {
+ workload: MakeSandboxWorkload(
+ "test",
+ func(w *computev1alpha.Workload) {
+ w.Spec.Placements[0].CityCodes = []string{testCityCodeDFW}
+ },
+ ),
+ expectedErrors: field.ErrorList{
+ field.Forbidden(field.NewPath("spec.placements[0].cityCodes"), ""),
+ },
+ },
+ "location selector together with locations": {
+ workload: MakeSandboxWorkload(
+ "test",
+ func(w *computev1alpha.Workload) {
+ w.Spec.Placements[0].LocationSelector = &metav1.LabelSelector{
+ MatchLabels: map[string]string{locationsv1alpha1.TopologyCityCodeKey: testCityCodeDFW},
+ }
+ },
+ ),
+ expectedErrors: field.ErrorList{
+ field.Forbidden(field.NewPath("spec.placements[0].locationSelector"), ""),
+ },
+ },
+ "missing location": {
+ workload: MakeSandboxWorkload(
+ "test",
+ func(w *computev1alpha.Workload) {
+ w.Spec.Placements[0].Locations = []locationsv1alpha1.LocationReference{}
+ },
+ ),
+ expectedErrors: field.ErrorList{
+ field.Required(field.NewPath("spec.placements[0].locations"), ""),
+ },
+ },
+ "invalid location": {
+ workload: MakeSandboxWorkload(
+ "test",
+ func(w *computev1alpha.Workload) {
+ w.Spec.Placements[0].Locations = []locationsv1alpha1.LocationReference{{Name: "TEST"}}
+ },
+ ),
+ expectedErrors: field.ErrorList{
+ field.NotSupported(field.NewPath("spec.placements[0].locations[0].name"), "TEST", []string{}),
},
},
"missing placement name": {
@@ -615,8 +711,13 @@ func TestValidateWorkloads(t *testing.T) {
},
)
- if len(scenario.opts.ValidCityCodes) == 0 {
- scenario.opts.ValidCityCodes = []string{testCityCodeDFW}
+ if len(scenario.opts.ValidLocations) == 0 {
+ scenario.opts.ValidLocations = []string{testCityCodeDFW}
+ }
+ if scenario.opts.LocationTopologies == nil {
+ scenario.opts.LocationTopologies = map[string]map[string]string{
+ testCityCodeDFW: {locationsv1alpha1.TopologyCityCodeKey: testCityCodeDFW},
+ }
}
t.Run(name, func(t *testing.T) {
@@ -671,7 +772,7 @@ func MakeSandboxWorkload(name string, tweaks ...Tweak) *computev1alpha.Workload
Placements: []computev1alpha.WorkloadPlacement{
{
Name: "placement1",
- CityCodes: []string{testCityCodeDFW},
+ Locations: []locationsv1alpha1.LocationReference{{Name: testCityCodeDFW}},
ScaleSettings: computev1alpha.HorizontalScaleSettings{
MinReplicas: 1,
},
@@ -746,7 +847,7 @@ func MakeVMWorkload(name string, tweaks ...Tweak) *computev1alpha.Workload {
Placements: []computev1alpha.WorkloadPlacement{
{
Name: "placement1",
- CityCodes: []string{testCityCodeDFW},
+ Locations: []locationsv1alpha1.LocationReference{{Name: testCityCodeDFW}},
ScaleSettings: computev1alpha.HorizontalScaleSettings{
MinReplicas: 1,
},
diff --git a/internal/webhook/v1alpha/workload_webhook.go b/internal/webhook/v1alpha/workload_webhook.go
index 5b991cd6..ccefd0c2 100644
--- a/internal/webhook/v1alpha/workload_webhook.go
+++ b/internal/webhook/v1alpha/workload_webhook.go
@@ -47,12 +47,31 @@ type workloadWebhook struct {
locationSource locations.Source
}
-func (r *workloadWebhook) validCityCodes(ctx context.Context, c client.Client) ([]string, error) {
+// readyLocations describes the locations a placement may run at: the
+// locations projected into the project control plane that are Ready and where
+// compute is available, as the names a placement may list and the topology a
+// selector is matched against.
+type readyLocations struct {
+ names []string
+ topologies map[string]map[string]string
+}
+
+func (r *workloadWebhook) readyLocations(ctx context.Context, c client.Client) (readyLocations, error) {
placementLocations, err := locations.ListPlacementLocations(ctx, c, r.locationSource)
if err != nil {
- return nil, err
+ return readyLocations{}, err
+ }
+
+ ready := readyLocations{
+ names: sets.List(locations.PlaceableNames(placementLocations)),
+ topologies: make(map[string]map[string]string),
+ }
+ for _, location := range placementLocations {
+ if location.Placeable() {
+ ready.topologies[location.Name] = location.Topology
+ }
}
- return sets.List(locations.CityCodes(placementLocations)), nil
+ return ready, nil
}
var _ admission.Defaulter[*computev1alpha.Workload] = &workloadWebhook{}
@@ -60,6 +79,12 @@ var _ admission.Validator[*computev1alpha.Workload] = &workloadWebhook{}
// Default implements admission.Defaulter so a mutating webhook will be registered for the type.
func (r *workloadWebhook) Default(ctx context.Context, workload *computev1alpha.Workload) error {
+ // A manifest written before placement moved to locations still names
+ // city codes. It is rewritten here so what is stored is what the
+ // controller places by, and so the stored object never carries the
+ // deprecated field.
+ workload.MigrateCityCodes()
+
// With the gate off there is only one runtime class, so the field stays
// empty rather than recording a class name the platform does not yet honor.
if features.FeatureGate.Enabled(features.RuntimeClasses) {
@@ -114,7 +139,7 @@ func (r *workloadWebhook) ValidateCreate(ctx context.Context, workload *computev
// that means for the scheduling phase, since there would not currently be
// sufficient context to know who created the workload and what locations
// are valid candidates based on that. Maybe an annotation, or spec field?
- validCityCodes, err := r.validCityCodes(ctx, clusterClient)
+ ready, err := r.readyLocations(ctx, clusterClient)
if err != nil {
return nil, err
}
@@ -125,12 +150,13 @@ func (r *workloadWebhook) ValidateCreate(ctx context.Context, workload *computev
}
opts := validation.WorkloadValidationOptions{
- Context: ctx,
- Client: clusterClient,
- AdmissionRequest: req,
- Workload: workload,
- ValidCityCodes: validCityCodes,
- RuntimeClasses: runtimeClasses,
+ Context: ctx,
+ Client: clusterClient,
+ AdmissionRequest: req,
+ Workload: workload,
+ ValidLocations: ready.names,
+ LocationTopologies: ready.topologies,
+ RuntimeClasses: runtimeClasses,
}
if errs := validation.ValidateWorkloadCreate(workload, opts); len(errs) > 0 {
@@ -156,7 +182,7 @@ func (r *workloadWebhook) ValidateUpdate(ctx context.Context, oldWorkload *compu
return nil, err
}
- validCityCodes, err := r.validCityCodes(ctx, clusterClient)
+ ready, err := r.readyLocations(ctx, clusterClient)
if err != nil {
return nil, err
}
@@ -167,12 +193,13 @@ func (r *workloadWebhook) ValidateUpdate(ctx context.Context, oldWorkload *compu
}
opts := validation.WorkloadValidationOptions{
- Context: ctx,
- Client: clusterClient,
- AdmissionRequest: req,
- Workload: newWorkload,
- ValidCityCodes: validCityCodes,
- RuntimeClasses: runtimeClasses,
+ Context: ctx,
+ Client: clusterClient,
+ AdmissionRequest: req,
+ Workload: newWorkload,
+ ValidLocations: ready.names,
+ LocationTopologies: ready.topologies,
+ RuntimeClasses: runtimeClasses,
}
if errs := validation.ValidateWorkloadUpdate(newWorkload, oldWorkload, opts); len(errs) > 0 {
diff --git a/internal/webhook/v1alpha/workload_webhook_test.go b/internal/webhook/v1alpha/workload_webhook_test.go
index 0083faac..72ffcedd 100644
--- a/internal/webhook/v1alpha/workload_webhook_test.go
+++ b/internal/webhook/v1alpha/workload_webhook_test.go
@@ -64,6 +64,28 @@ func TestWorkloadWebhookDefaultGateOff(t *testing.T) {
}
}
+// TestWorkloadWebhookDefaultMigratesCityCodes covers the shim for manifests
+// and stored objects written before placement moved to locations: a placement
+// that only names city codes is stored as the equivalent selector.
+func TestWorkloadWebhookDefaultMigratesCityCodes(t *testing.T) {
+ featuregatetesting.SetFeatureGateDuringTest(t, features.MutableFeatureGate, features.RuntimeClasses, false)
+
+ workload := &computev1alpha.Workload{}
+ workload.Spec.Placements = []computev1alpha.WorkloadPlacement{{Name: "default", CityCodes: []string{"DFW"}}}
+
+ if err := (&workloadWebhook{}).Default(context.Background(), workload); err != nil {
+ t.Fatalf("Default: %v", err)
+ }
+
+ placement := workload.Spec.Placements[0]
+ if placement.CityCodes != nil {
+ t.Errorf("cityCodes = %v, want cleared", placement.CityCodes)
+ }
+ if placement.LocationSelector == nil || placement.LocationSelector.MatchLabels["topology.datum.net/city-code"] != "DFW" {
+ t.Errorf("locationSelector = %v, want a city-code selector for DFW", placement.LocationSelector)
+ }
+}
+
// TestDefaultRuntimeClass covers which class a workload that selected none
// records. The catalog's default marker decides it, and a catalog with no
// default leaves the field empty for validation to reject.
diff --git a/pkg/instancepod/instancepod.go b/pkg/instancepod/instancepod.go
index 9fa962ff..3c31379b 100644
--- a/pkg/instancepod/instancepod.go
+++ b/pkg/instancepod/instancepod.go
@@ -94,7 +94,7 @@ var identityLabelKeys = []string{
computev1alpha.WorkloadDeploymentNameLabel,
computev1alpha.WorkloadNameLabel,
computev1alpha.PlacementNameLabel,
- computev1alpha.CityCodeLabel,
+ computev1alpha.LocationLabel,
computev1alpha.InstanceIndexLabel,
}
diff --git a/pkg/instancepod/instancepod_test.go b/pkg/instancepod/instancepod_test.go
index 56119c2c..d034ae05 100644
--- a/pkg/instancepod/instancepod_test.go
+++ b/pkg/instancepod/instancepod_test.go
@@ -627,7 +627,7 @@ func TestIdentityLabels(t *testing.T) {
computev1alpha.WorkloadDeploymentNameLabel: "web-dfw",
computev1alpha.WorkloadNameLabel: testWorkloadName,
computev1alpha.PlacementNameLabel: "dfw",
- computev1alpha.CityCodeLabel: "DFW",
+ computev1alpha.LocationLabel: "loc-dfw-1",
computev1alpha.InstanceIndexLabel: "0",
computev1alpha.RuntimeClassLabel: testClassAzurite,
"customer-team": "payments",
@@ -643,7 +643,7 @@ func TestIdentityLabels(t *testing.T) {
computev1alpha.WorkloadDeploymentNameLabel: "web-dfw",
computev1alpha.WorkloadNameLabel: testWorkloadName,
computev1alpha.PlacementNameLabel: "dfw",
- computev1alpha.CityCodeLabel: "DFW",
+ computev1alpha.LocationLabel: "loc-dfw-1",
computev1alpha.InstanceIndexLabel: "0",
}
if err := diff(want, IdentityLabels(instance)); err != nil {
diff --git a/test/e2e/chainsaw-config.yaml b/test/e2e/chainsaw-config.yaml
index 9524c8e4..0656f624 100644
--- a/test/e2e/chainsaw-config.yaml
+++ b/test/e2e/chainsaw-config.yaml
@@ -44,9 +44,9 @@ spec:
# and Instance write-backs live here.
downstream:
kubeconfig: tmp/e2e/kubeconfigs/downstream.yaml
- # POP DFW cell — downstream member cluster labelled topology.datum.net/city-code=dfw.
+ # POP DFW cell — downstream member cluster labelled topology.datum.net/location=dfw.
pop-dfw:
kubeconfig: tmp/e2e/kubeconfigs/pop-dfw.yaml
- # POP ORD cell — downstream member cluster labelled topology.datum.net/city-code=ord.
+ # POP ORD cell — downstream member cluster labelled topology.datum.net/location=ord.
pop-ord:
kubeconfig: tmp/e2e/kubeconfigs/pop-ord.yaml
diff --git a/test/e2e/deletion-cascade/workload-deployment.yaml b/test/e2e/deletion-cascade/workload-deployment.yaml
index 39d68a1d..8df72f5f 100644
--- a/test/e2e/deletion-cascade/workload-deployment.yaml
+++ b/test/e2e/deletion-cascade/workload-deployment.yaml
@@ -3,7 +3,8 @@ kind: WorkloadDeployment
metadata:
name: test-cascade-wd
spec:
- cityCode: dfw
+ locationRef:
+ name: dfw
placementName: default
workloadRef:
name: test-workload
diff --git a/test/e2e/federation-finalizer-no-wedge/chainsaw-test.yaml b/test/e2e/federation-finalizer-no-wedge/chainsaw-test.yaml
index 962783ca..811d8a21 100644
--- a/test/e2e/federation-finalizer-no-wedge/chainsaw-test.yaml
+++ b/test/e2e/federation-finalizer-no-wedge/chainsaw-test.yaml
@@ -50,7 +50,8 @@ spec:
name: test-no-wedge-wd
namespace: ${VICTIM_NS}
spec:
- cityCode: dfw
+ locationRef:
+ name: dfw
placementName: default
workloadRef:
name: test-workload
diff --git a/test/e2e/federation-hub-reclaim/chainsaw-test.yaml b/test/e2e/federation-hub-reclaim/chainsaw-test.yaml
index bbb10b9a..a65e1109 100644
--- a/test/e2e/federation-hub-reclaim/chainsaw-test.yaml
+++ b/test/e2e/federation-hub-reclaim/chainsaw-test.yaml
@@ -107,7 +107,8 @@ spec:
name: test-hub-reclaim-wd
namespace: ${INSTANCE_NS}
spec:
- cityCode: dfw
+ locationRef:
+ name: dfw
placementName: default
workloadRef:
name: test-workload
diff --git a/test/e2e/federation-hub-reclaim/instance-pop-dfw.yaml b/test/e2e/federation-hub-reclaim/instance-pop-dfw.yaml
index 4a19f0e5..d4d5ab65 100644
--- a/test/e2e/federation-hub-reclaim/instance-pop-dfw.yaml
+++ b/test/e2e/federation-hub-reclaim/instance-pop-dfw.yaml
@@ -17,7 +17,7 @@ metadata:
compute.datumapis.com/workload-deployment-uid: "00000000-0000-0000-0000-000000000002"
compute.datumapis.com/instance-index: "0"
compute.datumapis.com/workload-deployment-name: test-hub-reclaim-wd
- compute.datumapis.com/city-code: dfw
+ compute.datumapis.com/location: dfw
compute.datumapis.com/workload-name: test-workload
compute.datumapis.com/placement-name: default
spec:
diff --git a/test/e2e/federation-ownership/workload-deployment.yaml b/test/e2e/federation-ownership/workload-deployment.yaml
index e23a50ce..6c2bc8b9 100644
--- a/test/e2e/federation-ownership/workload-deployment.yaml
+++ b/test/e2e/federation-ownership/workload-deployment.yaml
@@ -4,7 +4,8 @@ metadata:
name: test-fed-own-wd
# namespace is injected by Chainsaw from ($namespace)
spec:
- cityCode: dfw
+ locationRef:
+ name: dfw
placementName: default
workloadRef:
name: test-workload
diff --git a/test/e2e/federation-reclaim-without-cell/workload-deployment.yaml b/test/e2e/federation-reclaim-without-cell/workload-deployment.yaml
index 7ae2ee9f..748e0a60 100644
--- a/test/e2e/federation-reclaim-without-cell/workload-deployment.yaml
+++ b/test/e2e/federation-reclaim-without-cell/workload-deployment.yaml
@@ -4,7 +4,8 @@ metadata:
name: test-no-cell-wd
# namespace is injected by Chainsaw from ($namespace)
spec:
- cityCode: dfw
+ locationRef:
+ name: dfw
placementName: default
workloadRef:
name: test-workload
diff --git a/test/e2e/full-federation-ord/chainsaw-test.yaml b/test/e2e/full-federation-ord/chainsaw-test.yaml
index b1bf1b64..6a19f8d4 100644
--- a/test/e2e/full-federation-ord/chainsaw-test.yaml
+++ b/test/e2e/full-federation-ord/chainsaw-test.yaml
@@ -8,14 +8,14 @@ spec:
The dfw path is covered by full-federation. This suite proves the same chain
routes independently to the OTHER cell: an ord-placed WorkloadDeployment must
- produce PropagationPolicy city-ord (not city-dfw), propagate to pop-ord (not
+ produce PropagationPolicy location-ord (not location-dfw), propagate to pop-ord (not
pop-dfw), and create its Instance on pop-ord. Both cells run the same operator
- image, so this is the coverage that catches city-code routing regressions and
+ image, so this is the coverage that catches location routing regressions and
a mis-registered second cell.
- 1. Create WorkloadDeployment (cityCode: ord) on control-plane.
+ 1. Create WorkloadDeployment (locationRef.name: ord) on control-plane.
2. WorkloadDeploymentFederator replicates it to Karmada (ns- namespace)
- and lazily creates PropagationPolicy city-ord routing to city-code=ord cells.
+ and lazily creates PropagationPolicy location-ord routing to location=ord cells.
3. Karmada propagates the WD to pop-ord.
4. WorkloadDeploymentReconciler on pop-ord creates Instance test-fullfed-ord-wd-0.
5. InstanceReconciler on pop-ord writes the Instance back to Karmada with
@@ -39,7 +39,7 @@ spec:
file: workload-deployment.yaml
- name: assert-wd-and-policy-in-downstream
- description: Assert the WD federated to Karmada and PropagationPolicy city-ord was created for ord.
+ description: Assert the WD federated to Karmada and PropagationPolicy location-ord was created for ord.
cluster: downstream
try:
- script:
@@ -59,17 +59,17 @@ spec:
namespace: ($downstreamNS)
name: test-fullfed-ord-wd
labels:
- topology.datum.net/city-code: ord
+ topology.datum.net/location: ord
- assert:
- # The federator names the policy city- and routes it to cells
- # carrying the same city-code label, so ord must land on pop-ord alone.
+ # The federator names the policy location- and routes it to cells
+ # carrying the same location label, so ord must land on pop-ord alone.
timeout: 120s
resource:
apiVersion: policy.karmada.io/v1alpha1
kind: PropagationPolicy
metadata:
namespace: ($downstreamNS)
- name: city-ord
+ name: location-ord
spec:
# Three selectors: the WorkloadDeployment plus the always-on ConfigMap
# and Secret referenced-data selectors. Chainsaw matches list length
@@ -79,7 +79,7 @@ spec:
kind: WorkloadDeployment
labelSelector:
matchLabels:
- topology.datum.net/city-code: ord
+ topology.datum.net/location: ord
- apiVersion: v1
kind: ConfigMap
labelSelector:
@@ -94,7 +94,7 @@ spec:
clusterAffinity:
labelSelector:
matchLabels:
- topology.datum.net/city-code: ord
+ topology.datum.net/location: ord
- name: assert-wd-on-pop-ord
description: Assert Karmada propagated the WD to pop-ord and the cell reconciler set status.
diff --git a/test/e2e/full-federation-ord/workload-deployment.yaml b/test/e2e/full-federation-ord/workload-deployment.yaml
index 74663331..42097bc0 100644
--- a/test/e2e/full-federation-ord/workload-deployment.yaml
+++ b/test/e2e/full-federation-ord/workload-deployment.yaml
@@ -4,7 +4,8 @@ metadata:
name: test-fullfed-ord-wd
# namespace is injected by Chainsaw from ($namespace)
spec:
- cityCode: ord
+ locationRef:
+ name: ord
placementName: default
workloadRef:
name: test-workload
diff --git a/test/e2e/full-federation/workload-deployment.yaml b/test/e2e/full-federation/workload-deployment.yaml
index 70b4cb94..f130351b 100644
--- a/test/e2e/full-federation/workload-deployment.yaml
+++ b/test/e2e/full-federation/workload-deployment.yaml
@@ -4,7 +4,8 @@ metadata:
name: test-full-fed-wd
# namespace is injected by Chainsaw from ($namespace)
spec:
- cityCode: dfw
+ locationRef:
+ name: dfw
placementName: default
workloadRef:
name: test-workload
diff --git a/test/e2e/instance-projection/workload-deployment.yaml b/test/e2e/instance-projection/workload-deployment.yaml
index 4d2d5979..580467e4 100644
--- a/test/e2e/instance-projection/workload-deployment.yaml
+++ b/test/e2e/instance-projection/workload-deployment.yaml
@@ -3,7 +3,8 @@ kind: WorkloadDeployment
metadata:
name: test-projector-wd
spec:
- cityCode: dfw
+ locationRef:
+ name: dfw
placementName: default
workloadRef:
name: test-workload
diff --git a/test/e2e/instance-writeback/chainsaw-test.yaml b/test/e2e/instance-writeback/chainsaw-test.yaml
index 537a5026..ada22886 100644
--- a/test/e2e/instance-writeback/chainsaw-test.yaml
+++ b/test/e2e/instance-writeback/chainsaw-test.yaml
@@ -108,7 +108,8 @@ spec:
name: test-writeback-wd
namespace: ${INSTANCE_NS}
spec:
- cityCode: dfw
+ locationRef:
+ name: dfw
placementName: default
workloadRef:
name: test-workload
diff --git a/test/e2e/instance-writeback/instance-pop-dfw.yaml b/test/e2e/instance-writeback/instance-pop-dfw.yaml
index aa5f11b2..c147a879 100644
--- a/test/e2e/instance-writeback/instance-pop-dfw.yaml
+++ b/test/e2e/instance-writeback/instance-pop-dfw.yaml
@@ -16,7 +16,7 @@ metadata:
compute.datumapis.com/workload-deployment-uid: "00000000-0000-0000-0000-000000000002"
compute.datumapis.com/instance-index: "0"
compute.datumapis.com/workload-deployment-name: test-writeback-wd
- compute.datumapis.com/city-code: dfw
+ compute.datumapis.com/location: dfw
compute.datumapis.com/workload-name: test-workload
compute.datumapis.com/placement-name: default
spec:
diff --git a/test/e2e/propagation-policy-lifecycle/chainsaw-test.yaml b/test/e2e/propagation-policy-lifecycle/chainsaw-test.yaml
index 5678c398..66f9aba9 100644
--- a/test/e2e/propagation-policy-lifecycle/chainsaw-test.yaml
+++ b/test/e2e/propagation-policy-lifecycle/chainsaw-test.yaml
@@ -6,13 +6,13 @@ spec:
description: |
Verifies the PropagationPolicy lifecycle managed by the WorkloadDeploymentFederator:
- - A PropagationPolicy (city-dfw) is lazily created when the first WorkloadDeployment
+ - A PropagationPolicy (location-dfw) is lazily created when the first WorkloadDeployment
for city code "dfw" is federated to Karmada.
- The PropagationPolicy is RETAINED while at least one WorkloadDeployment for
that city code remains in the Karmada namespace.
- The PropagationPolicy is DELETED when the last deployment for the city is removed.
- The test creates two WDs (wd-alpha, wd-beta) both targeting cityCode=dfw, verifies
+ The test creates two WDs (wd-alpha, wd-beta) both targeting location dfw, verifies
the PP appears, deletes wd-alpha and asserts the PP is still present, then deletes
wd-beta and waits for the PP to disappear.
@@ -66,7 +66,7 @@ spec:
kind: PropagationPolicy
metadata:
namespace: ($downstreamNS)
- name: city-dfw
+ name: location-dfw
- name: delete-alpha
description: Delete wd-alpha; wd-beta still targets dfw so the PP must be retained.
@@ -99,7 +99,7 @@ spec:
kind: PropagationPolicy
metadata:
namespace: ($downstreamNS)
- name: city-dfw
+ name: location-dfw
- name: delete-beta
description: Delete wd-beta (the last WD for city dfw).
@@ -127,7 +127,7 @@ spec:
apiVersion: policy.karmada.io/v1alpha1
kind: PropagationPolicy
namespace: ($downstreamNS)
- name: city-dfw
+ name: location-dfw
timeout: 30s
for:
deletion: {}
diff --git a/test/e2e/propagation-policy-lifecycle/workload-deployment-alpha.yaml b/test/e2e/propagation-policy-lifecycle/workload-deployment-alpha.yaml
index f9eb27fd..527ec9b3 100644
--- a/test/e2e/propagation-policy-lifecycle/workload-deployment-alpha.yaml
+++ b/test/e2e/propagation-policy-lifecycle/workload-deployment-alpha.yaml
@@ -3,7 +3,8 @@ kind: WorkloadDeployment
metadata:
name: wd-alpha
spec:
- cityCode: dfw
+ locationRef:
+ name: dfw
placementName: default
workloadRef:
name: test-workload
diff --git a/test/e2e/propagation-policy-lifecycle/workload-deployment-beta.yaml b/test/e2e/propagation-policy-lifecycle/workload-deployment-beta.yaml
index fd1d65c1..30267a8d 100644
--- a/test/e2e/propagation-policy-lifecycle/workload-deployment-beta.yaml
+++ b/test/e2e/propagation-policy-lifecycle/workload-deployment-beta.yaml
@@ -3,7 +3,8 @@ kind: WorkloadDeployment
metadata:
name: wd-beta
spec:
- cityCode: dfw
+ locationRef:
+ name: dfw
placementName: default
workloadRef:
name: test-workload
diff --git a/test/e2e/referenced-data-delete-cascade/workload-deployment.yaml b/test/e2e/referenced-data-delete-cascade/workload-deployment.yaml
index 99534bae..d902239c 100644
--- a/test/e2e/referenced-data-delete-cascade/workload-deployment.yaml
+++ b/test/e2e/referenced-data-delete-cascade/workload-deployment.yaml
@@ -4,7 +4,8 @@ metadata:
name: gc-test-wd
# namespace injected by Chainsaw from ($namespace)
spec:
- cityCode: dfw
+ locationRef:
+ name: dfw
placementName: default
workloadRef:
name: gc-test-workload
diff --git a/test/e2e/referenced-data-mounts/chainsaw-test.yaml b/test/e2e/referenced-data-mounts/chainsaw-test.yaml
index bcef1234..dd3a94d3 100644
--- a/test/e2e/referenced-data-mounts/chainsaw-test.yaml
+++ b/test/e2e/referenced-data-mounts/chainsaw-test.yaml
@@ -18,7 +18,7 @@ spec:
Companions are NOT written to the control-plane cluster.
[Hop 3] Karmada hub holds the companion ConfigMap + Secret in ns-{project-uid},
- propagated by the always-on label selector in the city-dfw
+ propagated by the always-on label selector in the location-dfw
PropagationPolicy (which includes ConfigMap and Secret selectors).
[Hop 4] Karmada propagates the WD + companions to pop-dfw.
@@ -197,7 +197,7 @@ spec:
- name: assert-propagation-policy-has-companion-selectors
description: |
- Assert the PropagationPolicy city-dfw on the hub includes ConfigMap and
+ Assert the PropagationPolicy location-dfw on the hub includes ConfigMap and
Secret resource selectors so companions co-propagate with the WD.
cluster: downstream
try:
@@ -216,7 +216,7 @@ spec:
kind: PropagationPolicy
metadata:
namespace: ($downstreamNS)
- name: city-dfw
+ name: location-dfw
spec:
resourceSelectors:
- apiVersion: compute.datumapis.com/v1alpha
@@ -224,7 +224,7 @@ spec:
namespace: ($downstreamNS)
labelSelector:
matchLabels:
- topology.datum.net/city-code: dfw
+ topology.datum.net/location: dfw
- apiVersion: v1
kind: ConfigMap
namespace: ($downstreamNS)
diff --git a/test/e2e/referenced-data-mounts/workload-deployment.yaml b/test/e2e/referenced-data-mounts/workload-deployment.yaml
index d849be0b..78df8da6 100644
--- a/test/e2e/referenced-data-mounts/workload-deployment.yaml
+++ b/test/e2e/referenced-data-mounts/workload-deployment.yaml
@@ -4,7 +4,8 @@ metadata:
name: test-refdata-wd
# namespace injected by Chainsaw from ($namespace)
spec:
- cityCode: dfw
+ locationRef:
+ name: dfw
placementName: default
workloadRef:
name: test-workload
diff --git a/test/e2e/referenced-data-pull-secret/chainsaw-test.yaml b/test/e2e/referenced-data-pull-secret/chainsaw-test.yaml
index 77805dca..96eec719 100644
--- a/test/e2e/referenced-data-pull-secret/chainsaw-test.yaml
+++ b/test/e2e/referenced-data-pull-secret/chainsaw-test.yaml
@@ -18,7 +18,7 @@ spec:
ReferencedDataController materialises a companion Secret in
ns-{project-uid} on the Karmada hub and lists it in the
expected-referenced-data annotation.
- [Hop 3] Karmada propagates the companion to pop-dfw via the city-dfw
+ [Hop 3] Karmada propagates the companion to pop-dfw via the location-dfw
PropagationPolicy Secret selector (label-based, source-agnostic).
[Hop 4] The Instance's ReferencedData scheduling gate clears only once the
credential is present on the cell.
diff --git a/test/e2e/referenced-data-pull-secret/workload-deployment-no-pull-secret.yaml b/test/e2e/referenced-data-pull-secret/workload-deployment-no-pull-secret.yaml
index 19c6eed1..d65773f2 100644
--- a/test/e2e/referenced-data-pull-secret/workload-deployment-no-pull-secret.yaml
+++ b/test/e2e/referenced-data-pull-secret/workload-deployment-no-pull-secret.yaml
@@ -4,7 +4,8 @@ metadata:
name: test-pullsecret-wd
# namespace injected by Chainsaw from ($namespace)
spec:
- cityCode: dfw
+ locationRef:
+ name: dfw
placementName: default
workloadRef:
name: test-workload
diff --git a/test/e2e/referenced-data-pull-secret/workload-deployment.yaml b/test/e2e/referenced-data-pull-secret/workload-deployment.yaml
index f32f012f..e4d1a24c 100644
--- a/test/e2e/referenced-data-pull-secret/workload-deployment.yaml
+++ b/test/e2e/referenced-data-pull-secret/workload-deployment.yaml
@@ -4,7 +4,8 @@ metadata:
name: test-pullsecret-wd
# namespace injected by Chainsaw from ($namespace)
spec:
- cityCode: dfw
+ locationRef:
+ name: dfw
placementName: default
workloadRef:
name: test-workload
diff --git a/test/e2e/suspension/workload-deployment-suspended.yaml b/test/e2e/suspension/workload-deployment-suspended.yaml
index 40aa416e..b9505ac7 100644
--- a/test/e2e/suspension/workload-deployment-suspended.yaml
+++ b/test/e2e/suspension/workload-deployment-suspended.yaml
@@ -6,7 +6,8 @@ metadata:
annotations:
compute.datumapis.com/suspended: "true"
spec:
- cityCode: dfw
+ locationRef:
+ name: dfw
placementName: default
workloadRef:
name: test-workload
diff --git a/test/e2e/suspension/workload-deployment.yaml b/test/e2e/suspension/workload-deployment.yaml
index 213ed8f4..883599f6 100644
--- a/test/e2e/suspension/workload-deployment.yaml
+++ b/test/e2e/suspension/workload-deployment.yaml
@@ -4,7 +4,8 @@ metadata:
name: test-suspend-wd
# namespace is injected by Chainsaw from ($namespace)
spec:
- cityCode: dfw
+ locationRef:
+ name: dfw
placementName: default
workloadRef:
name: test-workload
diff --git a/test/e2e/workload-deployment-federation/chainsaw-test.yaml b/test/e2e/workload-deployment-federation/chainsaw-test.yaml
index 8d589310..6659243b 100644
--- a/test/e2e/workload-deployment-federation/chainsaw-test.yaml
+++ b/test/e2e/workload-deployment-federation/chainsaw-test.yaml
@@ -6,7 +6,7 @@ spec:
description: |
Verifies that the WorkloadDeploymentFederator replicates a WorkloadDeployment
from the project namespace (control-plane cluster) to the Karmada API server
- with the correct city-code label and PropagationPolicy.
+ with the correct location label and PropagationPolicy.
The federator follows the ns- convention for Karmada namespaces,
matching the MappedNamespaceResourceStrategy used by NSO. The test derives
@@ -14,9 +14,9 @@ spec:
Verified:
- WorkloadDeployment exists in Karmada at ns-
- - Karmada copy carries label topology.datum.net/city-code: dfw
- - PropagationPolicy city-dfw exists in the Karmada namespace,
- selecting WDs by city-code and routing them to matching POP-cell clusters.
+ - Karmada copy carries label topology.datum.net/location: dfw
+ - PropagationPolicy location-dfw exists in the Karmada namespace,
+ selecting WDs by location and routing them to matching POP-cell clusters.
template: true
@@ -28,7 +28,7 @@ spec:
file: workload-deployment.yaml
- name: assert-wd-in-downstream
- description: Assert WorkloadDeployment federated to Karmada with city-code label.
+ description: Assert WorkloadDeployment federated to Karmada with location label.
cluster: downstream
try:
- script:
@@ -48,10 +48,10 @@ spec:
namespace: ($downstreamNS)
name: test-federation-wd
labels:
- topology.datum.net/city-code: dfw
+ topology.datum.net/location: dfw
- name: assert-propagation-policy-in-downstream
- description: Assert PropagationPolicy created for city-dfw.
+ description: Assert PropagationPolicy created for location-dfw.
cluster: downstream
try:
- script:
@@ -69,7 +69,7 @@ spec:
kind: PropagationPolicy
metadata:
namespace: ($downstreamNS)
- name: city-dfw
+ name: location-dfw
spec:
# The federator emits three resource selectors, not one: the
# WorkloadDeployment plus the always-on ConfigMap and Secret
@@ -80,7 +80,7 @@ spec:
kind: WorkloadDeployment
labelSelector:
matchLabels:
- topology.datum.net/city-code: dfw
+ topology.datum.net/location: dfw
- apiVersion: v1
kind: ConfigMap
labelSelector:
@@ -95,4 +95,4 @@ spec:
clusterAffinity:
labelSelector:
matchLabels:
- topology.datum.net/city-code: dfw
+ topology.datum.net/location: dfw
diff --git a/test/e2e/workload-deployment-federation/workload-deployment.yaml b/test/e2e/workload-deployment-federation/workload-deployment.yaml
index 0cd2347a..739d2f6d 100644
--- a/test/e2e/workload-deployment-federation/workload-deployment.yaml
+++ b/test/e2e/workload-deployment-federation/workload-deployment.yaml
@@ -4,7 +4,8 @@ metadata:
name: test-federation-wd
# namespace is injected by Chainsaw from ($namespace)
spec:
- cityCode: dfw
+ locationRef:
+ name: dfw
placementName: default
workloadRef:
name: test-workload
diff --git a/test/interpreter/workloaddeployment-retain-desired.yaml b/test/interpreter/workloaddeployment-retain-desired.yaml
index 73c75383..4229e1ff 100644
--- a/test/interpreter/workloaddeployment-retain-desired.yaml
+++ b/test/interpreter/workloaddeployment-retain-desired.yaml
@@ -7,7 +7,8 @@ spec:
workloadRef:
name: test
placementName: default
- cityCode: DFW
+ locationRef:
+ name: us-east-1
template: {}
scaleSettings:
minReplicas: 1
diff --git a/test/interpreter/workloaddeployment-retain-observed.yaml b/test/interpreter/workloaddeployment-retain-observed.yaml
index f1f2d36b..a7c6af92 100644
--- a/test/interpreter/workloaddeployment-retain-observed.yaml
+++ b/test/interpreter/workloaddeployment-retain-observed.yaml
@@ -7,7 +7,8 @@ spec:
workloadRef:
name: test
placementName: default
- cityCode: DFW
+ locationRef:
+ name: us-east-1
template: {}
scaleSettings:
minReplicas: 1
diff --git a/ui/consumer/src/adapter.ts b/ui/consumer/src/adapter.ts
index 64dbb50c..87d17d25 100644
--- a/ui/consumer/src/adapter.ts
+++ b/ui/consumer/src/adapter.ts
@@ -61,18 +61,22 @@ interface RawRuntime {
export const INSTANCE_LABELS = {
workloadName: 'compute.datumapis.com/workload-name',
workloadUid: 'compute.datumapis.com/workload-uid',
- cityCode: 'compute.datumapis.com/city-code',
+ location: 'compute.datumapis.com/location',
placementName: 'compute.datumapis.com/placement-name',
} as const;
interface RawWorkloadPlacement {
name: string;
+ locations?: Array<{ name: string }>;
+ locationSelector?: RawLabelSelector;
+ /** Deprecated: stored before placement moved to locations and not yet rewritten. */
cityCodes?: string[];
scaleSettings?: { minReplicas?: number; maxReplicas?: number };
}
interface RawWorkloadPlacementStatus {
name?: string;
+ locations?: Array<{ name: string }>;
conditions?: RawCondition[];
replicas?: number;
currentReplicas?: number;
@@ -179,6 +183,55 @@ function deriveUpdatedAt(
return latest ?? undefined;
}
+interface RawLabelSelector {
+ matchLabels?: Record;
+ matchExpressions?: Array<{ key: string; operator: string; values?: string[] }>;
+}
+
+/** Renders a label selector the way kubectl prints it, e.g. "city-code=DFW, region in (a,b)". */
+function formatLabelSelector(selector: RawLabelSelector): string {
+ const parts: string[] = [];
+ for (const [key, value] of Object.entries(selector.matchLabels ?? {})) {
+ parts.push(`${key}=${value}`);
+ }
+ for (const expr of selector.matchExpressions ?? []) {
+ const values = (expr.values ?? []).join(',');
+ switch (expr.operator) {
+ case 'In':
+ parts.push(`${expr.key} in (${values})`);
+ break;
+ case 'NotIn':
+ parts.push(`${expr.key} notin (${values})`);
+ break;
+ case 'Exists':
+ parts.push(expr.key);
+ break;
+ case 'DoesNotExist':
+ parts.push(`!${expr.key}`);
+ break;
+ default:
+ parts.push(`${expr.key} ${expr.operator} (${values})`);
+ }
+ }
+ return parts.join(', ');
+}
+
+/**
+ * The locations a placement runs at: what the controller resolved when status
+ * is present, else what the spec names. A selector-based placement has no
+ * names in its spec, so status is the only place its locations appear.
+ */
+function placementLocations(p: RawWorkloadPlacement, status?: RawWorkloadPlacementStatus): string[] {
+ const resolved = (status?.locations ?? []).map((location) => location.name);
+ if (resolved.length > 0) return resolved;
+ return (p.locations ?? []).map((location) => location.name);
+}
+
+function workloadLocations(placements: RawWorkloadPlacement[], statusPlacements: RawWorkloadPlacementStatus[]): string[] {
+ const statusByName = new Map(statusPlacements.filter((s) => !!s.name).map((s) => [s.name, s]));
+ return Array.from(new Set(placements.flatMap((p) => placementLocations(p, statusByName.get(p.name)))));
+}
+
function toPlacementRegions(
placements: RawWorkloadPlacement[],
statusPlacements: RawWorkloadPlacementStatus[]
@@ -209,7 +262,12 @@ function toPlacementRegions(
return {
name: p.name,
- cityCodes: p.cityCodes ?? [],
+ locations: placementLocations(p, status),
+ locationSelector: p.locationSelector
+ ? formatLabelSelector(p.locationSelector)
+ : p.cityCodes && p.cityCodes.length > 0
+ ? `topology.datum.net/city-code in (${p.cityCodes.join(',')})`
+ : undefined,
readyReplicas: ready,
desiredReplicas: desired,
health,
@@ -243,7 +301,7 @@ export function toWorkload(raw: RawWorkload): Workload {
runtimeType: runtime ? (runtime.sandbox ? 'Container sandbox' : 'Virtual machine') : undefined,
tags: deriveTags(runtime),
ports,
- regions: Array.from(new Set(placements.flatMap((p) => p.cityCodes ?? []))),
+ locations: workloadLocations(placements, raw.status?.placements ?? []),
resources: deriveResources(runtime),
replicasPerRegion: deriveReplicasPerRegion(placements),
conditions: conditions.map((c) => ({
@@ -344,7 +402,7 @@ export function toInstance(raw: RawInstance): Instance {
: new Date(),
workloadName: labels[INSTANCE_LABELS.workloadName],
workloadUid: labels[INSTANCE_LABELS.workloadUid],
- city: labels[INSTANCE_LABELS.cityCode],
+ location: labels[INSTANCE_LABELS.location],
placement: labels[INSTANCE_LABELS.placementName],
instanceType: raw.spec?.runtime?.resources?.instanceType,
cpu,
diff --git a/ui/consumer/src/components/instance-page-chrome.tsx b/ui/consumer/src/components/instance-page-chrome.tsx
index 1e4d19b9..606cccdf 100644
--- a/ui/consumer/src/components/instance-page-chrome.tsx
+++ b/ui/consumer/src/components/instance-page-chrome.tsx
@@ -101,12 +101,12 @@ export function InstancePageChrome({
aria-hidden
/>
{instance.status}
- {instance.city ? (
+ {instance.location ? (
<>
·
- {instance.city}
+ {instance.location}
) : null}
diff --git a/ui/consumer/src/pages/workload-detail.tsx b/ui/consumer/src/pages/workload-detail.tsx
index ffd27969..04da275f 100644
--- a/ui/consumer/src/pages/workload-detail.tsx
+++ b/ui/consumer/src/pages/workload-detail.tsx
@@ -86,7 +86,7 @@ function InstanceCard({ instance, onClick }: { instance: Instance; onClick: () =
{instance.name}
- {instance.city ?? 'Unknown region'}
+ {instance.location ?? 'Unknown location'}
{instance.status}
@@ -211,14 +211,14 @@ function ConfigurationCard({ workload }: { workload: Workload }) {
label: 'Replicas',
content:
workload.replicasPerRegion !== undefined
- ? `${workload.replicasPerRegion}/region · ${workload.desiredReplicas} total`
+ ? `${workload.replicasPerRegion}/location · ${workload.desiredReplicas} total`
: `${workload.desiredReplicas} total`,
},
{
- label: 'Regions',
+ label: 'Locations',
content:
- workload.regions.length > 0 ? (
- workload.regions.join(', ')
+ workload.locations.length > 0 ? (
+ workload.locations.join(', ')
) : (
—
),
@@ -252,7 +252,7 @@ export default function WorkloadDetail() {
const totalCount = workload ? instances.length || workload.desiredReplicas : 0;
const allHealthy = totalCount > 0 && healthyCount === totalCount;
- const regions = workload?.regions ?? [];
+ const locations = workload?.locations ?? [];
const stats: Stat[] | null = workload
? [
@@ -271,7 +271,7 @@ export default function WorkloadDetail() {
? 'text-green-600 dark:text-green-500'
: undefined,
},
- { label: 'Regions', value: String(regions.length) },
+ { label: 'Locations', value: String(locations.length) },
{
label: 'Requests',
value: COMING_SOON,
@@ -358,9 +358,9 @@ export default function WorkloadDetail() {
Instance Locations
- {regions.length > 0
- ? `Regions where this workload is deployed: ${regions.join(', ')}.`
- : 'Regions where this workload is deployed.'}
+ {locations.length > 0
+ ? `Locations where this workload is deployed: ${locations.join(', ')}.`
+ : 'Locations where this workload is deployed.'}
- Regions
+ Locations
{workload.placementRegions.map((region) => (
{isLoading && ;
+ matchExpressions?: Array<{ key: string; operator: string; values?: string[] }>;
+}
+
+/** Renders a label selector the way kubectl prints it, e.g. "city-code=DFW, region in (a,b)". */
+function formatLabelSelector(selector: RawLabelSelector): string {
+ const parts: string[] = [];
+ for (const [key, value] of Object.entries(selector.matchLabels ?? {})) {
+ parts.push(`${key}=${value}`);
+ }
+ for (const expr of selector.matchExpressions ?? []) {
+ const values = (expr.values ?? []).join(',');
+ switch (expr.operator) {
+ case 'In':
+ parts.push(`${expr.key} in (${values})`);
+ break;
+ case 'NotIn':
+ parts.push(`${expr.key} notin (${values})`);
+ break;
+ case 'Exists':
+ parts.push(expr.key);
+ break;
+ case 'DoesNotExist':
+ parts.push(`!${expr.key}`);
+ break;
+ default:
+ parts.push(`${expr.key} ${expr.operator} (${values})`);
+ }
+ }
+ return parts.join(', ');
+}
+
+/**
+ * The locations a placement runs at: what the controller resolved when status
+ * is present, else what the spec names. A selector-based placement has no
+ * names in its spec, so status is the only place its locations appear.
+ */
+function placementLocations(p: RawWorkloadPlacement, status?: RawWorkloadPlacementStatus): string[] {
+ const resolved = (status?.locations ?? []).map((location) => location.name);
+ if (resolved.length > 0) return resolved;
+ return (p.locations ?? []).map((location) => location.name);
+}
+
+function workloadLocations(placements: RawWorkloadPlacement[], statusPlacements: RawWorkloadPlacementStatus[]): string[] {
+ const statusByName = new Map(statusPlacements.filter((s) => !!s.name).map((s) => [s.name, s]));
+ return Array.from(new Set(placements.flatMap((p) => placementLocations(p, statusByName.get(p.name)))));
+}
+
function toPlacements(
placements: RawWorkloadPlacement[],
statusPlacements: RawWorkloadPlacementStatus[]
@@ -163,7 +216,12 @@ function toPlacements(
return {
name: p.name,
- cityCodes: p.cityCodes ?? [],
+ locations: placementLocations(p, status),
+ locationSelector: p.locationSelector
+ ? formatLabelSelector(p.locationSelector)
+ : p.cityCodes && p.cityCodes.length > 0
+ ? `topology.datum.net/city-code in (${p.cityCodes.join(',')})`
+ : undefined,
readyReplicas: ready,
desiredReplicas: desired,
currentReplicas: current,
@@ -194,7 +252,7 @@ export function toWorkload(raw: RawWorkload): Workload {
placements: toPlacements(placements, raw.status?.placements ?? []),
conditions: toConditions(conditions),
runtimeType: runtime ? (runtime.sandbox ? 'Container sandbox' : 'Virtual machine') : undefined,
- regions: Array.from(new Set(placements.flatMap((p) => p.cityCodes ?? []))),
+ locations: workloadLocations(placements, raw.status?.placements ?? []),
resources: deriveResources(runtime),
replicasPerRegion: deriveReplicasPerRegion(placements),
};
@@ -282,7 +340,7 @@ export function toInstance(raw: RawInstance): Instance {
createdAt: raw.metadata?.creationTimestamp
? new Date(raw.metadata.creationTimestamp)
: new Date(),
- city: labels['compute.datumapis.com/city-code'],
+ location: labels['compute.datumapis.com/location'],
placement: labels['compute.datumapis.com/placement-name'],
instanceType: raw.spec?.runtime?.resources?.instanceType,
cpu,
diff --git a/ui/provider/src/pages/fleet-workloads.tsx b/ui/provider/src/pages/fleet-workloads.tsx
index bc68bd06..2a2e2484 100644
--- a/ui/provider/src/pages/fleet-workloads.tsx
+++ b/ui/provider/src/pages/fleet-workloads.tsx
@@ -125,9 +125,9 @@ function WorkloadsTable({ workloads }: { workloads: FleetWorkload[] }) {
),
}),
- columnHelper.accessor((row) => row.workload.regions.join(', '), {
- id: 'regions',
- header: 'Regions',
+ columnHelper.accessor((row) => row.workload.locations.join(', '), {
+ id: 'locations',
+ header: 'Locations',
cell: ({ getValue }) => {getValue() || '—'},
}),
columnHelper.accessor((row) => row.statusSince.getTime(), {
diff --git a/ui/provider/src/pages/workload-detail.tsx b/ui/provider/src/pages/workload-detail.tsx
index 435841e1..8d279f28 100644
--- a/ui/provider/src/pages/workload-detail.tsx
+++ b/ui/provider/src/pages/workload-detail.tsx
@@ -107,10 +107,10 @@ function ConfigurationCard({ workload }: { workload: Workload }) {
label: 'Replicas',
content:
workload.replicasPerRegion !== undefined
- ? `${workload.replicasPerRegion}/region · ${workload.desiredReplicas} total`
+ ? `${workload.replicasPerRegion}/location · ${workload.desiredReplicas} total`
: `${workload.desiredReplicas} total`,
},
- { label: 'Regions', content: workload.regions.join(', ') || '—' },
+ { label: 'Locations', content: workload.locations.join(', ') || '—' },
]}
/>
@@ -135,7 +135,7 @@ function PlacementsCard({ workload }: { workload: Workload }) {
{p.name}
- {p.cityCodes.join(', ') || 'no city codes'}
+ {p.locations.join(', ') || p.locationSelector || 'no locations'}
@@ -170,7 +170,7 @@ function OverviewTab({ workload }: { workload: Workload }) {
{ label: 'Ready', value: `${workload.readyReplicas}/${workload.desiredReplicas}` },
{ label: 'Current', value: `${workload.currentReplicas}/${workload.desiredReplicas}` },
{ label: 'Updated', value: `${workload.updatedReplicas}/${workload.desiredReplicas}` },
- { label: 'Regions', value: String(workload.regions.length) },
+ { label: 'Locations', value: String(workload.locations.length) },
];
return (
@@ -203,7 +203,7 @@ function InstanceRow({ instance }: { instance: Instance }) {
)}
- {instance.city ?? '—'}
+ {instance.location ?? '—'}
{instance.internalIP ?? '—'}
@@ -245,7 +245,7 @@ function InstancesTab({ instances }: { instances: Instance[] }) {
Instance
- Region
+ Location
Internal IP
External IP
Message
diff --git a/ui/provider/src/pages/workload-list.tsx b/ui/provider/src/pages/workload-list.tsx
index 34d0592a..32175b35 100644
--- a/ui/provider/src/pages/workload-list.tsx
+++ b/ui/provider/src/pages/workload-list.tsx
@@ -39,7 +39,7 @@ function WorkloadRow({ workload }: { workload: Workload }) {
{workload.readyReplicas}/{workload.desiredReplicas}
- {workload.regions.join(', ') || '—'}
+ {workload.locations.join(', ') || '—'}
{formatDistanceToNowStrict(workload.createdAt, { addSuffix: true })}
@@ -78,7 +78,7 @@ export default function WorkloadList() {
Name
Health
Ready
- Regions
+ Locations
Created
diff --git a/ui/provider/src/schema.ts b/ui/provider/src/schema.ts
index eab5675b..1f1386a3 100644
--- a/ui/provider/src/schema.ts
+++ b/ui/provider/src/schema.ts
@@ -25,7 +25,9 @@ export type Condition = z.infer;
export const workloadPlacementSchema = z.object({
name: z.string(),
- cityCodes: z.array(z.string()).default([]),
+ locations: z.array(z.string()).default([]),
+ /** Topology selector the placement resolves through, when it does not name locations. */
+ locationSelector: z.string().optional(),
readyReplicas: z.number(),
desiredReplicas: z.number(),
currentReplicas: z.number(),
@@ -49,7 +51,7 @@ export const workloadResourceSchema = z.object({
placements: z.array(workloadPlacementSchema).default([]),
conditions: z.array(conditionSchema).default([]),
runtimeType: z.string().optional(),
- regions: z.array(z.string()).default([]),
+ locations: z.array(z.string()).default([]),
resources: z.string().optional(),
replicasPerRegion: z.number().optional(),
});
@@ -89,7 +91,7 @@ export const instanceResourceSchema = z.object({
name: z.string(),
namespace: z.string().optional(),
createdAt: z.coerce.date(),
- city: z.string().optional(),
+ location: z.string().optional(),
placement: z.string().optional(),
instanceType: z.string().optional(),
cpu: z.string().optional(),