From 311325d198d06194c90f2c6464fb996dbc54a3e2 Mon Sep 17 00:00:00 2001 From: rkoster Date: Fri, 10 Apr 2026 15:01:31 +0000 Subject: [PATCH 1/4] Enhance add-access-rule command UX with intuitive name-based flags MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This commit improves the user experience for the add-access-rule command by replacing the positional GUID-based SELECTOR argument with intuitive flags that accept human-readable names and support cross-space/org resolution. Changes: **Command Interface:** - Remove positional SELECTOR argument (breaking change, acceptable for unreleased feature) - Add new flags: --source-app, --source-space, --source-org, --source-any, --selector - Support hierarchical name resolution: - --source-app APP_NAME (looks in current space) - --source-app APP_NAME --source-space SPACE (cross-space in current org) - --source-app APP_NAME --source-space SPACE --source-org ORG (cross-org) - --source-space SPACE (space-level rule) - --source-org ORG (org-level rule) - --source-any (allow any authenticated app) - --selector SELECTOR (raw GUID-based selector for advanced users) - Validate exactly one primary source is specified - Display verbose output showing resolved selector for transparency **Terminology Update:** - Rename all "target" terminology to "source" throughout codebase - Access rules specify the source (who can access), not the target - Update AccessRuleWithRoute.TargetName → SourceName - Update resolveAccessRuleTarget() → resolveAccessRuleSource() - Update access-rules list command table header: "target" → "source" **Error Handling:** - Provide helpful error messages when app not found in current space - Suggest using --source-space and --source-org flags for cross-space/org access - Follow CF CLI patterns from add-network-policy command **Testing:** - Add 17 comprehensive test cases for add-access-rule command - Update 19 actor tests to use new SourceName field - All tests passing (36/36) **Domain Integration:** - Add enforce_access_rules support to create-shared-domain and create-private-domain - Add --enforce-access-rules and --access-rules-scope flags - Update domain resource with new fields Examples: # Simple case - app in current space cf add-access-rule allow-frontend apps.identity --source-app frontend-app --hostname backend # Cross-space access cf add-access-rule allow-other apps.identity --source-app api-client --source-space other-space --hostname backend # Cross-org access cf add-access-rule allow-prod apps.identity --source-app client --source-space prod-space --source-org prod-org --hostname api # Space-level rule cf add-access-rule allow-monitoring apps.identity --source-space monitoring --hostname api # Org-level rule cf add-access-rule allow-platform apps.identity --source-org platform --hostname shared-api # Any authenticated app cf add-access-rule allow-all apps.identity --source-any --hostname public-api Related to: https://github.com/cloudfoundry/community/pull/1438 --- .../access_rule_not_found_error.go | 11 + actor/v7action/access_rule.go | 383 +++++++++ actor/v7action/access_rule_test.go | 755 ++++++++++++++++++ actor/v7action/cloud_controller_client.go | 3 + actor/v7action/domain.go | 29 +- actor/v7action/domain_test.go | 4 +- .../fake_cloud_controller_client.go | 251 ++++++ api/cloudcontroller/ccv3/access_rule.go | 59 ++ .../ccv3/included_resources.go | 2 + .../ccv3/internal/api_routes.go | 8 + api/cloudcontroller/ccv3/query.go | 2 + command/common/command_list_v7.go | 3 + command/common/internal/help_all_display.go | 1 + command/flag/arguments.go | 10 + command/v7/access_rules_command.go | 103 +++ command/v7/access_rules_command_test.go | 356 +++++++++ command/v7/actor.go | 8 +- command/v7/add_access_rule_command.go | 284 +++++++ command/v7/add_access_rule_command_test.go | 453 +++++++++++ command/v7/create_private_domain_command.go | 35 +- .../v7/create_private_domain_command_test.go | 2 +- command/v7/create_shared_domain_command.go | 42 +- .../v7/create_shared_domain_command_test.go | 2 +- command/v7/remove_access_rule_command.go | 71 ++ command/v7/v7fakes/fake_actor.go | 384 ++++++++- resources/access_rule_resource.go | 84 ++ resources/access_rule_resource_test.go | 69 ++ resources/domain_resource.go | 32 +- 28 files changed, 3388 insertions(+), 58 deletions(-) create mode 100644 actor/actionerror/access_rule_not_found_error.go create mode 100644 actor/v7action/access_rule.go create mode 100644 actor/v7action/access_rule_test.go create mode 100644 api/cloudcontroller/ccv3/access_rule.go create mode 100644 command/v7/access_rules_command.go create mode 100644 command/v7/access_rules_command_test.go create mode 100644 command/v7/add_access_rule_command.go create mode 100644 command/v7/add_access_rule_command_test.go create mode 100644 command/v7/remove_access_rule_command.go create mode 100644 resources/access_rule_resource.go create mode 100644 resources/access_rule_resource_test.go diff --git a/actor/actionerror/access_rule_not_found_error.go b/actor/actionerror/access_rule_not_found_error.go new file mode 100644 index 00000000000..bf5710421e5 --- /dev/null +++ b/actor/actionerror/access_rule_not_found_error.go @@ -0,0 +1,11 @@ +package actionerror + +import "fmt" + +type AccessRuleNotFoundError struct { + Name string +} + +func (e AccessRuleNotFoundError) Error() string { + return fmt.Sprintf("Access rule '%s' not found.", e.Name) +} diff --git a/actor/v7action/access_rule.go b/actor/v7action/access_rule.go new file mode 100644 index 00000000000..e74bd789497 --- /dev/null +++ b/actor/v7action/access_rule.go @@ -0,0 +1,383 @@ +package v7action + +import ( + "code.cloudfoundry.org/cli/v9/actor/actionerror" + "code.cloudfoundry.org/cli/v9/api/cloudcontroller/ccv3" + "code.cloudfoundry.org/cli/v9/resources" +) + +func (actor Actor) AddAccessRule(ruleName, domainName, selector, hostname, path string) (Warnings, error) { + allWarnings := Warnings{} + + // Get the domain to ensure it exists and supports access rules + domain, warnings, err := actor.GetDomainByName(domainName) + allWarnings = append(allWarnings, warnings...) + if err != nil { + return allWarnings, err + } + + // Find the route + routes, routeWarnings, err := actor.GetRoutesByDomain(domain.GUID, hostname, path) + allWarnings = append(allWarnings, routeWarnings...) + if err != nil { + return allWarnings, err + } + + if len(routes) == 0 { + return allWarnings, actionerror.RouteNotFoundError{ + Host: hostname, + DomainName: domainName, + Path: path, + } + } + + route := routes[0] + + // Create the access rule + accessRule := resources.AccessRule{ + Name: ruleName, + Selector: selector, + RouteGUID: route.GUID, + } + + _, apiWarnings, err := actor.CloudControllerClient.CreateAccessRule(accessRule) + allWarnings = append(allWarnings, Warnings(apiWarnings)...) + + return allWarnings, err +} + +func (actor Actor) GetAccessRulesByRoute(domainName, hostname, path string) ([]resources.AccessRule, Warnings, error) { + allWarnings := Warnings{} + + // Get the domain + domain, warnings, err := actor.GetDomainByName(domainName) + allWarnings = append(allWarnings, warnings...) + if err != nil { + return nil, allWarnings, err + } + + // Find the route + routes, routeWarnings, err := actor.GetRoutesByDomain(domain.GUID, hostname, path) + allWarnings = append(allWarnings, routeWarnings...) + if err != nil { + return nil, allWarnings, err + } + + if len(routes) == 0 { + return nil, allWarnings, actionerror.RouteNotFoundError{ + Host: hostname, + DomainName: domainName, + Path: path, + } + } + + route := routes[0] + + // Get access rules for this route + accessRules, _, apiWarnings, err := actor.CloudControllerClient.GetAccessRules( + ccv3.Query{Key: ccv3.RouteGUIDFilter, Values: []string{route.GUID}}, + ) + allWarnings = append(allWarnings, Warnings(apiWarnings)...) + + var rules []resources.AccessRule + for _, rule := range accessRules { + rules = append(rules, resources.AccessRule(rule)) + } + + return rules, allWarnings, err +} + +func (actor Actor) DeleteAccessRule(ruleName, domainName, hostname, path string) (Warnings, error) { + allWarnings := Warnings{} + + // Get the domain + domain, warnings, err := actor.GetDomainByName(domainName) + allWarnings = append(allWarnings, warnings...) + if err != nil { + return allWarnings, err + } + + // Find the route + routes, routeWarnings, err := actor.GetRoutesByDomain(domain.GUID, hostname, path) + allWarnings = append(allWarnings, routeWarnings...) + if err != nil { + return allWarnings, err + } + + if len(routes) == 0 { + return allWarnings, actionerror.RouteNotFoundError{ + Host: hostname, + DomainName: domainName, + Path: path, + } + } + + route := routes[0] + + // Get access rules for this route to find the one with matching name + accessRules, _, apiWarnings, err := actor.CloudControllerClient.GetAccessRules( + ccv3.Query{Key: ccv3.RouteGUIDFilter, Values: []string{route.GUID}}, + ) + allWarnings = append(allWarnings, Warnings(apiWarnings)...) + if err != nil { + return allWarnings, err + } + + // Find the rule with matching name + var ruleGUID string + for _, rule := range accessRules { + if rule.Name == ruleName { + ruleGUID = rule.GUID + break + } + } + + if ruleGUID == "" { + return allWarnings, actionerror.AccessRuleNotFoundError{Name: ruleName} + } + + // Delete the access rule + _, deleteWarnings, err := actor.CloudControllerClient.DeleteAccessRule(ruleGUID) + allWarnings = append(allWarnings, Warnings(deleteWarnings)...) + + return allWarnings, err +} + +// GetRoutesByDomain gets routes for a domain with optional hostname and path filters +func (actor Actor) GetRoutesByDomain(domainGUID, hostname, path string) ([]resources.Route, Warnings, error) { + queries := []ccv3.Query{ + {Key: ccv3.DomainGUIDFilter, Values: []string{domainGUID}}, + } + + if hostname != "" { + queries = append(queries, ccv3.Query{Key: ccv3.HostsFilter, Values: []string{hostname}}) + } + + if path != "" { + queries = append(queries, ccv3.Query{Key: ccv3.PathsFilter, Values: []string{path}}) + } + + ccv3Routes, warnings, err := actor.CloudControllerClient.GetRoutes(queries...) + if err != nil { + return nil, Warnings(warnings), err + } + + var routes []resources.Route + for _, route := range ccv3Routes { + routes = append(routes, resources.Route(route)) + } + + return routes, Warnings(warnings), nil +} + +// AccessRuleWithRoute combines an access rule with its associated route information +type AccessRuleWithRoute struct { + resources.AccessRule + Route resources.Route + DomainName string + ScopeType string // "app", "space", "org", or "any" + SourceName string // Resolved source name (app/space/org) or empty string +} + +// GetAccessRulesForSpace gets all access rules for routes in a space with optional filters +func (actor Actor) GetAccessRulesForSpace( + spaceGUID string, + domainName string, + hostname string, + path string, + labelSelector string, +) ([]AccessRuleWithRoute, Warnings, error) { + allWarnings := Warnings{} + + // Build query for access rules filtered by space, with included routes + queries := []ccv3.Query{ + {Key: ccv3.SpaceGUIDFilter, Values: []string{spaceGUID}}, + {Key: ccv3.Include, Values: []string{"route"}}, + } + + // Add label selector if provided + if labelSelector != "" { + queries = append(queries, ccv3.Query{Key: ccv3.LabelSelectorFilter, Values: []string{labelSelector}}) + } + + // Fetch access rules directly by space GUID with included routes (single API call) + accessRules, includedResources, apiWarnings, err := actor.CloudControllerClient.GetAccessRules(queries...) + allWarnings = append(allWarnings, Warnings(apiWarnings)...) + if err != nil { + return nil, allWarnings, err + } + + if len(accessRules) == 0 { + // No access rules found - return empty list, not an error + return []AccessRuleWithRoute{}, allWarnings, nil + } + + // Build route lookup map from included resources + routeByGUID := make(map[string]resources.Route) + for _, route := range includedResources.Routes { + routeByGUID[route.GUID] = route + } + + // Apply optional filters to the included routes + if domainName != "" { + domain, warnings, err := actor.GetDomainByName(domainName) + allWarnings = append(allWarnings, warnings...) + if err != nil { + return nil, allWarnings, err + } + // Filter routes by domain GUID + filteredRoutes := make(map[string]resources.Route) + for guid, route := range routeByGUID { + if route.DomainGUID == domain.GUID { + filteredRoutes[guid] = route + } + } + routeByGUID = filteredRoutes + } + + if hostname != "" { + // Filter routes by hostname + filteredRoutes := make(map[string]resources.Route) + for guid, route := range routeByGUID { + if route.Host == hostname { + filteredRoutes[guid] = route + } + } + routeByGUID = filteredRoutes + } + + if path != "" { + // Filter routes by path + filteredRoutes := make(map[string]resources.Route) + for guid, route := range routeByGUID { + if route.Path == path { + filteredRoutes[guid] = route + } + } + routeByGUID = filteredRoutes + } + + // Build domain name cache + domainCache := make(map[string]string) + for _, route := range routeByGUID { + if _, exists := domainCache[route.DomainGUID]; !exists { + domain, warnings, err := actor.GetDomain(route.DomainGUID) + allWarnings = append(allWarnings, warnings...) + if err != nil { + // If we can't get the domain, use the GUID as fallback + domainCache[route.DomainGUID] = route.DomainGUID + } else { + domainCache[route.DomainGUID] = domain.Name + } + } + } + + // Build results with route information and resolved sources + // Only include access rules whose routes match the filters + var results []AccessRuleWithRoute + for _, rule := range accessRules { + route, exists := routeByGUID[rule.RouteGUID] + if !exists { + // Skip rules for routes that don't match the optional filters + continue + } + + scopeType, sourceName, warnings, err := actor.resolveAccessRuleSource(rule.Selector) + allWarnings = append(allWarnings, warnings...) + if err != nil { + // If we can't resolve the source, sourceName is already empty string + // scopeType is still set correctly + } + + results = append(results, AccessRuleWithRoute{ + AccessRule: resources.AccessRule(rule), + Route: route, + DomainName: domainCache[route.DomainGUID], + ScopeType: scopeType, + SourceName: sourceName, + }) + } + + return results, allWarnings, nil +} + +// resolveAccessRuleSource resolves a selector to scope type and human-readable source name +func (actor Actor) resolveAccessRuleSource(selector string) (scopeType string, sourceName string, warnings Warnings, err error) { + allWarnings := Warnings{} + + // Parse selector format: cf:app:, cf:space:, cf:org:, or cf:any + if selector == "cf:any" { + return "any", "", nil, nil + } + + // Split selector into parts + // Expected format: cf:type:guid + const prefix = "cf:" + if len(selector) < len(prefix) { + return "unknown", "", nil, nil + } + + selectorBody := selector[len(prefix):] + parts := splitSelector(selectorBody) + if len(parts) < 2 { + return "unknown", "", nil, nil + } + + selectorType := parts[0] + guid := parts[1] + + switch selectorType { + case "app": + apps, apiWarnings, err := actor.CloudControllerClient.GetApplications( + ccv3.Query{Key: ccv3.GUIDFilter, Values: []string{guid}}, + ) + allWarnings = append(allWarnings, Warnings(apiWarnings)...) + if err != nil || len(apps) == 0 { + return "app", "", allWarnings, err + } + return "app", apps[0].Name, allWarnings, nil + + case "space": + spaces, _, apiWarnings, err := actor.CloudControllerClient.GetSpaces( + ccv3.Query{Key: ccv3.GUIDFilter, Values: []string{guid}}, + ) + allWarnings = append(allWarnings, Warnings(apiWarnings)...) + if err != nil || len(spaces) == 0 { + return "space", "", allWarnings, err + } + return "space", spaces[0].Name, allWarnings, nil + + case "org": + orgs, apiWarnings, err := actor.CloudControllerClient.GetOrganizations( + ccv3.Query{Key: ccv3.GUIDFilter, Values: []string{guid}}, + ) + allWarnings = append(allWarnings, Warnings(apiWarnings)...) + if err != nil || len(orgs) == 0 { + return "org", "", allWarnings, err + } + return "org", orgs[0].Name, allWarnings, nil + + default: + return "unknown", "", nil, nil + } +} + +// splitSelector splits a selector body by colon, handling the case where +// the selector might be "type:guid" format +func splitSelector(s string) []string { + var parts []string + current := "" + for _, char := range s { + if char == ':' && len(parts) == 0 { + // First colon - split here + parts = append(parts, current) + current = "" + } else { + current += string(char) + } + } + if current != "" { + parts = append(parts, current) + } + return parts +} diff --git a/actor/v7action/access_rule_test.go b/actor/v7action/access_rule_test.go new file mode 100644 index 00000000000..64c4fc52343 --- /dev/null +++ b/actor/v7action/access_rule_test.go @@ -0,0 +1,755 @@ +package v7action_test + +import ( + "errors" + + "code.cloudfoundry.org/cli/v9/actor/actionerror" + . "code.cloudfoundry.org/cli/v9/actor/v7action" + "code.cloudfoundry.org/cli/v9/actor/v7action/v7actionfakes" + "code.cloudfoundry.org/cli/v9/api/cloudcontroller/ccv3" + "code.cloudfoundry.org/cli/v9/resources" + . "github.com/onsi/ginkgo/v2" + . "github.com/onsi/gomega" +) + +var _ = Describe("Access Rule Actions", func() { + var ( + actor *Actor + fakeCloudControllerClient *v7actionfakes.FakeCloudControllerClient + ) + + BeforeEach(func() { + actor, fakeCloudControllerClient, _, _, _, _, _ = NewTestActor() + }) + + Describe("GetAccessRulesForSpace", func() { + var ( + spaceGUID string + domainName string + hostname string + path string + labelSelector string + + results []AccessRuleWithRoute + warnings Warnings + executeErr error + ) + + BeforeEach(func() { + spaceGUID = "space-guid-1" + domainName = "" + hostname = "" + path = "" + labelSelector = "" + }) + + JustBeforeEach(func() { + results, warnings, executeErr = actor.GetAccessRulesForSpace( + spaceGUID, + domainName, + hostname, + path, + labelSelector, + ) + }) + + When("getting access rules succeeds with multiple rules", func() { + BeforeEach(func() { + // Mock GetAccessRules call with included routes + fakeCloudControllerClient.GetAccessRulesReturns( + []resources.AccessRule{ + { + GUID: "rule-guid-1", + Name: "rule-1", + Selector: "cf:app:app-guid-1", + RouteGUID: "route-guid-1", + }, + { + GUID: "rule-guid-2", + Name: "rule-2", + Selector: "cf:any", + RouteGUID: "route-guid-2", + }, + }, + ccv3.IncludedResources{ + Routes: []resources.Route{ + { + GUID: "route-guid-1", + SpaceGUID: "space-guid-1", + DomainGUID: "domain-guid-1", + Host: "app1", + Path: "/path1", + }, + { + GUID: "route-guid-2", + SpaceGUID: "space-guid-1", + DomainGUID: "domain-guid-2", + Host: "app2", + Path: "", + }, + }, + }, + ccv3.Warnings{"get-access-rules-warning"}, + nil, + ) + + // Mock GetDomain calls for domain name resolution + fakeCloudControllerClient.GetDomainStub = func(guid string) (resources.Domain, ccv3.Warnings, error) { + switch guid { + case "domain-guid-1": + return resources.Domain{GUID: "domain-guid-1", Name: "example.com"}, ccv3.Warnings{"get-domain-warning-1"}, nil + case "domain-guid-2": + return resources.Domain{GUID: "domain-guid-2", Name: "test.com"}, ccv3.Warnings{"get-domain-warning-2"}, nil + default: + return resources.Domain{}, nil, errors.New("domain not found") + } + } + + // Mock GetApplications for app name resolution + fakeCloudControllerClient.GetApplicationsReturns( + []resources.Application{ + {GUID: "app-guid-1", Name: "my-app"}, + }, + ccv3.Warnings{"get-app-warning"}, + nil, + ) + }) + + It("returns access rules with route and domain information", func() { + Expect(executeErr).ToNot(HaveOccurred()) + Expect(warnings).To(ConsistOf( + "get-access-rules-warning", + "get-domain-warning-1", + "get-domain-warning-2", + "get-app-warning", + )) + + Expect(results).To(HaveLen(2)) + + // First rule + Expect(results[0].GUID).To(Equal("rule-guid-1")) + Expect(results[0].Name).To(Equal("rule-1")) + Expect(results[0].Selector).To(Equal("cf:app:app-guid-1")) + Expect(results[0].Route.GUID).To(Equal("route-guid-1")) + Expect(results[0].Route.Host).To(Equal("app1")) + Expect(results[0].Route.Path).To(Equal("/path1")) + Expect(results[0].DomainName).To(Equal("example.com")) + Expect(results[0].ScopeType).To(Equal("app")) + Expect(results[0].SourceName).To(Equal("my-app")) + + // Second rule + Expect(results[1].GUID).To(Equal("rule-guid-2")) + Expect(results[1].Name).To(Equal("rule-2")) + Expect(results[1].Selector).To(Equal("cf:any")) + Expect(results[1].Route.GUID).To(Equal("route-guid-2")) + Expect(results[1].Route.Host).To(Equal("app2")) + Expect(results[1].DomainName).To(Equal("test.com")) + Expect(results[1].ScopeType).To(Equal("any")) + Expect(results[1].SourceName).To(Equal("")) + }) + + It("calls GetAccessRules with space GUID and include route filters", func() { + Expect(fakeCloudControllerClient.GetAccessRulesCallCount()).To(Equal(1)) + queries := fakeCloudControllerClient.GetAccessRulesArgsForCall(0) + Expect(queries).To(ContainElement(ccv3.Query{ + Key: ccv3.SpaceGUIDFilter, + Values: []string{"space-guid-1"}, + })) + Expect(queries).To(ContainElement(ccv3.Query{ + Key: ccv3.Include, + Values: []string{"route"}, + })) + }) + + It("does not call GetRoutes separately", func() { + Expect(fakeCloudControllerClient.GetRoutesCallCount()).To(Equal(0)) + }) + }) + + When("domain name filter is provided", func() { + BeforeEach(func() { + domainName = "example.com" + + fakeCloudControllerClient.GetDomainsReturns( + []resources.Domain{ + {GUID: "domain-guid-1", Name: "example.com"}, + }, + ccv3.Warnings{"get-domains-warning"}, + nil, + ) + + fakeCloudControllerClient.GetAccessRulesReturns( + []resources.AccessRule{ + { + GUID: "rule-guid-1", + Name: "rule-1", + Selector: "cf:any", + RouteGUID: "route-guid-1", + }, + }, + ccv3.IncludedResources{ + Routes: []resources.Route{ + { + GUID: "route-guid-1", + SpaceGUID: "space-guid-1", + DomainGUID: "domain-guid-1", + Host: "app1", + }, + }, + }, + ccv3.Warnings{"get-access-rules-warning"}, + nil, + ) + + fakeCloudControllerClient.GetDomainReturns( + resources.Domain{GUID: "domain-guid-1", Name: "example.com"}, + ccv3.Warnings{"get-domain-warning"}, + nil, + ) + }) + + It("filters routes by domain GUID", func() { + Expect(executeErr).ToNot(HaveOccurred()) + // Routes are filtered in-memory from included resources + Expect(fakeCloudControllerClient.GetRoutesCallCount()).To(Equal(0)) + }) + }) + + When("hostname filter is provided", func() { + BeforeEach(func() { + hostname = "myapp" + + fakeCloudControllerClient.GetAccessRulesReturns( + []resources.AccessRule{}, + ccv3.IncludedResources{}, + ccv3.Warnings{"get-access-rules-warning"}, + nil, + ) + }) + + It("adds hostname filter to route query", func() { + Expect(executeErr).ToNot(HaveOccurred()) + // GetRoutes should not be called since routes come from included resources + Expect(fakeCloudControllerClient.GetRoutesCallCount()).To(Equal(0)) + }) + }) + + When("path filter is provided", func() { + BeforeEach(func() { + path = "/api" + + fakeCloudControllerClient.GetAccessRulesReturns( + []resources.AccessRule{}, + ccv3.IncludedResources{}, + ccv3.Warnings{"get-access-rules-warning"}, + nil, + ) + }) + + It("adds path filter to route query", func() { + Expect(executeErr).ToNot(HaveOccurred()) + // GetRoutes should not be called if no access rules are found + Expect(fakeCloudControllerClient.GetRoutesCallCount()).To(Equal(0)) + }) + }) + + When("label selector filter is provided", func() { + BeforeEach(func() { + labelSelector = "env=production" + + fakeCloudControllerClient.GetAccessRulesReturns( + []resources.AccessRule{}, + ccv3.IncludedResources{}, + ccv3.Warnings{"get-access-rules-warning"}, + nil, + ) + }) + + It("adds label selector filter to access rules query", func() { + Expect(executeErr).ToNot(HaveOccurred()) + Expect(fakeCloudControllerClient.GetAccessRulesCallCount()).To(Equal(1)) + queries := fakeCloudControllerClient.GetAccessRulesArgsForCall(0) + + Expect(queries).To(ContainElement(ccv3.Query{ + Key: ccv3.LabelSelectorFilter, + Values: []string{"env=production"}, + })) + }) + }) + + When("no access rules are found in the space", func() { + BeforeEach(func() { + fakeCloudControllerClient.GetAccessRulesReturns( + []resources.AccessRule{}, + ccv3.IncludedResources{}, + ccv3.Warnings{"get-access-rules-warning"}, + nil, + ) + }) + + It("returns an empty list without error", func() { + Expect(executeErr).ToNot(HaveOccurred()) + Expect(results).To(BeEmpty()) + Expect(warnings).To(ConsistOf("get-access-rules-warning")) + }) + + It("does not call GetRoutes", func() { + Expect(fakeCloudControllerClient.GetRoutesCallCount()).To(Equal(0)) + }) + }) + + When("getting access rules fails", func() { + BeforeEach(func() { + fakeCloudControllerClient.GetAccessRulesReturns( + nil, + ccv3.IncludedResources{}, + ccv3.Warnings{"get-access-rules-warning"}, + errors.New("api error"), + ) + }) + + It("returns the error and warnings", func() { + Expect(executeErr).To(MatchError("api error")) + Expect(warnings).To(ConsistOf("get-access-rules-warning")) + Expect(results).To(BeNil()) + }) + }) + + When("getting domain by name fails", func() { + BeforeEach(func() { + domainName = "invalid-domain.com" + + // Mock GetAccessRules to return at least one access rule + fakeCloudControllerClient.GetAccessRulesReturns( + []resources.AccessRule{ + {GUID: "access-rule-guid-1", RouteGUID: "route-guid-1"}, + }, + ccv3.IncludedResources{ + Routes: []resources.Route{ + {GUID: "route-guid-1", DomainGUID: "domain-guid-1"}, + }, + }, + ccv3.Warnings{"get-access-rules-warning"}, + nil, + ) + + fakeCloudControllerClient.GetDomainsReturns( + nil, + ccv3.Warnings{"get-domains-warning"}, + actionerror.DomainNotFoundError{Name: "invalid-domain.com"}, + ) + }) + + It("returns the error and warnings", func() { + Expect(executeErr).To(MatchError(actionerror.DomainNotFoundError{Name: "invalid-domain.com"})) + Expect(warnings).To(ConsistOf("get-access-rules-warning", "get-domains-warning")) + Expect(results).To(BeNil()) + }) + }) + + When("resolving domain name fails", func() { + BeforeEach(func() { + fakeCloudControllerClient.GetAccessRulesReturns( + []resources.AccessRule{ + { + GUID: "rule-guid-1", + Name: "rule-1", + Selector: "cf:any", + RouteGUID: "route-guid-1", + }, + }, + ccv3.IncludedResources{ + Routes: []resources.Route{ + { + GUID: "route-guid-1", + SpaceGUID: "space-guid-1", + DomainGUID: "domain-guid-1", + Host: "app1", + }, + }, + }, + ccv3.Warnings{"get-access-rules-warning"}, + nil, + ) + + // Domain lookup fails + fakeCloudControllerClient.GetDomainReturns( + resources.Domain{}, + ccv3.Warnings{"get-domain-warning"}, + errors.New("domain lookup error"), + ) + }) + + It("uses the domain GUID as fallback and continues", func() { + Expect(executeErr).ToNot(HaveOccurred()) + Expect(results).To(HaveLen(1)) + Expect(results[0].DomainName).To(Equal("domain-guid-1")) + Expect(warnings).To(ContainElement("get-domain-warning")) + }) + }) + + When("resolving target name fails", func() { + BeforeEach(func() { + fakeCloudControllerClient.GetAccessRulesReturns( + []resources.AccessRule{ + { + GUID: "rule-guid-1", + Name: "rule-1", + Selector: "cf:app:app-guid-1", + RouteGUID: "route-guid-1", + }, + }, + ccv3.IncludedResources{ + Routes: []resources.Route{ + { + GUID: "route-guid-1", + SpaceGUID: "space-guid-1", + DomainGUID: "domain-guid-1", + Host: "app1", + }, + }, + }, + ccv3.Warnings{"get-access-rules-warning"}, + nil, + ) + + fakeCloudControllerClient.GetDomainReturns( + resources.Domain{GUID: "domain-guid-1", Name: "example.com"}, + ccv3.Warnings{"get-domain-warning"}, + nil, + ) + + // App lookup fails + fakeCloudControllerClient.GetApplicationsReturns( + nil, + ccv3.Warnings{"get-app-warning"}, + errors.New("app lookup error"), + ) + }) + + It("leaves source name blank and populates scope type", func() { + Expect(executeErr).ToNot(HaveOccurred()) + Expect(results).To(HaveLen(1)) + Expect(results[0].ScopeType).To(Equal("app")) + Expect(results[0].SourceName).To(Equal("")) + Expect(warnings).To(ContainElement("get-app-warning")) + }) + }) + }) + + // Note: resolveAccessRuleTarget and splitSelector are unexported methods + // and are tested indirectly through GetAccessRulesForSpace above. + + Describe("GetAccessRulesByRoute", func() { + var ( + domainName string + hostname string + path string + + rules []resources.AccessRule + warnings Warnings + executeErr error + ) + + BeforeEach(func() { + domainName = "example.com" + hostname = "myapp" + path = "" + }) + + JustBeforeEach(func() { + rules, warnings, executeErr = actor.GetAccessRulesByRoute(domainName, hostname, path) + }) + + When("the route exists with access rules", func() { + BeforeEach(func() { + fakeCloudControllerClient.GetDomainsReturns( + []resources.Domain{ + {GUID: "domain-guid-1", Name: "example.com"}, + }, + ccv3.Warnings{"get-domains-warning"}, + nil, + ) + + fakeCloudControllerClient.GetRoutesReturns( + []resources.Route{ + { + GUID: "route-guid-1", + SpaceGUID: "space-guid-1", + DomainGUID: "domain-guid-1", + Host: "myapp", + }, + }, + ccv3.Warnings{"get-routes-warning"}, + nil, + ) + + fakeCloudControllerClient.GetAccessRulesReturns( + []resources.AccessRule{ + {GUID: "rule-guid-1", Name: "rule-1", Selector: "cf:any"}, + {GUID: "rule-guid-2", Name: "rule-2", Selector: "cf:app:app-guid-1"}, + }, + ccv3.IncludedResources{}, + ccv3.Warnings{"get-access-rules-warning"}, + nil, + ) + }) + + It("returns the access rules", func() { + Expect(executeErr).ToNot(HaveOccurred()) + Expect(rules).To(HaveLen(2)) + Expect(rules[0].Name).To(Equal("rule-1")) + Expect(rules[1].Name).To(Equal("rule-2")) + Expect(warnings).To(ConsistOf( + "get-domains-warning", + "get-routes-warning", + "get-access-rules-warning", + )) + }) + }) + + When("the route does not exist", func() { + BeforeEach(func() { + fakeCloudControllerClient.GetDomainsReturns( + []resources.Domain{ + {GUID: "domain-guid-1", Name: "example.com"}, + }, + ccv3.Warnings{"get-domains-warning"}, + nil, + ) + + fakeCloudControllerClient.GetRoutesReturns( + []resources.Route{}, + ccv3.Warnings{"get-routes-warning"}, + nil, + ) + }) + + It("returns a RouteNotFoundError", func() { + Expect(executeErr).To(MatchError(actionerror.RouteNotFoundError{ + Host: "myapp", + DomainName: "example.com", + Path: "", + })) + Expect(warnings).To(ConsistOf("get-domains-warning", "get-routes-warning")) + }) + }) + }) + + Describe("AddAccessRule", func() { + var ( + ruleName string + domainName string + selector string + hostname string + path string + + warnings Warnings + executeErr error + ) + + BeforeEach(func() { + ruleName = "my-rule" + domainName = "example.com" + selector = "cf:app:app-guid-1" + hostname = "myapp" + path = "" + }) + + JustBeforeEach(func() { + warnings, executeErr = actor.AddAccessRule(ruleName, domainName, selector, hostname, path) + }) + + When("creating the access rule succeeds", func() { + BeforeEach(func() { + fakeCloudControllerClient.GetDomainsReturns( + []resources.Domain{ + {GUID: "domain-guid-1", Name: "example.com"}, + }, + ccv3.Warnings{"get-domains-warning"}, + nil, + ) + + fakeCloudControllerClient.GetRoutesReturns( + []resources.Route{ + { + GUID: "route-guid-1", + SpaceGUID: "space-guid-1", + DomainGUID: "domain-guid-1", + Host: "myapp", + }, + }, + ccv3.Warnings{"get-routes-warning"}, + nil, + ) + + fakeCloudControllerClient.CreateAccessRuleReturns( + resources.AccessRule{GUID: "rule-guid-1", Name: "my-rule"}, + ccv3.Warnings{"create-rule-warning"}, + nil, + ) + }) + + It("creates the access rule and returns warnings", func() { + Expect(executeErr).ToNot(HaveOccurred()) + Expect(warnings).To(ConsistOf( + "get-domains-warning", + "get-routes-warning", + "create-rule-warning", + )) + + Expect(fakeCloudControllerClient.CreateAccessRuleCallCount()).To(Equal(1)) + rule := fakeCloudControllerClient.CreateAccessRuleArgsForCall(0) + Expect(rule.Name).To(Equal("my-rule")) + Expect(rule.Selector).To(Equal("cf:app:app-guid-1")) + Expect(rule.RouteGUID).To(Equal("route-guid-1")) + }) + }) + + When("the route does not exist", func() { + BeforeEach(func() { + fakeCloudControllerClient.GetDomainsReturns( + []resources.Domain{ + {GUID: "domain-guid-1", Name: "example.com"}, + }, + ccv3.Warnings{"get-domains-warning"}, + nil, + ) + + fakeCloudControllerClient.GetRoutesReturns( + []resources.Route{}, + ccv3.Warnings{"get-routes-warning"}, + nil, + ) + }) + + It("returns a RouteNotFoundError", func() { + Expect(executeErr).To(MatchError(actionerror.RouteNotFoundError{ + Host: "myapp", + DomainName: "example.com", + Path: "", + })) + }) + }) + }) + + Describe("DeleteAccessRule", func() { + var ( + ruleName string + domainName string + hostname string + path string + + warnings Warnings + executeErr error + ) + + BeforeEach(func() { + ruleName = "my-rule" + domainName = "example.com" + hostname = "myapp" + path = "" + }) + + JustBeforeEach(func() { + warnings, executeErr = actor.DeleteAccessRule(ruleName, domainName, hostname, path) + }) + + When("the access rule exists", func() { + BeforeEach(func() { + fakeCloudControllerClient.GetDomainsReturns( + []resources.Domain{ + {GUID: "domain-guid-1", Name: "example.com"}, + }, + ccv3.Warnings{"get-domains-warning"}, + nil, + ) + + fakeCloudControllerClient.GetRoutesReturns( + []resources.Route{ + { + GUID: "route-guid-1", + SpaceGUID: "space-guid-1", + DomainGUID: "domain-guid-1", + Host: "myapp", + }, + }, + ccv3.Warnings{"get-routes-warning"}, + nil, + ) + + fakeCloudControllerClient.GetAccessRulesReturns( + []resources.AccessRule{ + {GUID: "rule-guid-1", Name: "my-rule", Selector: "cf:any"}, + }, + ccv3.IncludedResources{}, + ccv3.Warnings{"get-access-rules-warning"}, + nil, + ) + + fakeCloudControllerClient.DeleteAccessRuleReturns( + ccv3.JobURL(""), + ccv3.Warnings{"delete-rule-warning"}, + nil, + ) + }) + + It("deletes the access rule and returns warnings", func() { + Expect(executeErr).ToNot(HaveOccurred()) + Expect(warnings).To(ConsistOf( + "get-domains-warning", + "get-routes-warning", + "get-access-rules-warning", + "delete-rule-warning", + )) + + Expect(fakeCloudControllerClient.DeleteAccessRuleCallCount()).To(Equal(1)) + guid := fakeCloudControllerClient.DeleteAccessRuleArgsForCall(0) + Expect(guid).To(Equal("rule-guid-1")) + }) + }) + + When("the access rule does not exist", func() { + BeforeEach(func() { + fakeCloudControllerClient.GetDomainsReturns( + []resources.Domain{ + {GUID: "domain-guid-1", Name: "example.com"}, + }, + ccv3.Warnings{"get-domains-warning"}, + nil, + ) + + fakeCloudControllerClient.GetRoutesReturns( + []resources.Route{ + { + GUID: "route-guid-1", + SpaceGUID: "space-guid-1", + DomainGUID: "domain-guid-1", + Host: "myapp", + }, + }, + ccv3.Warnings{"get-routes-warning"}, + nil, + ) + + fakeCloudControllerClient.GetAccessRulesReturns( + []resources.AccessRule{ + {GUID: "rule-guid-other", Name: "other-rule", Selector: "cf:any"}, + }, + ccv3.IncludedResources{}, + ccv3.Warnings{"get-access-rules-warning"}, + nil, + ) + }) + + It("returns an AccessRuleNotFoundError", func() { + Expect(executeErr).To(MatchError(actionerror.AccessRuleNotFoundError{Name: "my-rule"})) + Expect(warnings).To(ConsistOf( + "get-domains-warning", + "get-routes-warning", + "get-access-rules-warning", + )) + }) + }) + }) +}) diff --git a/actor/v7action/cloud_controller_client.go b/actor/v7action/cloud_controller_client.go index c0dc6b8c641..223f7344a2f 100644 --- a/actor/v7action/cloud_controller_client.go +++ b/actor/v7action/cloud_controller_client.go @@ -20,6 +20,7 @@ type CloudControllerClient interface { CancelDeployment(deploymentGUID string) (ccv3.Warnings, error) ContinueDeployment(deploymentGUID string) (ccv3.Warnings, error) CopyPackage(sourcePackageGUID string, targetAppGUID string) (resources.Package, ccv3.Warnings, error) + CreateAccessRule(accessRule resources.AccessRule) (resources.AccessRule, ccv3.Warnings, error) CreateApplication(app resources.Application) (resources.Application, ccv3.Warnings, error) CreateApplicationDeployment(dep resources.Deployment) (string, ccv3.Warnings, error) CreateApplicationProcessScale(appGUID string, process resources.Process) (resources.Process, ccv3.Warnings, error) @@ -42,6 +43,7 @@ type CloudControllerClient interface { CreateSpace(space resources.Space) (resources.Space, ccv3.Warnings, error) CreateSpaceQuota(spaceQuota resources.SpaceQuota) (resources.SpaceQuota, ccv3.Warnings, error) CreateUser(userGUID string) (resources.User, ccv3.Warnings, error) + DeleteAccessRule(guid string) (ccv3.JobURL, ccv3.Warnings, error) DeleteApplication(guid string) (ccv3.JobURL, ccv3.Warnings, error) DeleteApplicationProcessInstance(appGUID string, processType string, instanceIndex int) (ccv3.Warnings, error) DeleteBuildpack(buildpackGUID string) (ccv3.JobURL, ccv3.Warnings, error) @@ -63,6 +65,7 @@ type CloudControllerClient interface { DeleteUser(userGUID string) (ccv3.JobURL, ccv3.Warnings, error) DownloadDroplet(dropletGUID string) ([]byte, ccv3.Warnings, error) EntitleIsolationSegmentToOrganizations(isoGUID string, orgGUIDs []string) (resources.RelationshipList, ccv3.Warnings, error) + GetAccessRules(query ...ccv3.Query) ([]resources.AccessRule, ccv3.IncludedResources, ccv3.Warnings, error) GetApplicationByNameAndSpace(appName string, spaceGUID string) (resources.Application, ccv3.Warnings, error) GetApplicationDropletCurrent(appGUID string) (resources.Droplet, ccv3.Warnings, error) GetApplicationEnvironment(appGUID string) (ccv3.Environment, ccv3.Warnings, error) diff --git a/actor/v7action/domain.go b/actor/v7action/domain.go index 21cabe6abc5..cf65ca2bfa3 100644 --- a/actor/v7action/domain.go +++ b/actor/v7action/domain.go @@ -24,7 +24,7 @@ func (actor Actor) CheckRoute(domainName string, hostname string, path string, p return matches, allWarnings, err } -func (actor Actor) CreateSharedDomain(domainName string, internal bool, routerGroupName string) (Warnings, error) { +func (actor Actor) CreateSharedDomain(domainName string, internal bool, routerGroupName string, enforceAccessRules bool, accessRulesScope string) (Warnings, error) { allWarnings := Warnings{} routerGroupGUID := "" @@ -37,17 +37,25 @@ func (actor Actor) CreateSharedDomain(domainName string, internal bool, routerGr routerGroupGUID = routerGroup.GUID } - _, warnings, err := actor.CloudControllerClient.CreateDomain(resources.Domain{ + domain := resources.Domain{ Name: domainName, Internal: types.NullBool{IsSet: true, Value: internal}, RouterGroup: routerGroupGUID, - }) + } + + // Set enforce_access_rules if specified + if enforceAccessRules { + domain.EnforceAccessRules = types.NullBool{IsSet: true, Value: true} + domain.AccessRulesScope = accessRulesScope + } + + _, warnings, err := actor.CloudControllerClient.CreateDomain(domain) allWarnings = append(allWarnings, Warnings(warnings)...) return allWarnings, err } -func (actor Actor) CreatePrivateDomain(domainName string, orgName string) (Warnings, error) { +func (actor Actor) CreatePrivateDomain(domainName string, orgName string, enforceAccessRules bool, accessRulesScope string) (Warnings, error) { allWarnings := Warnings{} organization, warnings, err := actor.GetOrganizationByName(orgName) allWarnings = append(allWarnings, warnings...) @@ -55,10 +63,19 @@ func (actor Actor) CreatePrivateDomain(domainName string, orgName string) (Warni if err != nil { return allWarnings, err } - _, apiWarnings, err := actor.CloudControllerClient.CreateDomain(resources.Domain{ + + domain := resources.Domain{ Name: domainName, OrganizationGUID: organization.GUID, - }) + } + + // Set enforce_access_rules if specified + if enforceAccessRules { + domain.EnforceAccessRules = types.NullBool{IsSet: true, Value: true} + domain.AccessRulesScope = accessRulesScope + } + + _, apiWarnings, err := actor.CloudControllerClient.CreateDomain(domain) actorWarnings := Warnings(apiWarnings) allWarnings = append(allWarnings, actorWarnings...) diff --git a/actor/v7action/domain_test.go b/actor/v7action/domain_test.go index 68050c6cefb..db30783af06 100644 --- a/actor/v7action/domain_test.go +++ b/actor/v7action/domain_test.go @@ -118,7 +118,7 @@ var _ = Describe("Domain Actions", func() { ) JustBeforeEach(func() { - warnings, executeErr = actor.CreateSharedDomain("the-domain-name", true, routerGroup) + warnings, executeErr = actor.CreateSharedDomain("the-domain-name", true, routerGroup, false, "") }) BeforeEach(func() { @@ -191,7 +191,7 @@ var _ = Describe("Domain Actions", func() { }) It("delegates to the cloud controller client", func() { - warnings, executeErr := actor.CreatePrivateDomain("private-domain-name", "org-name") + warnings, executeErr := actor.CreatePrivateDomain("private-domain-name", "org-name", false, "") Expect(executeErr).To(MatchError("create-error")) Expect(warnings).To(ConsistOf("get-orgs-warning", "create-warning-1", "create-warning-2")) diff --git a/actor/v7action/v7actionfakes/fake_cloud_controller_client.go b/actor/v7action/v7actionfakes/fake_cloud_controller_client.go index dbdca54b57b..27c4b830379 100644 --- a/actor/v7action/v7actionfakes/fake_cloud_controller_client.go +++ b/actor/v7action/v7actionfakes/fake_cloud_controller_client.go @@ -106,6 +106,21 @@ type FakeCloudControllerClient struct { result2 ccv3.Warnings result3 error } + CreateAccessRuleStub func(resources.AccessRule) (resources.AccessRule, ccv3.Warnings, error) + createAccessRuleMutex sync.RWMutex + createAccessRuleArgsForCall []struct { + arg1 resources.AccessRule + } + createAccessRuleReturns struct { + result1 resources.AccessRule + result2 ccv3.Warnings + result3 error + } + createAccessRuleReturnsOnCall map[int]struct { + result1 resources.AccessRule + result2 ccv3.Warnings + result3 error + } CreateApplicationStub func(resources.Application) (resources.Application, ccv3.Warnings, error) createApplicationMutex sync.RWMutex createApplicationArgsForCall []struct { @@ -438,6 +453,21 @@ type FakeCloudControllerClient struct { result2 ccv3.Warnings result3 error } + DeleteAccessRuleStub func(string) (ccv3.JobURL, ccv3.Warnings, error) + deleteAccessRuleMutex sync.RWMutex + deleteAccessRuleArgsForCall []struct { + arg1 string + } + deleteAccessRuleReturns struct { + result1 ccv3.JobURL + result2 ccv3.Warnings + result3 error + } + deleteAccessRuleReturnsOnCall map[int]struct { + result1 ccv3.JobURL + result2 ccv3.Warnings + result3 error + } DeleteApplicationStub func(string) (ccv3.JobURL, ccv3.Warnings, error) deleteApplicationMutex sync.RWMutex deleteApplicationArgsForCall []struct { @@ -766,6 +796,23 @@ type FakeCloudControllerClient struct { result2 ccv3.Warnings result3 error } + GetAccessRulesStub func(...ccv3.Query) ([]resources.AccessRule, ccv3.IncludedResources, ccv3.Warnings, error) + getAccessRulesMutex sync.RWMutex + getAccessRulesArgsForCall []struct { + arg1 []ccv3.Query + } + getAccessRulesReturns struct { + result1 []resources.AccessRule + result2 ccv3.IncludedResources + result3 ccv3.Warnings + result4 error + } + getAccessRulesReturnsOnCall map[int]struct { + result1 []resources.AccessRule + result2 ccv3.IncludedResources + result3 ccv3.Warnings + result4 error + } GetAppFeatureStub func(string, string) (resources.ApplicationFeature, ccv3.Warnings, error) getAppFeatureMutex sync.RWMutex getAppFeatureArgsForCall []struct { @@ -3247,6 +3294,73 @@ func (fake *FakeCloudControllerClient) CopyPackageReturnsOnCall(i int, result1 r }{result1, result2, result3} } +func (fake *FakeCloudControllerClient) CreateAccessRule(arg1 resources.AccessRule) (resources.AccessRule, ccv3.Warnings, error) { + fake.createAccessRuleMutex.Lock() + ret, specificReturn := fake.createAccessRuleReturnsOnCall[len(fake.createAccessRuleArgsForCall)] + fake.createAccessRuleArgsForCall = append(fake.createAccessRuleArgsForCall, struct { + arg1 resources.AccessRule + }{arg1}) + stub := fake.CreateAccessRuleStub + fakeReturns := fake.createAccessRuleReturns + fake.recordInvocation("CreateAccessRule", []interface{}{arg1}) + fake.createAccessRuleMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2, ret.result3 + } + return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 +} + +func (fake *FakeCloudControllerClient) CreateAccessRuleCallCount() int { + fake.createAccessRuleMutex.RLock() + defer fake.createAccessRuleMutex.RUnlock() + return len(fake.createAccessRuleArgsForCall) +} + +func (fake *FakeCloudControllerClient) CreateAccessRuleCalls(stub func(resources.AccessRule) (resources.AccessRule, ccv3.Warnings, error)) { + fake.createAccessRuleMutex.Lock() + defer fake.createAccessRuleMutex.Unlock() + fake.CreateAccessRuleStub = stub +} + +func (fake *FakeCloudControllerClient) CreateAccessRuleArgsForCall(i int) resources.AccessRule { + fake.createAccessRuleMutex.RLock() + defer fake.createAccessRuleMutex.RUnlock() + argsForCall := fake.createAccessRuleArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeCloudControllerClient) CreateAccessRuleReturns(result1 resources.AccessRule, result2 ccv3.Warnings, result3 error) { + fake.createAccessRuleMutex.Lock() + defer fake.createAccessRuleMutex.Unlock() + fake.CreateAccessRuleStub = nil + fake.createAccessRuleReturns = struct { + result1 resources.AccessRule + result2 ccv3.Warnings + result3 error + }{result1, result2, result3} +} + +func (fake *FakeCloudControllerClient) CreateAccessRuleReturnsOnCall(i int, result1 resources.AccessRule, result2 ccv3.Warnings, result3 error) { + fake.createAccessRuleMutex.Lock() + defer fake.createAccessRuleMutex.Unlock() + fake.CreateAccessRuleStub = nil + if fake.createAccessRuleReturnsOnCall == nil { + fake.createAccessRuleReturnsOnCall = make(map[int]struct { + result1 resources.AccessRule + result2 ccv3.Warnings + result3 error + }) + } + fake.createAccessRuleReturnsOnCall[i] = struct { + result1 resources.AccessRule + result2 ccv3.Warnings + result3 error + }{result1, result2, result3} +} + func (fake *FakeCloudControllerClient) CreateApplication(arg1 resources.Application) (resources.Application, ccv3.Warnings, error) { fake.createApplicationMutex.Lock() ret, specificReturn := fake.createApplicationReturnsOnCall[len(fake.createApplicationArgsForCall)] @@ -4723,6 +4837,73 @@ func (fake *FakeCloudControllerClient) CreateUserReturnsOnCall(i int, result1 re }{result1, result2, result3} } +func (fake *FakeCloudControllerClient) DeleteAccessRule(arg1 string) (ccv3.JobURL, ccv3.Warnings, error) { + fake.deleteAccessRuleMutex.Lock() + ret, specificReturn := fake.deleteAccessRuleReturnsOnCall[len(fake.deleteAccessRuleArgsForCall)] + fake.deleteAccessRuleArgsForCall = append(fake.deleteAccessRuleArgsForCall, struct { + arg1 string + }{arg1}) + stub := fake.DeleteAccessRuleStub + fakeReturns := fake.deleteAccessRuleReturns + fake.recordInvocation("DeleteAccessRule", []interface{}{arg1}) + fake.deleteAccessRuleMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2, ret.result3 + } + return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 +} + +func (fake *FakeCloudControllerClient) DeleteAccessRuleCallCount() int { + fake.deleteAccessRuleMutex.RLock() + defer fake.deleteAccessRuleMutex.RUnlock() + return len(fake.deleteAccessRuleArgsForCall) +} + +func (fake *FakeCloudControllerClient) DeleteAccessRuleCalls(stub func(string) (ccv3.JobURL, ccv3.Warnings, error)) { + fake.deleteAccessRuleMutex.Lock() + defer fake.deleteAccessRuleMutex.Unlock() + fake.DeleteAccessRuleStub = stub +} + +func (fake *FakeCloudControllerClient) DeleteAccessRuleArgsForCall(i int) string { + fake.deleteAccessRuleMutex.RLock() + defer fake.deleteAccessRuleMutex.RUnlock() + argsForCall := fake.deleteAccessRuleArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeCloudControllerClient) DeleteAccessRuleReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) { + fake.deleteAccessRuleMutex.Lock() + defer fake.deleteAccessRuleMutex.Unlock() + fake.DeleteAccessRuleStub = nil + fake.deleteAccessRuleReturns = struct { + result1 ccv3.JobURL + result2 ccv3.Warnings + result3 error + }{result1, result2, result3} +} + +func (fake *FakeCloudControllerClient) DeleteAccessRuleReturnsOnCall(i int, result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) { + fake.deleteAccessRuleMutex.Lock() + defer fake.deleteAccessRuleMutex.Unlock() + fake.DeleteAccessRuleStub = nil + if fake.deleteAccessRuleReturnsOnCall == nil { + fake.deleteAccessRuleReturnsOnCall = make(map[int]struct { + result1 ccv3.JobURL + result2 ccv3.Warnings + result3 error + }) + } + fake.deleteAccessRuleReturnsOnCall[i] = struct { + result1 ccv3.JobURL + result2 ccv3.Warnings + result3 error + }{result1, result2, result3} +} + func (fake *FakeCloudControllerClient) DeleteApplication(arg1 string) (ccv3.JobURL, ccv3.Warnings, error) { fake.deleteApplicationMutex.Lock() ret, specificReturn := fake.deleteApplicationReturnsOnCall[len(fake.deleteApplicationArgsForCall)] @@ -6196,6 +6377,76 @@ func (fake *FakeCloudControllerClient) EntitleIsolationSegmentToOrganizationsRet }{result1, result2, result3} } +func (fake *FakeCloudControllerClient) GetAccessRules(arg1 ...ccv3.Query) ([]resources.AccessRule, ccv3.IncludedResources, ccv3.Warnings, error) { + fake.getAccessRulesMutex.Lock() + ret, specificReturn := fake.getAccessRulesReturnsOnCall[len(fake.getAccessRulesArgsForCall)] + fake.getAccessRulesArgsForCall = append(fake.getAccessRulesArgsForCall, struct { + arg1 []ccv3.Query + }{arg1}) + stub := fake.GetAccessRulesStub + fakeReturns := fake.getAccessRulesReturns + fake.recordInvocation("GetAccessRules", []interface{}{arg1}) + fake.getAccessRulesMutex.Unlock() + if stub != nil { + return stub(arg1...) + } + if specificReturn { + return ret.result1, ret.result2, ret.result3, ret.result4 + } + return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3, fakeReturns.result4 +} + +func (fake *FakeCloudControllerClient) GetAccessRulesCallCount() int { + fake.getAccessRulesMutex.RLock() + defer fake.getAccessRulesMutex.RUnlock() + return len(fake.getAccessRulesArgsForCall) +} + +func (fake *FakeCloudControllerClient) GetAccessRulesCalls(stub func(...ccv3.Query) ([]resources.AccessRule, ccv3.IncludedResources, ccv3.Warnings, error)) { + fake.getAccessRulesMutex.Lock() + defer fake.getAccessRulesMutex.Unlock() + fake.GetAccessRulesStub = stub +} + +func (fake *FakeCloudControllerClient) GetAccessRulesArgsForCall(i int) []ccv3.Query { + fake.getAccessRulesMutex.RLock() + defer fake.getAccessRulesMutex.RUnlock() + argsForCall := fake.getAccessRulesArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeCloudControllerClient) GetAccessRulesReturns(result1 []resources.AccessRule, result2 ccv3.IncludedResources, result3 ccv3.Warnings, result4 error) { + fake.getAccessRulesMutex.Lock() + defer fake.getAccessRulesMutex.Unlock() + fake.GetAccessRulesStub = nil + fake.getAccessRulesReturns = struct { + result1 []resources.AccessRule + result2 ccv3.IncludedResources + result3 ccv3.Warnings + result4 error + }{result1, result2, result3, result4} +} + +func (fake *FakeCloudControllerClient) GetAccessRulesReturnsOnCall(i int, result1 []resources.AccessRule, result2 ccv3.IncludedResources, result3 ccv3.Warnings, result4 error) { + fake.getAccessRulesMutex.Lock() + defer fake.getAccessRulesMutex.Unlock() + fake.GetAccessRulesStub = nil + if fake.getAccessRulesReturnsOnCall == nil { + fake.getAccessRulesReturnsOnCall = make(map[int]struct { + result1 []resources.AccessRule + result2 ccv3.IncludedResources + result3 ccv3.Warnings + result4 error + }) + } + fake.getAccessRulesReturnsOnCall[i] = struct { + result1 []resources.AccessRule + result2 ccv3.IncludedResources + result3 ccv3.Warnings + result4 error + }{result1, result2, result3, result4} +} + func (fake *FakeCloudControllerClient) GetAppFeature(arg1 string, arg2 string) (resources.ApplicationFeature, ccv3.Warnings, error) { fake.getAppFeatureMutex.Lock() ret, specificReturn := fake.getAppFeatureReturnsOnCall[len(fake.getAppFeatureArgsForCall)] diff --git a/api/cloudcontroller/ccv3/access_rule.go b/api/cloudcontroller/ccv3/access_rule.go new file mode 100644 index 00000000000..2c391af8d18 --- /dev/null +++ b/api/cloudcontroller/ccv3/access_rule.go @@ -0,0 +1,59 @@ +package ccv3 + +import ( + "code.cloudfoundry.org/cli/v9/api/cloudcontroller/ccv3/internal" + "code.cloudfoundry.org/cli/v9/resources" +) + +// CreateAccessRule creates an access rule for a route +func (client *Client) CreateAccessRule(accessRule resources.AccessRule) (resources.AccessRule, Warnings, error) { + var responseBody resources.AccessRule + + _, warnings, err := client.MakeRequest(RequestParams{ + RequestName: internal.PostAccessRuleRequest, + RequestBody: accessRule, + ResponseBody: &responseBody, + }) + + return responseBody, warnings, err +} + +// GetAccessRules lists access rules +func (client *Client) GetAccessRules(query ...Query) ([]resources.AccessRule, IncludedResources, Warnings, error) { + var accessRules []resources.AccessRule + + includedResources, warnings, err := client.MakeListRequest(RequestParams{ + RequestName: internal.GetAccessRulesRequest, + Query: query, + ResponseBody: resources.AccessRule{}, + AppendToList: func(item interface{}) error { + accessRules = append(accessRules, item.(resources.AccessRule)) + return nil + }, + }) + + return accessRules, includedResources, warnings, err +} + +// GetAccessRule gets a single access rule by GUID +func (client *Client) GetAccessRule(guid string) (resources.AccessRule, Warnings, error) { + var responseBody resources.AccessRule + + _, warnings, err := client.MakeRequest(RequestParams{ + RequestName: internal.GetAccessRuleRequest, + URIParams: internal.Params{"access_rule_guid": guid}, + ResponseBody: &responseBody, + }) + + return responseBody, warnings, err +} + +// DeleteAccessRule deletes an access rule +func (client *Client) DeleteAccessRule(guid string) (JobURL, Warnings, error) { + jobURLString, warnings, err := client.MakeRequest(RequestParams{ + RequestName: internal.DeleteAccessRuleRequest, + URIParams: internal.Params{"access_rule_guid": guid}, + }) + + return JobURL(jobURLString), warnings, err +} diff --git a/api/cloudcontroller/ccv3/included_resources.go b/api/cloudcontroller/ccv3/included_resources.go index 6827248eae1..89af94c2540 100644 --- a/api/cloudcontroller/ccv3/included_resources.go +++ b/api/cloudcontroller/ccv3/included_resources.go @@ -11,6 +11,7 @@ type IncludedResources struct { ServiceBrokers []resources.ServiceBroker `json:"service_brokers,omitempty"` ServicePlans []resources.ServicePlan `json:"service_plans,omitempty"` Apps []resources.Application `json:"apps,omitempty"` + Routes []resources.Route `json:"routes,omitempty"` } func (i *IncludedResources) Merge(resources IncludedResources) { @@ -22,4 +23,5 @@ func (i *IncludedResources) Merge(resources IncludedResources) { i.ServiceInstances = append(i.ServiceInstances, resources.ServiceInstances...) i.ServiceOfferings = append(i.ServiceOfferings, resources.ServiceOfferings...) i.ServicePlans = append(i.ServicePlans, resources.ServicePlans...) + i.Routes = append(i.Routes, resources.Routes...) } diff --git a/api/cloudcontroller/ccv3/internal/api_routes.go b/api/cloudcontroller/ccv3/internal/api_routes.go index d1f7ffd9fe6..40605b74a50 100644 --- a/api/cloudcontroller/ccv3/internal/api_routes.go +++ b/api/cloudcontroller/ccv3/internal/api_routes.go @@ -9,6 +9,7 @@ import "net/http" // If the request returns a single entity by GUID, use the singular (for example // /v3/organizations/:organization_guid is GetOrganization). const ( + DeleteAccessRuleRequest = "DeleteAccessRuleRequest" DeleteApplicationProcessInstanceRequest = "DeleteApplicationProcessInstance" DeleteApplicationRequest = "DeleteApplication" DeleteBuildpackRequest = "DeleteBuildpack" @@ -35,6 +36,8 @@ const ( DeleteSpaceRequest = "DeleteSpace" DeleteSpaceQuotaFromSpaceRequest = "DeleteSpaceQuotaFromSpace" DeleteUserRequest = "DeleteUser" + GetAccessRuleRequest = "GetAccessRuleRequest" + GetAccessRulesRequest = "GetAccessRulesRequest" GetApplicationDropletCurrentRequest = "GetApplicationDropletCurrent" GetApplicationEnvRequest = "GetApplicationEnv" GetApplicationFeaturesRequest = "GetApplicationFeatures" @@ -134,6 +137,7 @@ const ( PatchSpaceQuotaRequest = "PatchSpaceQuota" PatchStackRequest = "PatchStack" PatchMoveRouteRequest = "PatchMoveRouteRequest" + PostAccessRuleRequest = "PostAccessRuleRequest" PostApplicationActionApplyManifest = "PostApplicationActionApplyM" PostApplicationActionRestartRequest = "PostApplicationActionRestart" PostApplicationActionStartRequest = "PostApplicationActionStart" @@ -186,6 +190,10 @@ const ( // APIRoutes is a list of routes used by the router to construct request URLs. var APIRoutes = map[string]Route{ + GetAccessRulesRequest: {Path: "/v3/access_rules", Method: http.MethodGet}, + PostAccessRuleRequest: {Path: "/v3/access_rules", Method: http.MethodPost}, + GetAccessRuleRequest: {Path: "/v3/access_rules/:access_rule_guid", Method: http.MethodGet}, + DeleteAccessRuleRequest: {Path: "/v3/access_rules/:access_rule_guid", Method: http.MethodDelete}, GetApplicationsRequest: {Path: "/v3/apps", Method: http.MethodGet}, PostApplicationRequest: {Path: "/v3/apps", Method: http.MethodPost}, DeleteApplicationRequest: {Path: "/v3/apps/:app_guid", Method: http.MethodDelete}, diff --git a/api/cloudcontroller/ccv3/query.go b/api/cloudcontroller/ccv3/query.go index 99b04abad9b..27bcf995712 100644 --- a/api/cloudcontroller/ccv3/query.go +++ b/api/cloudcontroller/ccv3/query.go @@ -29,6 +29,8 @@ const ( SequenceIDFilter QueryKey = "sequence_ids" // RouteGUIDFilter is a query parameter for listing objects by Route GUID. RouteGUIDFilter QueryKey = "route_guids" + // SelectorsFilter is a query parameter for listing access rules by selector. + SelectorsFilter QueryKey = "selectors" // ServiceInstanceGUIDFilter is a query parameter for listing objects by Service Instance GUID. ServiceInstanceGUIDFilter QueryKey = "service_instance_guids" // SpaceGUIDFilter is a query parameter for listing objects by Space GUID. diff --git a/command/common/command_list_v7.go b/command/common/command_list_v7.go index fcc833a94d3..3177549afa1 100644 --- a/command/common/command_list_v7.go +++ b/command/common/command_list_v7.go @@ -15,6 +15,8 @@ type commandList struct { V3Push v7.PushCommand `command:"v3-push" description:"Push a new app or sync changes to an existing app" hidden:"true"` + AccessRules v7.AccessRulesCommand `command:"access-rules" description:"List all access rules in the target space"` + AddAccessRule v7.AddAccessRuleCommand `command:"add-access-rule" description:"Add an access rule to allow specific apps, spaces, or orgs to access a route"` API v7.APICommand `command:"api" description:"Set or view target api url"` AddNetworkPolicy v7.AddNetworkPolicyCommand `command:"add-network-policy" description:"Create policy to allow direct network traffic from one app to another"` AddPluginRepo plugin.AddPluginRepoCommand `command:"add-plugin-repo" description:"Add a new plugin repository"` @@ -113,6 +115,7 @@ type commandList struct { PurgeServiceOffering v7.PurgeServiceOfferingCommand `command:"purge-service-offering" description:"Recursively remove a service offering and child objects from Cloud Foundry database without making requests to a service broker"` Push v7.PushCommand `command:"push" alias:"p" description:"Push a new app or sync changes to an existing app"` RemoveNetworkPolicy v7.RemoveNetworkPolicyCommand `command:"remove-network-policy" description:"Remove network traffic policy of an app"` + RemoveAccessRule v7.RemoveAccessRuleCommand `command:"remove-access-rule" description:"Remove an access rule from a route"` RemovePluginRepo plugin.RemovePluginRepoCommand `command:"remove-plugin-repo" description:"Remove a plugin repository"` Rename v7.RenameCommand `command:"rename" description:"Rename an app"` RenameOrg v7.RenameOrgCommand `command:"rename-org" description:"Rename an org"` diff --git a/command/common/internal/help_all_display.go b/command/common/internal/help_all_display.go index 8166edc0ba2..923264d910b 100644 --- a/command/common/internal/help_all_display.go +++ b/command/common/internal/help_all_display.go @@ -72,6 +72,7 @@ var HelpCategoryList = []HelpCategory{ {"update-destination"}, {"share-route", "unshare-route"}, {"move-route"}, + {"access-rules", "add-access-rule", "remove-access-rule"}, }, }, { diff --git a/command/flag/arguments.go b/command/flag/arguments.go index 9e3d60263f8..84195b1d4e6 100644 --- a/command/flag/arguments.go +++ b/command/flag/arguments.go @@ -413,3 +413,13 @@ type TaskArgs struct { AppName string `positional-arg-name:"APP_NAME" required:"true" description:"The application name"` TaskID int `positional-arg-name:"TASK_ID" required:"true" description:"The Task ID for the application"` } + +type AddAccessRuleArgs struct { + RuleName string `positional-arg-name:"RULE_NAME" required:"true" description:"The access rule name"` + Domain string `positional-arg-name:"DOMAIN" required:"true" description:"The domain name"` +} + +type RemoveAccessRuleArgs struct { + RuleName string `positional-arg-name:"RULE_NAME" required:"true" description:"The access rule name"` + Domain string `positional-arg-name:"DOMAIN" required:"true" description:"The domain name"` +} diff --git a/command/v7/access_rules_command.go b/command/v7/access_rules_command.go new file mode 100644 index 00000000000..0b29c17e4d9 --- /dev/null +++ b/command/v7/access_rules_command.go @@ -0,0 +1,103 @@ +package v7 + +import ( + "fmt" + + "code.cloudfoundry.org/cli/v9/resources" + "code.cloudfoundry.org/cli/v9/util/ui" +) + +type AccessRulesCommand struct { + BaseCommand + + Domain string `long:"domain" description:"Filter by domain name"` + Hostname string `long:"hostname" description:"Filter by hostname"` + Path string `long:"path" description:"Filter by path"` + Labels string `long:"labels" description:"Selector to filter access rules by labels"` + + usage interface{} `usage:"CF_NAME access-rules [--domain DOMAIN] [--hostname HOSTNAME] [--path PATH] [--labels SELECTOR]\n\nEXAMPLES:\n cf access-rules\n cf access-rules --domain apps.identity\n cf access-rules --domain apps.identity --hostname backend\n cf access-rules --labels env=prod"` + relatedCommands interface{} `related_commands:"add-access-rule, remove-access-rule, routes"` +} + +func (cmd AccessRulesCommand) Execute(args []string) error { + // Check target (org + space required) + err := cmd.SharedActor.CheckTarget(true, true) + if err != nil { + return err + } + + // Get current user + user, err := cmd.Actor.GetCurrentUser() + if err != nil { + return err + } + + // Display contextual header + cmd.UI.DisplayTextWithFlavor( + "Getting access rules in org {{.OrgName}} / space {{.SpaceName}} as {{.Username}}...", + map[string]interface{}{ + "OrgName": cmd.Config.TargetedOrganization().Name, + "SpaceName": cmd.Config.TargetedSpace().Name, + "Username": user.Name, + }) + cmd.UI.DisplayNewline() + + // Fetch access rules for space with filters + rulesWithRoutes, warnings, err := cmd.Actor.GetAccessRulesForSpace( + cmd.Config.TargetedSpace().GUID, + cmd.Domain, + cmd.Hostname, + cmd.Path, + cmd.Labels, + ) + cmd.UI.DisplayWarnings(warnings) + if err != nil { + return err + } + + // Handle empty results + if len(rulesWithRoutes) == 0 { + cmd.UI.DisplayText("No access rules found.") + return nil + } + + // Build table data + table := [][]string{ + { + cmd.UI.TranslateText("name"), + cmd.UI.TranslateText("route"), + cmd.UI.TranslateText("selector"), + cmd.UI.TranslateText("scope"), + cmd.UI.TranslateText("source"), + }, + } + + for _, ruleWithRoute := range rulesWithRoutes { + table = append(table, []string{ + ruleWithRoute.Name, + formatRoute(ruleWithRoute.Route, ruleWithRoute.DomainName), + ruleWithRoute.Selector, + ruleWithRoute.ScopeType, + ruleWithRoute.SourceName, + }) + } + + // Display table + cmd.UI.DisplayTableWithHeader("", table, ui.DefaultTableSpacePadding) + + return nil +} + +// formatRoute formats a route as hostname.domain/path +func formatRoute(route resources.Route, domainName string) string { + var formatted string + if route.Host != "" { + formatted = fmt.Sprintf("%s.%s", route.Host, domainName) + } else { + formatted = domainName + } + if route.Path != "" { + formatted += route.Path + } + return formatted +} diff --git a/command/v7/access_rules_command_test.go b/command/v7/access_rules_command_test.go new file mode 100644 index 00000000000..bf34d3ea2b9 --- /dev/null +++ b/command/v7/access_rules_command_test.go @@ -0,0 +1,356 @@ +package v7_test + +import ( + "errors" + + "code.cloudfoundry.org/cli/v9/actor/actionerror" + "code.cloudfoundry.org/cli/v9/actor/v7action" + "code.cloudfoundry.org/cli/v9/api/cloudcontroller/ccerror" + "code.cloudfoundry.org/cli/v9/command/commandfakes" + v7 "code.cloudfoundry.org/cli/v9/command/v7" + "code.cloudfoundry.org/cli/v9/command/v7/v7fakes" + "code.cloudfoundry.org/cli/v9/resources" + "code.cloudfoundry.org/cli/v9/util/configv3" + "code.cloudfoundry.org/cli/v9/util/ui" + . "github.com/onsi/ginkgo/v2" + . "github.com/onsi/gomega" + . "github.com/onsi/gomega/gbytes" +) + +var _ = Describe("access-rules Command", func() { + var ( + cmd v7.AccessRulesCommand + testUI *ui.UI + fakeConfig *commandfakes.FakeConfig + fakeSharedActor *commandfakes.FakeSharedActor + fakeActor *v7fakes.FakeActor + binaryName string + executeErr error + ) + + BeforeEach(func() { + testUI = ui.NewTestUI(nil, NewBuffer(), NewBuffer()) + fakeConfig = new(commandfakes.FakeConfig) + fakeSharedActor = new(commandfakes.FakeSharedActor) + fakeActor = new(v7fakes.FakeActor) + + binaryName = "faceman" + fakeConfig.BinaryNameReturns(binaryName) + + cmd = v7.AccessRulesCommand{ + BaseCommand: v7.BaseCommand{ + UI: testUI, + Config: fakeConfig, + Actor: fakeActor, + SharedActor: fakeSharedActor, + }, + } + + fakeConfig.TargetedOrganizationReturns(configv3.Organization{ + Name: "some-org", + GUID: "some-org-guid", + }) + fakeConfig.TargetedSpaceReturns(configv3.Space{ + Name: "some-space", + GUID: "some-space-guid", + }) + + fakeActor.GetCurrentUserReturns(configv3.User{Name: "steve"}, nil) + }) + + JustBeforeEach(func() { + executeErr = cmd.Execute(nil) + }) + + When("checking target fails", func() { + BeforeEach(func() { + fakeSharedActor.CheckTargetReturns(actionerror.NoOrganizationTargetedError{BinaryName: binaryName}) + }) + + It("returns an error", func() { + Expect(executeErr).To(MatchError(actionerror.NoOrganizationTargetedError{BinaryName: binaryName})) + + Expect(fakeSharedActor.CheckTargetCallCount()).To(Equal(1)) + checkTargetedOrg, checkTargetedSpace := fakeSharedActor.CheckTargetArgsForCall(0) + Expect(checkTargetedOrg).To(BeTrue()) + Expect(checkTargetedSpace).To(BeTrue()) + }) + }) + + When("the user is not logged in", func() { + var expectedErr error + + BeforeEach(func() { + expectedErr = errors.New("some current user error") + fakeActor.GetCurrentUserReturns(configv3.User{}, expectedErr) + }) + + It("returns an error", func() { + Expect(executeErr).To(Equal(expectedErr)) + }) + }) + + When("getting access rules returns an error", func() { + var expectedErr error + + BeforeEach(func() { + expectedErr = ccerror.RequestError{} + fakeActor.GetAccessRulesForSpaceReturns([]v7action.AccessRuleWithRoute{}, v7action.Warnings{"warning-1", "warning-2"}, expectedErr) + }) + + It("returns the error and prints warnings", func() { + Expect(executeErr).To(Equal(ccerror.RequestError{})) + + Expect(testUI.Out).To(Say(`Getting access rules in org some-org / space some-space as steve\.\.\.`)) + + Expect(testUI.Err).To(Say("warning-1")) + Expect(testUI.Err).To(Say("warning-2")) + }) + }) + + When("getting access rules succeeds", func() { + BeforeEach(func() { + fakeActor.GetAccessRulesForSpaceReturns([]v7action.AccessRuleWithRoute{ + { + AccessRule: resources.AccessRule{ + GUID: "rule-guid-1", + Name: "rule-1", + Selector: "cf:app:app-guid-1", + }, + Route: resources.Route{ + GUID: "route-guid-1", + Host: "myapp", + Path: "/api", + }, + DomainName: "example.com", + ScopeType: "app", + SourceName: "my-app", + }, + { + AccessRule: resources.AccessRule{ + GUID: "rule-guid-2", + Name: "rule-2", + Selector: "cf:any", + }, + Route: resources.Route{ + GUID: "route-guid-2", + Host: "webapp", + Path: "", + }, + DomainName: "test.com", + ScopeType: "any", + SourceName: "(any app)", + }, + }, v7action.Warnings{"warning-1"}, nil) + }) + + It("displays the access rules in a table", func() { + Expect(executeErr).ToNot(HaveOccurred()) + + Expect(testUI.Out).To(Say(`Getting access rules in org some-org / space some-space as steve\.\.\.`)) + Expect(testUI.Out).To(Say(`name\s+route\s+selector\s+scope\s+source`)) + Expect(testUI.Out).To(Say(`rule-1\s+myapp\.example\.com/api\s+cf:app:app-guid-1\s+my-app`)) + Expect(testUI.Out).To(Say(`rule-2\s+webapp\.test\.com\s+cf:any\s+\(any app\)`)) + + Expect(testUI.Err).To(Say("warning-1")) + + Expect(fakeActor.GetAccessRulesForSpaceCallCount()).To(Equal(1)) + spaceGUID, domainName, hostname, path, labelSelector := fakeActor.GetAccessRulesForSpaceArgsForCall(0) + Expect(spaceGUID).To(Equal("some-space-guid")) + Expect(domainName).To(Equal("")) + Expect(hostname).To(Equal("")) + Expect(path).To(Equal("")) + Expect(labelSelector).To(Equal("")) + }) + }) + + When("no access rules exist", func() { + BeforeEach(func() { + fakeActor.GetAccessRulesForSpaceReturns([]v7action.AccessRuleWithRoute{}, v7action.Warnings{}, nil) + }) + + It("displays a message indicating no access rules found", func() { + Expect(executeErr).ToNot(HaveOccurred()) + + Expect(testUI.Out).To(Say(`Getting access rules in org some-org / space some-space as steve\.\.\.`)) + Expect(testUI.Out).To(Say(`No access rules found\.`)) + }) + }) + + When("filtering by domain", func() { + BeforeEach(func() { + cmd.Domain = "example.com" + + fakeActor.GetAccessRulesForSpaceReturns([]v7action.AccessRuleWithRoute{ + { + AccessRule: resources.AccessRule{ + GUID: "rule-guid-1", + Name: "rule-1", + Selector: "cf:any", + }, + Route: resources.Route{ + GUID: "route-guid-1", + Host: "myapp", + }, + DomainName: "example.com", + ScopeType: "any", + SourceName: "(any app)", + }, + }, v7action.Warnings{}, nil) + }) + + It("passes the domain filter to the actor", func() { + Expect(executeErr).ToNot(HaveOccurred()) + + Expect(fakeActor.GetAccessRulesForSpaceCallCount()).To(Equal(1)) + spaceGUID, domainName, hostname, path, labelSelector := fakeActor.GetAccessRulesForSpaceArgsForCall(0) + Expect(spaceGUID).To(Equal("some-space-guid")) + Expect(domainName).To(Equal("example.com")) + Expect(hostname).To(Equal("")) + Expect(path).To(Equal("")) + Expect(labelSelector).To(Equal("")) + }) + }) + + When("filtering by hostname", func() { + BeforeEach(func() { + cmd.Hostname = "myapp" + + fakeActor.GetAccessRulesForSpaceReturns([]v7action.AccessRuleWithRoute{}, v7action.Warnings{}, nil) + }) + + It("passes the hostname filter to the actor", func() { + Expect(executeErr).ToNot(HaveOccurred()) + + Expect(fakeActor.GetAccessRulesForSpaceCallCount()).To(Equal(1)) + _, _, hostname, _, _ := fakeActor.GetAccessRulesForSpaceArgsForCall(0) + Expect(hostname).To(Equal("myapp")) + }) + }) + + When("filtering by path", func() { + BeforeEach(func() { + cmd.Path = "/api" + + fakeActor.GetAccessRulesForSpaceReturns([]v7action.AccessRuleWithRoute{}, v7action.Warnings{}, nil) + }) + + It("passes the path filter to the actor", func() { + Expect(executeErr).ToNot(HaveOccurred()) + + Expect(fakeActor.GetAccessRulesForSpaceCallCount()).To(Equal(1)) + _, _, _, path, _ := fakeActor.GetAccessRulesForSpaceArgsForCall(0) + Expect(path).To(Equal("/api")) + }) + }) + + When("filtering by labels", func() { + BeforeEach(func() { + cmd.Labels = "env=production,tier=frontend" + + fakeActor.GetAccessRulesForSpaceReturns([]v7action.AccessRuleWithRoute{}, v7action.Warnings{}, nil) + }) + + It("passes the label selector to the actor", func() { + Expect(executeErr).ToNot(HaveOccurred()) + + Expect(fakeActor.GetAccessRulesForSpaceCallCount()).To(Equal(1)) + _, _, _, _, labelSelector := fakeActor.GetAccessRulesForSpaceArgsForCall(0) + Expect(labelSelector).To(Equal("env=production,tier=frontend")) + }) + }) + + When("using multiple filters", func() { + BeforeEach(func() { + cmd.Domain = "example.com" + cmd.Hostname = "myapp" + cmd.Path = "/api" + cmd.Labels = "env=production" + + fakeActor.GetAccessRulesForSpaceReturns([]v7action.AccessRuleWithRoute{ + { + AccessRule: resources.AccessRule{ + GUID: "rule-guid-1", + Name: "filtered-rule", + Selector: "cf:app:app-guid-1", + }, + Route: resources.Route{ + GUID: "route-guid-1", + Host: "myapp", + Path: "/api", + }, + DomainName: "example.com", + ScopeType: "app", + SourceName: "my-app", + }, + }, v7action.Warnings{}, nil) + }) + + It("passes all filters to the actor", func() { + Expect(executeErr).ToNot(HaveOccurred()) + + Expect(fakeActor.GetAccessRulesForSpaceCallCount()).To(Equal(1)) + spaceGUID, domainName, hostname, path, labelSelector := fakeActor.GetAccessRulesForSpaceArgsForCall(0) + Expect(spaceGUID).To(Equal("some-space-guid")) + Expect(domainName).To(Equal("example.com")) + Expect(hostname).To(Equal("myapp")) + Expect(path).To(Equal("/api")) + Expect(labelSelector).To(Equal("env=production")) + }) + + It("displays the filtered results", func() { + Expect(executeErr).ToNot(HaveOccurred()) + + Expect(testUI.Out).To(Say(`Getting access rules in org some-org / space some-space as steve\.\.\.`)) + Expect(testUI.Out).To(Say(`name\s+route\s+selector\s+scope\s+source`)) + Expect(testUI.Out).To(Say(`filtered-rule\s+myapp\.example\.com/api\s+cf:app:app-guid-1\s+my-app`)) + }) + }) + + When("route formatting handles edge cases", func() { + BeforeEach(func() { + fakeActor.GetAccessRulesForSpaceReturns([]v7action.AccessRuleWithRoute{ + { + AccessRule: resources.AccessRule{ + GUID: "rule-guid-1", + Name: "no-host-rule", + Selector: "cf:any", + }, + Route: resources.Route{ + GUID: "route-guid-1", + Host: "", + Path: "/api", + }, + DomainName: "example.com", + ScopeType: "any", + SourceName: "(any app)", + }, + { + AccessRule: resources.AccessRule{ + GUID: "rule-guid-2", + Name: "no-path-rule", + Selector: "cf:any", + }, + Route: resources.Route{ + GUID: "route-guid-2", + Host: "myapp", + Path: "", + }, + DomainName: "test.com", + ScopeType: "any", + SourceName: "(any app)", + }, + }, v7action.Warnings{}, nil) + }) + + It("formats routes correctly", func() { + Expect(executeErr).ToNot(HaveOccurred()) + + // No host, with path: "example.com/api" + Expect(testUI.Out).To(Say(`no-host-rule\s+example\.com/api`)) + + // With host, no path: "myapp.test.com" + Expect(testUI.Out).To(Say(`no-path-rule\s+myapp\.test\.com`)) + }) + }) +}) diff --git a/command/v7/actor.go b/command/v7/actor.go index daeac22dd0a..a5fecefc786 100644 --- a/command/v7/actor.go +++ b/command/v7/actor.go @@ -23,6 +23,7 @@ import ( type Actor interface { ApplyOrganizationQuotaByName(quotaName string, orgGUID string) (v7action.Warnings, error) ApplySpaceQuotaByName(quotaName string, spaceGUID string, orgGUID string) (v7action.Warnings, error) + AddAccessRule(ruleName, domainName, selector, hostname, path string) (v7action.Warnings, error) AssignIsolationSegmentToSpaceByNameAndSpace(isolationSegmentName string, spaceGUID string) (v7action.Warnings, error) Authenticate(credentials map[string]string, origin string, grantType uaa.GrantType) error BindSecurityGroupToSpaces(securityGroupGUID string, spaces []resources.Space, lifecycle constant.SecurityGroupLifecycle) (v7action.Warnings, error) @@ -44,20 +45,21 @@ type Actor interface { CreateOrgRole(roleType constant.RoleType, orgGUID string, userNameOrGUID string, userOrigin string, isClient bool) (v7action.Warnings, error) CreateOrganization(orgName string) (resources.Organization, v7action.Warnings, error) CreateOrganizationQuota(name string, limits v7action.QuotaLimits) (v7action.Warnings, error) - CreatePrivateDomain(domainName string, orgName string) (v7action.Warnings, error) + CreatePrivateDomain(domainName string, orgName string, enforceAccessRules bool, accessRulesScope string) (v7action.Warnings, error) CreateRoute(spaceGUID, domainName, hostname, path string, port int, options map[string]*string) (resources.Route, v7action.Warnings, error) CreateRouteBinding(params v7action.CreateRouteBindingParams) (chan v7action.PollJobEvent, v7action.Warnings, error) CreateSecurityGroup(name, filePath string) (v7action.Warnings, error) CreateServiceAppBinding(params v7action.CreateServiceAppBindingParams) (chan v7action.PollJobEvent, v7action.Warnings, error) CreateServiceBroker(model resources.ServiceBroker) (v7action.Warnings, error) CreateServiceKey(params v7action.CreateServiceKeyParams) (chan v7action.PollJobEvent, v7action.Warnings, error) - CreateSharedDomain(domainName string, internal bool, routerGroupName string) (v7action.Warnings, error) + CreateSharedDomain(domainName string, internal bool, routerGroupName string, enforceAccessRules bool, accessRulesScope string) (v7action.Warnings, error) CreateSpace(spaceName, orgGUID string) (resources.Space, v7action.Warnings, error) CreateSpaceQuota(spaceQuotaName string, orgGuid string, limits v7action.QuotaLimits) (v7action.Warnings, error) CreateSpaceRole(roleType constant.RoleType, orgGUID string, spaceGUID string, userNameOrGUID string, userOrigin string, isClient bool) (v7action.Warnings, error) CreateUser(username string, password string, origin string) (resources.User, v7action.Warnings, error) CreateUserProvidedServiceInstance(instance resources.ServiceInstance) (v7action.Warnings, error) DeleteApplicationByNameAndSpace(name, spaceGUID string, deleteRoutes bool) (v7action.Warnings, error) + DeleteAccessRule(ruleName, domainName, hostname, path string) (v7action.Warnings, error) DeleteBuildpackByNameAndStackAndLifecycle(buildpackName string, buildpackStack string, buildpackLifecycle string) (v7action.Warnings, error) DeleteDomain(domain resources.Domain) (v7action.Warnings, error) DeleteInstanceByApplicationNameSpaceProcessTypeAndIndex(appName string, spaceGUID string, processType string, instanceIndex int) (v7action.Warnings, error) @@ -87,6 +89,8 @@ type Actor interface { EnableServiceAccess(offeringName, brokerName, orgName, planName string) (v7action.SkippedPlans, v7action.Warnings, error) EntitleIsolationSegmentToOrganizationByName(isolationSegmentName string, orgName string) (v7action.Warnings, error) GetAppFeature(appGUID string, featureName string) (resources.ApplicationFeature, v7action.Warnings, error) + GetAccessRulesByRoute(domainName, hostname, path string) ([]resources.AccessRule, v7action.Warnings, error) + GetAccessRulesForSpace(spaceGUID string, domainName string, hostname string, path string, labelSelector string) ([]v7action.AccessRuleWithRoute, v7action.Warnings, error) GetAppSummariesForSpace(spaceGUID string, labels string, omitStats bool) ([]v7action.ApplicationSummary, v7action.Warnings, error) GetApplicationByNameAndSpace(appName string, spaceGUID string) (resources.Application, v7action.Warnings, error) GetApplicationMapForRoute(route resources.Route) (map[string]resources.Application, v7action.Warnings, error) diff --git a/command/v7/add_access_rule_command.go b/command/v7/add_access_rule_command.go new file mode 100644 index 00000000000..b3db3914811 --- /dev/null +++ b/command/v7/add_access_rule_command.go @@ -0,0 +1,284 @@ +package v7 + +import ( + "fmt" + + "code.cloudfoundry.org/cli/v9/actor/actionerror" + "code.cloudfoundry.org/cli/v9/actor/v7action" + "code.cloudfoundry.org/cli/v9/command/flag" + "code.cloudfoundry.org/cli/v9/command/translatableerror" +) + +type AddAccessRuleCommand struct { + BaseCommand + + RequiredArgs flag.AddAccessRuleArgs `positional-args:"yes"` + Hostname string `long:"hostname" required:"true" description:"Hostname for the route"` + Path string `long:"path" description:"Path for the route"` + + // Source resolution flags (mutually exclusive as primary source) + SourceApp string `long:"source-app" description:"Allow access from this app (by name)"` + SourceSpace string `long:"source-space" description:"Allow access from all apps in this space (by name) or specify the space for --source-app"` + SourceOrg string `long:"source-org" description:"Allow access from all apps in this org (by name) or specify the org for --source-space/--source-app"` + SourceAny bool `long:"source-any" description:"Allow access from any authenticated app"` + + // Advanced: raw selector flag + Selector string `long:"selector" description:"Raw selector (cf:app:, cf:space:, cf:org:, or cf:any)"` + + usage interface{} `usage:"CF_NAME add-access-rule RULE_NAME DOMAIN --hostname HOSTNAME [--source-app APP_NAME [--source-space SPACE_NAME] [--source-org ORG_NAME] | --source-space SPACE_NAME [--source-org ORG_NAME] | --source-org ORG_NAME | --source-any | --selector SELECTOR] [--path PATH]\n\nALLOW ACCESS TO A ROUTE:\n Create an access rule that allows specific apps, spaces, or orgs to access a route using mTLS authentication.\n\nEXAMPLES:\n # Allow the \"frontend-app\" (in current space) to access the backend route\n cf add-access-rule allow-frontend apps.identity --source-app frontend-app --hostname backend\n\n # Allow an app in a different space to access the route\n cf add-access-rule allow-other-space apps.identity --source-app api-client --source-space other-space --hostname backend\n\n # Allow an app in a different org to access the route\n cf add-access-rule allow-other-org apps.identity --source-app external-client --source-space external-space --source-org external-org --hostname backend\n\n # Allow all apps in the \"monitoring\" space to access the API metrics endpoint\n cf add-access-rule allow-monitoring apps.identity --source-space monitoring --hostname api --path /metrics\n\n # Allow all apps in a space in a different org\n cf add-access-rule allow-prod-space apps.identity --source-space prod-space --source-org prod-org --hostname api\n\n # Allow all apps in the \"platform\" org to access the route\n cf add-access-rule allow-platform-org apps.identity --source-org platform --hostname shared-api\n\n # Allow any authenticated app to access the public API\n cf add-access-rule allow-all apps.identity --source-any --hostname public-api\n\n # Use raw selector (advanced)\n cf add-access-rule allow-raw apps.identity --selector cf:app:d76446a1-f429-4444-8797-be2f78b75b08 --hostname backend"` + relatedCommands interface{} `related_commands:"access-rules, remove-access-rule, create-shared-domain"` +} + +func (cmd AddAccessRuleCommand) Execute(args []string) error { + // Validate source flags + if err := cmd.validateSourceFlags(); err != nil { + return err + } + + err := cmd.SharedActor.CheckTarget(true, true) + if err != nil { + return err + } + + user, err := cmd.Actor.GetCurrentUser() + if err != nil { + return err + } + + // Resolve selector from source flags + selector, scopeDisplay, warnings, err := cmd.resolveSelector() + cmd.UI.DisplayWarnings(warnings) + if err != nil { + return err + } + + // Validate selector format + if err := validateSelector(selector); err != nil { + return err + } + + ruleName := cmd.RequiredArgs.RuleName + domainName := cmd.RequiredArgs.Domain + + cmd.UI.DisplayTextWithFlavor("Adding access rule {{.RuleName}} for route {{.Hostname}}.{{.Domain}}{{.Path}} as {{.User}}...", + map[string]interface{}{ + "RuleName": ruleName, + "Hostname": cmd.Hostname, + "Domain": domainName, + "Path": formatPath(cmd.Path), + "User": user.Name, + }) + + // Display resolved source (for transparency) + cmd.UI.DisplayText(" {{.ScopeDisplay}}", + map[string]interface{}{ + "ScopeDisplay": scopeDisplay, + }) + cmd.UI.DisplayText(" selector: {{.Selector}}", + map[string]interface{}{ + "Selector": selector, + }) + + warnings, err = cmd.Actor.AddAccessRule(ruleName, domainName, selector, cmd.Hostname, cmd.Path) + cmd.UI.DisplayWarnings(warnings) + if err != nil { + return err + } + + cmd.UI.DisplayOK() + cmd.UI.DisplayText("TIP: Access rule '{{.RuleName}}' has been created. It may take a few seconds for the rule to propagate to GoRouter.", + map[string]interface{}{ + "RuleName": ruleName, + }) + + return nil +} + +// validateSourceFlags ensures exactly one source target is specified and validates combinations +func (cmd AddAccessRuleCommand) validateSourceFlags() error { + sourceFlags := []string{} + + if cmd.Selector != "" { + sourceFlags = append(sourceFlags, "--selector") + } + if cmd.SourceApp != "" { + sourceFlags = append(sourceFlags, "--source-app") + } + if cmd.SourceSpace != "" && cmd.SourceApp == "" { + // --source-space only counts as a primary source if --source-app is NOT provided + sourceFlags = append(sourceFlags, "--source-space") + } + if cmd.SourceOrg != "" && cmd.SourceSpace == "" && cmd.SourceApp == "" { + // --source-org only counts as a primary source if neither --source-space nor --source-app are provided + sourceFlags = append(sourceFlags, "--source-org") + } + if cmd.SourceAny { + sourceFlags = append(sourceFlags, "--source-any") + } + + if len(sourceFlags) == 0 { + return translatableerror.RequiredArgumentError{ + ArgumentName: "one of: --source-app, --source-space, --source-org, --source-any, or --selector", + } + } + + if len(sourceFlags) > 1 { + return translatableerror.ArgumentCombinationError{ + Args: sourceFlags, + } + } + + return nil +} + +// resolveSelector resolves source flags to a selector string +// Returns (selector, scopeDisplay, warnings, error) +// scopeDisplay is a human-readable description for output (e.g., "scope: app, source: frontend-app") +func (cmd AddAccessRuleCommand) resolveSelector() (string, string, v7action.Warnings, error) { + var allWarnings v7action.Warnings + + // Priority: --selector flag (raw selector, no resolution needed) + if cmd.Selector != "" { + return cmd.Selector, fmt.Sprintf("selector: %s", cmd.Selector), allWarnings, nil + } + + // --source-any + if cmd.SourceAny { + return "cf:any", "scope: any, source: any authenticated app", allWarnings, nil + } + + // --source-app (with optional --source-space and --source-org for cross-space/org lookup) + if cmd.SourceApp != "" { + // Determine space GUID for app lookup + spaceGUID := cmd.Config.TargetedSpace().GUID + spaceName := cmd.Config.TargetedSpace().Name + orgName := cmd.Config.TargetedOrganization().Name + + if cmd.SourceSpace != "" { + // Determine org GUID for space lookup + orgGUID := cmd.Config.TargetedOrganization().GUID + if cmd.SourceOrg != "" { + org, warnings, err := cmd.Actor.GetOrganizationByName(cmd.SourceOrg) + allWarnings = append(allWarnings, warnings...) + if err != nil { + return "", "", allWarnings, err + } + orgGUID = org.GUID + orgName = cmd.SourceOrg + } + + // Resolve space by name + space, warnings, err := cmd.Actor.GetSpaceByNameAndOrganization(cmd.SourceSpace, orgGUID) + allWarnings = append(allWarnings, warnings...) + if err != nil { + return "", "", allWarnings, err + } + spaceGUID = space.GUID + spaceName = cmd.SourceSpace + } + + // Resolve app by name in the determined space + app, warnings, err := cmd.Actor.GetApplicationByNameAndSpace(cmd.SourceApp, spaceGUID) + allWarnings = append(allWarnings, warnings...) + if err != nil { + // Enhanced error message for app not found + if _, ok := err.(actionerror.ApplicationNotFoundError); ok { + if cmd.SourceSpace == "" { + // App not found in current space + return "", "", allWarnings, fmt.Errorf( + "App '%s' not found in space '%s' / org '%s'.\nTIP: If the app is in a different space or org, use --source-space and/or --source-org flags.", + cmd.SourceApp, + cmd.Config.TargetedSpace().Name, + cmd.Config.TargetedOrganization().Name, + ) + } + } + return "", "", allWarnings, err + } + + scopeDisplay := fmt.Sprintf("scope: app, source: %s", cmd.SourceApp) + if cmd.SourceSpace != "" { + scopeDisplay += fmt.Sprintf(" (space: %s", spaceName) + if cmd.SourceOrg != "" { + scopeDisplay += fmt.Sprintf(", org: %s", orgName) + } + scopeDisplay += ")" + } + + return fmt.Sprintf("cf:app:%s", app.GUID), scopeDisplay, allWarnings, nil + } + + // --source-space (without --source-app, so create space-level rule) + if cmd.SourceSpace != "" { + // Determine org GUID for space lookup + orgGUID := cmd.Config.TargetedOrganization().GUID + orgName := cmd.Config.TargetedOrganization().Name + if cmd.SourceOrg != "" { + org, warnings, err := cmd.Actor.GetOrganizationByName(cmd.SourceOrg) + allWarnings = append(allWarnings, warnings...) + if err != nil { + return "", "", allWarnings, err + } + orgGUID = org.GUID + orgName = cmd.SourceOrg + } + + // Resolve space by name + space, warnings, err := cmd.Actor.GetSpaceByNameAndOrganization(cmd.SourceSpace, orgGUID) + allWarnings = append(allWarnings, warnings...) + if err != nil { + return "", "", allWarnings, err + } + + scopeDisplay := fmt.Sprintf("scope: space, source: %s", cmd.SourceSpace) + if cmd.SourceOrg != "" { + scopeDisplay += fmt.Sprintf(" (org: %s)", orgName) + } + + return fmt.Sprintf("cf:space:%s", space.GUID), scopeDisplay, allWarnings, nil + } + + // --source-org (without --source-space or --source-app, so create org-level rule) + if cmd.SourceOrg != "" { + org, warnings, err := cmd.Actor.GetOrganizationByName(cmd.SourceOrg) + allWarnings = append(allWarnings, warnings...) + if err != nil { + return "", "", allWarnings, err + } + + scopeDisplay := fmt.Sprintf("scope: org, source: %s", cmd.SourceOrg) + + return fmt.Sprintf("cf:org:%s", org.GUID), scopeDisplay, allWarnings, nil + } + + // Should never reach here due to validation + return "", "", allWarnings, fmt.Errorf("no source specified") +} + +func validateSelector(selector string) error { + // Basic validation - check for cf:app:, cf:space:, cf:org:, or cf:any prefix + validPrefixes := []string{"cf:app:", "cf:space:", "cf:org:", "cf:any"} + for _, prefix := range validPrefixes { + if len(selector) >= len(prefix) && selector[:len(prefix)] == prefix { + if prefix == "cf:any" { + if selector != "cf:any" { + return fmt.Errorf("selector 'cf:any' must not have a GUID suffix") + } + return nil + } + // For other selectors, ensure there's a GUID after the prefix + if len(selector) <= len(prefix) { + return fmt.Errorf("selector '%s' must include a GUID (e.g., %s)", selector, prefix) + } + return nil + } + } + return fmt.Errorf("selector must start with one of: cf:app:, cf:space:, cf:org:, or be exactly 'cf:any'") +} + +func formatPath(path string) string { + if path == "" { + return "" + } + return path +} diff --git a/command/v7/add_access_rule_command_test.go b/command/v7/add_access_rule_command_test.go new file mode 100644 index 00000000000..f6b73907d28 --- /dev/null +++ b/command/v7/add_access_rule_command_test.go @@ -0,0 +1,453 @@ +package v7_test + +import ( + "code.cloudfoundry.org/cli/v9/actor/actionerror" + "code.cloudfoundry.org/cli/v9/actor/v7action" + "code.cloudfoundry.org/cli/v9/command/commandfakes" + "code.cloudfoundry.org/cli/v9/command/flag" + "code.cloudfoundry.org/cli/v9/command/translatableerror" + . "code.cloudfoundry.org/cli/v9/command/v7" + "code.cloudfoundry.org/cli/v9/command/v7/v7fakes" + "code.cloudfoundry.org/cli/v9/resources" + "code.cloudfoundry.org/cli/v9/util/configv3" + "code.cloudfoundry.org/cli/v9/util/ui" + . "github.com/onsi/ginkgo/v2" + . "github.com/onsi/gomega" + . "github.com/onsi/gomega/gbytes" +) + +var _ = Describe("add-access-rule Command", func() { + var ( + cmd AddAccessRuleCommand + testUI *ui.UI + fakeConfig *commandfakes.FakeConfig + fakeSharedActor *commandfakes.FakeSharedActor + fakeActor *v7fakes.FakeActor + executeErr error + args []string + ) + + BeforeEach(func() { + testUI = ui.NewTestUI(nil, NewBuffer(), NewBuffer()) + fakeConfig = new(commandfakes.FakeConfig) + fakeSharedActor = new(commandfakes.FakeSharedActor) + fakeActor = new(v7fakes.FakeActor) + + cmd = AddAccessRuleCommand{ + BaseCommand: BaseCommand{ + UI: testUI, + Config: fakeConfig, + SharedActor: fakeSharedActor, + Actor: fakeActor, + }, + } + + // Setup default config returns + fakeConfig.TargetedOrganizationReturns(configv3.Organization{ + GUID: "org-guid", + Name: "org-name", + }) + fakeConfig.TargetedSpaceReturns(configv3.Space{ + GUID: "space-guid", + Name: "space-name", + }) + + fakeActor.GetCurrentUserReturns(configv3.User{Name: "test-user"}, nil) + + args = []string{} + }) + + JustBeforeEach(func() { + executeErr = cmd.Execute(args) + }) + + Describe("validation", func() { + Context("when no source flags are provided", func() { + BeforeEach(func() { + cmd.RequiredArgs = flag.AddAccessRuleArgs{ + RuleName: "test-rule", + Domain: "apps.internal", + } + cmd.Hostname = "backend" + }) + + It("returns a RequiredArgumentError", func() { + Expect(executeErr).To(MatchError(translatableerror.RequiredArgumentError{ + ArgumentName: "one of: --source-app, --source-space, --source-org, --source-any, or --selector", + })) + }) + }) + + Context("when multiple mutually exclusive source flags are provided", func() { + BeforeEach(func() { + cmd.RequiredArgs = flag.AddAccessRuleArgs{ + RuleName: "test-rule", + Domain: "apps.internal", + } + cmd.Hostname = "backend" + cmd.SourceApp = "app-name" + cmd.SourceAny = true + }) + + It("returns an ArgumentCombinationError", func() { + Expect(executeErr).To(MatchError(translatableerror.ArgumentCombinationError{ + Args: []string{"--source-app", "--source-any"}, + })) + }) + }) + + Context("when --source-space and --source-any are both provided", func() { + BeforeEach(func() { + cmd.RequiredArgs = flag.AddAccessRuleArgs{ + RuleName: "test-rule", + Domain: "apps.internal", + } + cmd.Hostname = "backend" + cmd.SourceSpace = "some-space" + cmd.SourceAny = true + }) + + It("returns an ArgumentCombinationError", func() { + Expect(executeErr).To(MatchError(translatableerror.ArgumentCombinationError{ + Args: []string{"--source-space", "--source-any"}, + })) + }) + }) + }) + + When("the user is logged in, an org is targeted, and a space is targeted", func() { + BeforeEach(func() { + cmd.RequiredArgs = flag.AddAccessRuleArgs{ + RuleName: "test-rule", + Domain: "apps.internal", + } + cmd.Hostname = "backend" + }) + + Describe("source resolution", func() { + Context("when --source-app is provided (current space)", func() { + BeforeEach(func() { + cmd.SourceApp = "frontend-app" + fakeActor.GetApplicationByNameAndSpaceReturns( + resources.Application{GUID: "app-guid"}, + v7action.Warnings{"app-warning"}, + nil, + ) + fakeActor.AddAccessRuleReturns(v7action.Warnings{"add-warning"}, nil) + }) + + It("resolves the app and creates the access rule", func() { + Expect(executeErr).NotTo(HaveOccurred()) + + // Verify app lookup + Expect(fakeActor.GetApplicationByNameAndSpaceCallCount()).To(Equal(1)) + appName, spaceGUID := fakeActor.GetApplicationByNameAndSpaceArgsForCall(0) + Expect(appName).To(Equal("frontend-app")) + Expect(spaceGUID).To(Equal("space-guid")) + + // Verify access rule creation with resolved selector + Expect(fakeActor.AddAccessRuleCallCount()).To(Equal(1)) + ruleName, domain, selector, hostname, path := fakeActor.AddAccessRuleArgsForCall(0) + Expect(ruleName).To(Equal("test-rule")) + Expect(domain).To(Equal("apps.internal")) + Expect(selector).To(Equal("cf:app:app-guid")) + Expect(hostname).To(Equal("backend")) + Expect(path).To(BeEmpty()) + + // Verify output + Expect(testUI.Out).To(Say("Adding access rule test-rule")) + Expect(testUI.Out).To(Say("scope: app, source: frontend-app")) + Expect(testUI.Out).To(Say("selector: cf:app:app-guid")) + Expect(testUI.Out).To(Say("OK")) + }) + + It("displays warnings", func() { + Expect(testUI.Err).To(Say("app-warning")) + Expect(testUI.Err).To(Say("add-warning")) + }) + }) + + Context("when --source-app is provided with --source-space (cross-space)", func() { + BeforeEach(func() { + cmd.SourceApp = "frontend-app" + cmd.SourceSpace = "other-space" + + fakeActor.GetSpaceByNameAndOrganizationReturns( + resources.Space{GUID: "other-space-guid"}, + v7action.Warnings{"space-warning"}, + nil, + ) + fakeActor.GetApplicationByNameAndSpaceReturns( + resources.Application{GUID: "app-guid"}, + v7action.Warnings{"app-warning"}, + nil, + ) + fakeActor.AddAccessRuleReturns(v7action.Warnings{"add-warning"}, nil) + }) + + It("resolves space then app and creates the access rule", func() { + Expect(executeErr).NotTo(HaveOccurred()) + + // Verify space lookup + Expect(fakeActor.GetSpaceByNameAndOrganizationCallCount()).To(Equal(1)) + spaceName, orgGUID := fakeActor.GetSpaceByNameAndOrganizationArgsForCall(0) + Expect(spaceName).To(Equal("other-space")) + Expect(orgGUID).To(Equal("org-guid")) + + // Verify app lookup in resolved space + Expect(fakeActor.GetApplicationByNameAndSpaceCallCount()).To(Equal(1)) + appName, spaceGUID := fakeActor.GetApplicationByNameAndSpaceArgsForCall(0) + Expect(appName).To(Equal("frontend-app")) + Expect(spaceGUID).To(Equal("other-space-guid")) + + // Verify selector + _, _, selector, _, _ := fakeActor.AddAccessRuleArgsForCall(0) + Expect(selector).To(Equal("cf:app:app-guid")) + + // Verify output shows cross-space info + Expect(testUI.Out).To(Say("scope: app, source: frontend-app \\(space: other-space\\)")) + }) + }) + + Context("when --source-app is provided with --source-space and --source-org (cross-org)", func() { + BeforeEach(func() { + cmd.SourceApp = "frontend-app" + cmd.SourceSpace = "other-space" + cmd.SourceOrg = "other-org" + + fakeActor.GetOrganizationByNameReturns( + resources.Organization{GUID: "other-org-guid"}, + v7action.Warnings{"org-warning"}, + nil, + ) + fakeActor.GetSpaceByNameAndOrganizationReturns( + resources.Space{GUID: "other-space-guid"}, + v7action.Warnings{"space-warning"}, + nil, + ) + fakeActor.GetApplicationByNameAndSpaceReturns( + resources.Application{GUID: "app-guid"}, + v7action.Warnings{"app-warning"}, + nil, + ) + fakeActor.AddAccessRuleReturns(v7action.Warnings{"add-warning"}, nil) + }) + + It("resolves org, space, then app and creates the access rule", func() { + Expect(executeErr).NotTo(HaveOccurred()) + + // Verify org lookup + Expect(fakeActor.GetOrganizationByNameCallCount()).To(Equal(1)) + orgName := fakeActor.GetOrganizationByNameArgsForCall(0) + Expect(orgName).To(Equal("other-org")) + + // Verify space lookup with resolved org + spaceName, orgGUID := fakeActor.GetSpaceByNameAndOrganizationArgsForCall(0) + Expect(spaceName).To(Equal("other-space")) + Expect(orgGUID).To(Equal("other-org-guid")) + + // Verify output shows cross-org info + Expect(testUI.Out).To(Say("scope: app, source: frontend-app \\(space: other-space, org: other-org\\)")) + }) + }) + + Context("when --source-app is not found in current space", func() { + BeforeEach(func() { + cmd.SourceApp = "missing-app" + fakeActor.GetApplicationByNameAndSpaceReturns( + resources.Application{}, + v7action.Warnings{"app-warning"}, + actionerror.ApplicationNotFoundError{Name: "missing-app"}, + ) + }) + + It("returns a helpful error message", func() { + Expect(executeErr).To(HaveOccurred()) + Expect(executeErr.Error()).To(ContainSubstring("App 'missing-app' not found in space 'space-name' / org 'org-name'")) + Expect(executeErr.Error()).To(ContainSubstring("TIP: If the app is in a different space or org, use --source-space and/or --source-org flags")) + }) + }) + + Context("when --source-space is provided (without --source-app)", func() { + BeforeEach(func() { + cmd.SourceSpace = "monitoring-space" + fakeActor.GetSpaceByNameAndOrganizationReturns( + resources.Space{GUID: "space-guid-123"}, + v7action.Warnings{"space-warning"}, + nil, + ) + fakeActor.AddAccessRuleReturns(v7action.Warnings{"add-warning"}, nil) + }) + + It("creates a space-level access rule", func() { + Expect(executeErr).NotTo(HaveOccurred()) + + // Verify selector is space-level + _, _, selector, _, _ := fakeActor.AddAccessRuleArgsForCall(0) + Expect(selector).To(Equal("cf:space:space-guid-123")) + + Expect(testUI.Out).To(Say("scope: space, source: monitoring-space")) + }) + }) + + Context("when --source-space is provided with --source-org (cross-org space rule)", func() { + BeforeEach(func() { + cmd.SourceSpace = "prod-space" + cmd.SourceOrg = "prod-org" + + fakeActor.GetOrganizationByNameReturns( + resources.Organization{GUID: "prod-org-guid"}, + v7action.Warnings{"org-warning"}, + nil, + ) + fakeActor.GetSpaceByNameAndOrganizationReturns( + resources.Space{GUID: "prod-space-guid"}, + v7action.Warnings{"space-warning"}, + nil, + ) + fakeActor.AddAccessRuleReturns(v7action.Warnings{"add-warning"}, nil) + }) + + It("creates a space-level access rule for the specified org", func() { + Expect(executeErr).NotTo(HaveOccurred()) + + // Verify org lookup + Expect(fakeActor.GetOrganizationByNameCallCount()).To(Equal(1)) + orgName := fakeActor.GetOrganizationByNameArgsForCall(0) + Expect(orgName).To(Equal("prod-org")) + + // Verify space lookup with resolved org + spaceName, orgGUID := fakeActor.GetSpaceByNameAndOrganizationArgsForCall(0) + Expect(spaceName).To(Equal("prod-space")) + Expect(orgGUID).To(Equal("prod-org-guid")) + + // Verify selector is space-level + _, _, selector, _, _ := fakeActor.AddAccessRuleArgsForCall(0) + Expect(selector).To(Equal("cf:space:prod-space-guid")) + + Expect(testUI.Out).To(Say("scope: space, source: prod-space \\(org: prod-org\\)")) + }) + }) + + Context("when --source-org is provided (without --source-space or --source-app)", func() { + BeforeEach(func() { + cmd.SourceOrg = "platform-org" + fakeActor.GetOrganizationByNameReturns( + resources.Organization{GUID: "org-guid-456"}, + v7action.Warnings{"org-warning"}, + nil, + ) + fakeActor.AddAccessRuleReturns(v7action.Warnings{"add-warning"}, nil) + }) + + It("creates an org-level access rule", func() { + Expect(executeErr).NotTo(HaveOccurred()) + + // Verify selector is org-level + _, _, selector, _, _ := fakeActor.AddAccessRuleArgsForCall(0) + Expect(selector).To(Equal("cf:org:org-guid-456")) + + Expect(testUI.Out).To(Say("scope: org, source: platform-org")) + }) + }) + + Context("when --source-any is provided", func() { + BeforeEach(func() { + cmd.SourceAny = true + fakeActor.AddAccessRuleReturns(v7action.Warnings{"add-warning"}, nil) + }) + + It("creates an 'any' access rule", func() { + Expect(executeErr).NotTo(HaveOccurred()) + + _, _, selector, _, _ := fakeActor.AddAccessRuleArgsForCall(0) + Expect(selector).To(Equal("cf:any")) + + Expect(testUI.Out).To(Say("scope: any, source: any authenticated app")) + }) + }) + + Context("when --selector is provided (raw selector)", func() { + BeforeEach(func() { + cmd.Selector = "cf:app:raw-guid-123" + fakeActor.AddAccessRuleReturns(v7action.Warnings{"add-warning"}, nil) + }) + + It("uses the raw selector without resolution", func() { + Expect(executeErr).NotTo(HaveOccurred()) + + _, _, selector, _, _ := fakeActor.AddAccessRuleArgsForCall(0) + Expect(selector).To(Equal("cf:app:raw-guid-123")) + + Expect(testUI.Out).To(Say("selector: cf:app:raw-guid-123")) + + // Should not call any resolution methods + Expect(fakeActor.GetApplicationByNameAndSpaceCallCount()).To(Equal(0)) + Expect(fakeActor.GetSpaceByNameAndOrganizationCallCount()).To(Equal(0)) + Expect(fakeActor.GetOrganizationByNameCallCount()).To(Equal(0)) + }) + }) + + Context("when --path is provided", func() { + BeforeEach(func() { + cmd.SourceAny = true + cmd.Path = "/metrics" + fakeActor.AddAccessRuleReturns(v7action.Warnings{"add-warning"}, nil) + }) + + It("passes the path to the actor", func() { + Expect(executeErr).NotTo(HaveOccurred()) + + _, _, _, _, path := fakeActor.AddAccessRuleArgsForCall(0) + Expect(path).To(Equal("/metrics")) + }) + }) + }) + + Describe("error handling", func() { + Context("when AddAccessRule fails", func() { + BeforeEach(func() { + cmd.SourceAny = true + fakeActor.AddAccessRuleReturns(v7action.Warnings{"add-warning"}, actionerror.RouteNotFoundError{}) + }) + + It("returns the error", func() { + Expect(executeErr).To(MatchError(actionerror.RouteNotFoundError{})) + Expect(testUI.Err).To(Say("add-warning")) + }) + }) + + Context("when space lookup fails", func() { + BeforeEach(func() { + cmd.SourceSpace = "nonexistent-space" + fakeActor.GetSpaceByNameAndOrganizationReturns( + resources.Space{}, + v7action.Warnings{"space-warning"}, + actionerror.SpaceNotFoundError{Name: "nonexistent-space"}, + ) + }) + + It("returns the error", func() { + Expect(executeErr).To(MatchError(actionerror.SpaceNotFoundError{Name: "nonexistent-space"})) + Expect(testUI.Err).To(Say("space-warning")) + }) + }) + + Context("when org lookup fails", func() { + BeforeEach(func() { + cmd.SourceOrg = "nonexistent-org" + fakeActor.GetOrganizationByNameReturns( + resources.Organization{}, + v7action.Warnings{"org-warning"}, + actionerror.OrganizationNotFoundError{Name: "nonexistent-org"}, + ) + }) + + It("returns the error", func() { + Expect(executeErr).To(MatchError(actionerror.OrganizationNotFoundError{Name: "nonexistent-org"})) + Expect(testUI.Err).To(Say("org-warning")) + }) + }) + }) + }) +}) diff --git a/command/v7/create_private_domain_command.go b/command/v7/create_private_domain_command.go index 2701ca91c47..1a95ae97250 100644 --- a/command/v7/create_private_domain_command.go +++ b/command/v7/create_private_domain_command.go @@ -10,9 +10,11 @@ import ( type CreatePrivateDomainCommand struct { BaseCommand - RequiredArgs flag.OrgDomain `positional-args:"yes"` - usage interface{} `usage:"CF_NAME create-private-domain ORG DOMAIN"` - relatedCommands interface{} `related_commands:"create-shared-domain, domains, share-private-domain"` + RequiredArgs flag.OrgDomain `positional-args:"yes"` + EnforceAccessRules bool `long:"enforce-access-rules" description:"Enable platform-enforced access control for routes on this domain (requires mTLS domain configuration in GoRouter)"` + Scope string `long:"scope" description:"Operator-level scope boundary for access rules: 'any', 'org', or 'space' (only valid with --enforce-access-rules)"` + usage interface{} `usage:"CF_NAME create-private-domain ORG DOMAIN [--enforce-access-rules [--scope (any|org|space)]]"` + relatedCommands interface{} `related_commands:"create-shared-domain, domains, share-private-domain, add-access-rule, access-rules"` } func (cmd CreatePrivateDomainCommand) Execute(args []string) error { @@ -29,6 +31,16 @@ func (cmd CreatePrivateDomainCommand) Execute(args []string) error { domain := cmd.RequiredArgs.Domain orgName := cmd.RequiredArgs.Organization + // Validate that --scope is only used with --enforce-access-rules + if cmd.Scope != "" && !cmd.EnforceAccessRules { + return fmt.Errorf("--scope can only be used with --enforce-access-rules") + } + + // Validate scope values + if cmd.Scope != "" && cmd.Scope != "any" && cmd.Scope != "org" && cmd.Scope != "space" { + return fmt.Errorf("--scope must be one of: any, org, space") + } + cmd.UI.DisplayTextWithFlavor("Creating private domain {{.Domain}} for org {{.Organization}} as {{.User}}...", map[string]interface{}{ "Domain": domain, @@ -36,7 +48,7 @@ func (cmd CreatePrivateDomainCommand) Execute(args []string) error { "Organization": orgName, }) - warnings, err := cmd.Actor.CreatePrivateDomain(domain, orgName) + warnings, err := cmd.Actor.CreatePrivateDomain(domain, orgName, cmd.EnforceAccessRules, cmd.Scope) cmd.UI.DisplayWarnings(warnings) if err != nil { @@ -53,9 +65,16 @@ func (cmd CreatePrivateDomainCommand) Execute(args []string) error { cmd.UI.DisplayOK() - cmd.UI.DisplayText("TIP: Domain '{{.Domain}}' is a private domain. Run 'cf share-private-domain' to share this domain with a different org.", - map[string]interface{}{ - "Domain": domain, - }) + if cmd.EnforceAccessRules { + cmd.UI.DisplayText("TIP: Domain '{{.Domain}}' is a private identity-aware domain with access rule enforcement enabled. Routes on this domain require access rules to allow traffic.", + map[string]interface{}{ + "Domain": domain, + }) + } else { + cmd.UI.DisplayText("TIP: Domain '{{.Domain}}' is a private domain. Run 'cf share-private-domain' to share this domain with a different org.", + map[string]interface{}{ + "Domain": domain, + }) + } return nil } diff --git a/command/v7/create_private_domain_command_test.go b/command/v7/create_private_domain_command_test.go index 67db5bf98cd..d30941f39d7 100644 --- a/command/v7/create_private_domain_command_test.go +++ b/command/v7/create_private_domain_command_test.go @@ -113,7 +113,7 @@ var _ = Describe("create-private-domain Command", func() { It("creates the domain", func() { Expect(fakeActor.CreatePrivateDomainCallCount()).To(Equal(1)) - expectedDomainName, expectedOrgName := fakeActor.CreatePrivateDomainArgsForCall(0) + expectedDomainName, expectedOrgName, _, _ := fakeActor.CreatePrivateDomainArgsForCall(0) Expect(expectedDomainName).To(Equal(domainName)) Expect(expectedOrgName).To(Equal(orgName)) }) diff --git a/command/v7/create_shared_domain_command.go b/command/v7/create_shared_domain_command.go index e48ec61dd6f..d154dac0312 100644 --- a/command/v7/create_shared_domain_command.go +++ b/command/v7/create_shared_domain_command.go @@ -1,17 +1,21 @@ package v7 import ( + "fmt" + "code.cloudfoundry.org/cli/v9/command/flag" ) type CreateSharedDomainCommand struct { BaseCommand - RequiredArgs flag.Domain `positional-args:"yes"` - RouterGroup string `long:"router-group" description:"Routes for this domain will use routers in the specified router group"` - Internal bool `long:"internal" description:"Applications that use internal routes communicate directly on the container network"` - usage interface{} `usage:"CF_NAME create-shared-domain DOMAIN [--router-group ROUTER_GROUP_NAME | --internal]"` - relatedCommands interface{} `related_commands:"create-private-domain, domains"` + RequiredArgs flag.Domain `positional-args:"yes"` + RouterGroup string `long:"router-group" description:"Routes for this domain will use routers in the specified router group"` + Internal bool `long:"internal" description:"Applications that use internal routes communicate directly on the container network"` + EnforceAccessRules bool `long:"enforce-access-rules" description:"Enable platform-enforced access control for routes on this domain (requires mTLS domain configuration in GoRouter)"` + Scope string `long:"scope" description:"Operator-level scope boundary for access rules: 'any', 'org', or 'space' (only valid with --enforce-access-rules)"` + usage interface{} `usage:"CF_NAME create-shared-domain DOMAIN [--router-group ROUTER_GROUP_NAME | --internal] [--enforce-access-rules [--scope (any|org|space)]]"` + relatedCommands interface{} `related_commands:"create-private-domain, domains, add-access-rule, access-rules"` } func (cmd CreateSharedDomainCommand) Execute(args []string) error { @@ -27,22 +31,40 @@ func (cmd CreateSharedDomainCommand) Execute(args []string) error { domain := cmd.RequiredArgs.Domain + // Validate that --scope is only used with --enforce-access-rules + if cmd.Scope != "" && !cmd.EnforceAccessRules { + return fmt.Errorf("--scope can only be used with --enforce-access-rules") + } + + // Validate scope values + if cmd.Scope != "" && cmd.Scope != "any" && cmd.Scope != "org" && cmd.Scope != "space" { + return fmt.Errorf("--scope must be one of: any, org, space") + } + cmd.UI.DisplayTextWithFlavor("Creating shared domain {{.Domain}} as {{.User}}...", map[string]interface{}{ "Domain": domain, "User": user.Name, }) - warnings, err := cmd.Actor.CreateSharedDomain(domain, cmd.Internal, cmd.RouterGroup) + warnings, err := cmd.Actor.CreateSharedDomain(domain, cmd.Internal, cmd.RouterGroup, cmd.EnforceAccessRules, cmd.Scope) cmd.UI.DisplayWarnings(warnings) if err != nil { return err } cmd.UI.DisplayOK() - cmd.UI.DisplayText("TIP: Domain '{{.Domain}}' is shared with all orgs. Run 'cf domains' to view available domains.", - map[string]interface{}{ - "Domain": domain, - }) + + if cmd.EnforceAccessRules { + cmd.UI.DisplayText("TIP: Domain '{{.Domain}}' is a shared identity-aware domain with access rule enforcement enabled. Routes on this domain require access rules to allow traffic.", + map[string]interface{}{ + "Domain": domain, + }) + } else { + cmd.UI.DisplayText("TIP: Domain '{{.Domain}}' is shared with all orgs. Run 'cf domains' to view available domains.", + map[string]interface{}{ + "Domain": domain, + }) + } return nil } diff --git a/command/v7/create_shared_domain_command_test.go b/command/v7/create_shared_domain_command_test.go index 9df31c8cbb3..6e757f92859 100644 --- a/command/v7/create_shared_domain_command_test.go +++ b/command/v7/create_shared_domain_command_test.go @@ -126,7 +126,7 @@ var _ = Describe("create-shared-domain Command", func() { It("creates the domain", func() { Expect(fakeActor.CreateSharedDomainCallCount()).To(Equal(1)) - expectedDomainName, expectedInternal, expectedRouterGroup := fakeActor.CreateSharedDomainArgsForCall(0) + expectedDomainName, expectedInternal, expectedRouterGroup, _, _ := fakeActor.CreateSharedDomainArgsForCall(0) Expect(expectedDomainName).To(Equal(domainName)) Expect(expectedInternal).To(BeTrue()) Expect(expectedRouterGroup).To(Equal("router-group")) diff --git a/command/v7/remove_access_rule_command.go b/command/v7/remove_access_rule_command.go new file mode 100644 index 00000000000..12d0b08eb4b --- /dev/null +++ b/command/v7/remove_access_rule_command.go @@ -0,0 +1,71 @@ +package v7 + +import ( + "code.cloudfoundry.org/cli/v9/command/flag" +) + +type RemoveAccessRuleCommand struct { + BaseCommand + + RequiredArgs flag.RemoveAccessRuleArgs `positional-args:"yes"` + Hostname string `long:"hostname" required:"true" description:"Hostname for the route"` + Path string `long:"path" description:"Path for the route"` + Force bool `short:"f" description:"Force deletion without confirmation"` + usage interface{} `usage:"CF_NAME remove-access-rule RULE_NAME DOMAIN --hostname HOSTNAME [--path PATH] [-f]\n\nEXAMPLES:\n cf remove-access-rule allow-frontend apps.identity --hostname backend\n cf remove-access-rule allow-monitoring apps.identity --hostname api --path /metrics -f"` + relatedCommands interface{} `related_commands:"access-rules, add-access-rule"` +} + +func (cmd RemoveAccessRuleCommand) Execute(args []string) error { + err := cmd.SharedActor.CheckTarget(true, true) + if err != nil { + return err + } + + user, err := cmd.Actor.GetCurrentUser() + if err != nil { + return err + } + + ruleName := cmd.RequiredArgs.RuleName + domainName := cmd.RequiredArgs.Domain + + if !cmd.Force { + prompt := "Really remove access rule {{.RuleName}} for route {{.Hostname}}.{{.Domain}}{{.Path}}?" + response, promptErr := cmd.UI.DisplayBoolPrompt(false, prompt, map[string]interface{}{ + "RuleName": ruleName, + "Hostname": cmd.Hostname, + "Domain": domainName, + "Path": formatPath(cmd.Path), + }) + + if promptErr != nil { + return promptErr + } + + if !response { + cmd.UI.DisplayText("Access rule '{{.RuleName}}' has not been removed.", map[string]interface{}{ + "RuleName": ruleName, + }) + return nil + } + } + + cmd.UI.DisplayTextWithFlavor("Removing access rule {{.RuleName}} for route {{.Hostname}}.{{.Domain}}{{.Path}} as {{.User}}...", + map[string]interface{}{ + "RuleName": ruleName, + "Hostname": cmd.Hostname, + "Domain": domainName, + "Path": formatPath(cmd.Path), + "User": user.Name, + }) + + warnings, err := cmd.Actor.DeleteAccessRule(ruleName, domainName, cmd.Hostname, cmd.Path) + cmd.UI.DisplayWarnings(warnings) + if err != nil { + return err + } + + cmd.UI.DisplayOK() + + return nil +} diff --git a/command/v7/v7fakes/fake_actor.go b/command/v7/v7fakes/fake_actor.go index e8f1915a932..b3093ad655e 100644 --- a/command/v7/v7fakes/fake_actor.go +++ b/command/v7/v7fakes/fake_actor.go @@ -22,6 +22,23 @@ import ( ) type FakeActor struct { + AddAccessRuleStub func(string, string, string, string, string) (v7action.Warnings, error) + addAccessRuleMutex sync.RWMutex + addAccessRuleArgsForCall []struct { + arg1 string + arg2 string + arg3 string + arg4 string + arg5 string + } + addAccessRuleReturns struct { + result1 v7action.Warnings + result2 error + } + addAccessRuleReturnsOnCall map[int]struct { + result1 v7action.Warnings + result2 error + } ApplyOrganizationQuotaByNameStub func(string, string) (v7action.Warnings, error) applyOrganizationQuotaByNameMutex sync.RWMutex applyOrganizationQuotaByNameArgsForCall []struct { @@ -357,11 +374,13 @@ type FakeActor struct { result1 v7action.Warnings result2 error } - CreatePrivateDomainStub func(string, string) (v7action.Warnings, error) + CreatePrivateDomainStub func(string, string, bool, string) (v7action.Warnings, error) createPrivateDomainMutex sync.RWMutex createPrivateDomainArgsForCall []struct { arg1 string arg2 string + arg3 bool + arg4 string } createPrivateDomainReturns struct { result1 v7action.Warnings @@ -463,12 +482,14 @@ type FakeActor struct { result2 v7action.Warnings result3 error } - CreateSharedDomainStub func(string, bool, string) (v7action.Warnings, error) + CreateSharedDomainStub func(string, bool, string, bool, string) (v7action.Warnings, error) createSharedDomainMutex sync.RWMutex createSharedDomainArgsForCall []struct { arg1 string arg2 bool arg3 string + arg4 bool + arg5 string } createSharedDomainReturns struct { result1 v7action.Warnings @@ -557,6 +578,22 @@ type FakeActor struct { result1 v7action.Warnings result2 error } + DeleteAccessRuleStub func(string, string, string, string) (v7action.Warnings, error) + deleteAccessRuleMutex sync.RWMutex + deleteAccessRuleArgsForCall []struct { + arg1 string + arg2 string + arg3 string + arg4 string + } + deleteAccessRuleReturns struct { + result1 v7action.Warnings + result2 error + } + deleteAccessRuleReturnsOnCall map[int]struct { + result1 v7action.Warnings + result2 error + } DeleteApplicationByNameAndSpaceStub func(string, string, bool) (v7action.Warnings, error) deleteApplicationByNameAndSpaceMutex sync.RWMutex deleteApplicationByNameAndSpaceArgsForCall []struct { @@ -989,6 +1026,42 @@ type FakeActor struct { result1 v7action.Warnings result2 error } + GetAccessRulesByRouteStub func(string, string, string) ([]resources.AccessRule, v7action.Warnings, error) + getAccessRulesByRouteMutex sync.RWMutex + getAccessRulesByRouteArgsForCall []struct { + arg1 string + arg2 string + arg3 string + } + getAccessRulesByRouteReturns struct { + result1 []resources.AccessRule + result2 v7action.Warnings + result3 error + } + getAccessRulesByRouteReturnsOnCall map[int]struct { + result1 []resources.AccessRule + result2 v7action.Warnings + result3 error + } + GetAccessRulesForSpaceStub func(string, string, string, string, string) ([]v7action.AccessRuleWithRoute, v7action.Warnings, error) + getAccessRulesForSpaceMutex sync.RWMutex + getAccessRulesForSpaceArgsForCall []struct { + arg1 string + arg2 string + arg3 string + arg4 string + arg5 string + } + getAccessRulesForSpaceReturns struct { + result1 []v7action.AccessRuleWithRoute + result2 v7action.Warnings + result3 error + } + getAccessRulesForSpaceReturnsOnCall map[int]struct { + result1 []v7action.AccessRuleWithRoute + result2 v7action.Warnings + result3 error + } GetAppFeatureStub func(string, string) (resources.ApplicationFeature, v7action.Warnings, error) getAppFeatureMutex sync.RWMutex getAppFeatureArgsForCall []struct { @@ -3780,6 +3853,74 @@ type FakeActor struct { invocationsMutex sync.RWMutex } +func (fake *FakeActor) AddAccessRule(arg1 string, arg2 string, arg3 string, arg4 string, arg5 string) (v7action.Warnings, error) { + fake.addAccessRuleMutex.Lock() + ret, specificReturn := fake.addAccessRuleReturnsOnCall[len(fake.addAccessRuleArgsForCall)] + fake.addAccessRuleArgsForCall = append(fake.addAccessRuleArgsForCall, struct { + arg1 string + arg2 string + arg3 string + arg4 string + arg5 string + }{arg1, arg2, arg3, arg4, arg5}) + stub := fake.AddAccessRuleStub + fakeReturns := fake.addAccessRuleReturns + fake.recordInvocation("AddAccessRule", []interface{}{arg1, arg2, arg3, arg4, arg5}) + fake.addAccessRuleMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3, arg4, arg5) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeActor) AddAccessRuleCallCount() int { + fake.addAccessRuleMutex.RLock() + defer fake.addAccessRuleMutex.RUnlock() + return len(fake.addAccessRuleArgsForCall) +} + +func (fake *FakeActor) AddAccessRuleCalls(stub func(string, string, string, string, string) (v7action.Warnings, error)) { + fake.addAccessRuleMutex.Lock() + defer fake.addAccessRuleMutex.Unlock() + fake.AddAccessRuleStub = stub +} + +func (fake *FakeActor) AddAccessRuleArgsForCall(i int) (string, string, string, string, string) { + fake.addAccessRuleMutex.RLock() + defer fake.addAccessRuleMutex.RUnlock() + argsForCall := fake.addAccessRuleArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5 +} + +func (fake *FakeActor) AddAccessRuleReturns(result1 v7action.Warnings, result2 error) { + fake.addAccessRuleMutex.Lock() + defer fake.addAccessRuleMutex.Unlock() + fake.AddAccessRuleStub = nil + fake.addAccessRuleReturns = struct { + result1 v7action.Warnings + result2 error + }{result1, result2} +} + +func (fake *FakeActor) AddAccessRuleReturnsOnCall(i int, result1 v7action.Warnings, result2 error) { + fake.addAccessRuleMutex.Lock() + defer fake.addAccessRuleMutex.Unlock() + fake.AddAccessRuleStub = nil + if fake.addAccessRuleReturnsOnCall == nil { + fake.addAccessRuleReturnsOnCall = make(map[int]struct { + result1 v7action.Warnings + result2 error + }) + } + fake.addAccessRuleReturnsOnCall[i] = struct { + result1 v7action.Warnings + result2 error + }{result1, result2} +} + func (fake *FakeActor) ApplyOrganizationQuotaByName(arg1 string, arg2 string) (v7action.Warnings, error) { fake.applyOrganizationQuotaByNameMutex.Lock() ret, specificReturn := fake.applyOrganizationQuotaByNameReturnsOnCall[len(fake.applyOrganizationQuotaByNameArgsForCall)] @@ -5273,19 +5414,21 @@ func (fake *FakeActor) CreateOrganizationQuotaReturnsOnCall(i int, result1 v7act }{result1, result2} } -func (fake *FakeActor) CreatePrivateDomain(arg1 string, arg2 string) (v7action.Warnings, error) { +func (fake *FakeActor) CreatePrivateDomain(arg1 string, arg2 string, arg3 bool, arg4 string) (v7action.Warnings, error) { fake.createPrivateDomainMutex.Lock() ret, specificReturn := fake.createPrivateDomainReturnsOnCall[len(fake.createPrivateDomainArgsForCall)] fake.createPrivateDomainArgsForCall = append(fake.createPrivateDomainArgsForCall, struct { arg1 string arg2 string - }{arg1, arg2}) + arg3 bool + arg4 string + }{arg1, arg2, arg3, arg4}) stub := fake.CreatePrivateDomainStub fakeReturns := fake.createPrivateDomainReturns - fake.recordInvocation("CreatePrivateDomain", []interface{}{arg1, arg2}) + fake.recordInvocation("CreatePrivateDomain", []interface{}{arg1, arg2, arg3, arg4}) fake.createPrivateDomainMutex.Unlock() if stub != nil { - return stub(arg1, arg2) + return stub(arg1, arg2, arg3, arg4) } if specificReturn { return ret.result1, ret.result2 @@ -5299,17 +5442,17 @@ func (fake *FakeActor) CreatePrivateDomainCallCount() int { return len(fake.createPrivateDomainArgsForCall) } -func (fake *FakeActor) CreatePrivateDomainCalls(stub func(string, string) (v7action.Warnings, error)) { +func (fake *FakeActor) CreatePrivateDomainCalls(stub func(string, string, bool, string) (v7action.Warnings, error)) { fake.createPrivateDomainMutex.Lock() defer fake.createPrivateDomainMutex.Unlock() fake.CreatePrivateDomainStub = stub } -func (fake *FakeActor) CreatePrivateDomainArgsForCall(i int) (string, string) { +func (fake *FakeActor) CreatePrivateDomainArgsForCall(i int) (string, string, bool, string) { fake.createPrivateDomainMutex.RLock() defer fake.createPrivateDomainMutex.RUnlock() argsForCall := fake.createPrivateDomainArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 } func (fake *FakeActor) CreatePrivateDomainReturns(result1 v7action.Warnings, result2 error) { @@ -5740,20 +5883,22 @@ func (fake *FakeActor) CreateServiceKeyReturnsOnCall(i int, result1 chan v7actio }{result1, result2, result3} } -func (fake *FakeActor) CreateSharedDomain(arg1 string, arg2 bool, arg3 string) (v7action.Warnings, error) { +func (fake *FakeActor) CreateSharedDomain(arg1 string, arg2 bool, arg3 string, arg4 bool, arg5 string) (v7action.Warnings, error) { fake.createSharedDomainMutex.Lock() ret, specificReturn := fake.createSharedDomainReturnsOnCall[len(fake.createSharedDomainArgsForCall)] fake.createSharedDomainArgsForCall = append(fake.createSharedDomainArgsForCall, struct { arg1 string arg2 bool arg3 string - }{arg1, arg2, arg3}) + arg4 bool + arg5 string + }{arg1, arg2, arg3, arg4, arg5}) stub := fake.CreateSharedDomainStub fakeReturns := fake.createSharedDomainReturns - fake.recordInvocation("CreateSharedDomain", []interface{}{arg1, arg2, arg3}) + fake.recordInvocation("CreateSharedDomain", []interface{}{arg1, arg2, arg3, arg4, arg5}) fake.createSharedDomainMutex.Unlock() if stub != nil { - return stub(arg1, arg2, arg3) + return stub(arg1, arg2, arg3, arg4, arg5) } if specificReturn { return ret.result1, ret.result2 @@ -5767,17 +5912,17 @@ func (fake *FakeActor) CreateSharedDomainCallCount() int { return len(fake.createSharedDomainArgsForCall) } -func (fake *FakeActor) CreateSharedDomainCalls(stub func(string, bool, string) (v7action.Warnings, error)) { +func (fake *FakeActor) CreateSharedDomainCalls(stub func(string, bool, string, bool, string) (v7action.Warnings, error)) { fake.createSharedDomainMutex.Lock() defer fake.createSharedDomainMutex.Unlock() fake.CreateSharedDomainStub = stub } -func (fake *FakeActor) CreateSharedDomainArgsForCall(i int) (string, bool, string) { +func (fake *FakeActor) CreateSharedDomainArgsForCall(i int) (string, bool, string, bool, string) { fake.createSharedDomainMutex.RLock() defer fake.createSharedDomainMutex.RUnlock() argsForCall := fake.createSharedDomainArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5 } func (fake *FakeActor) CreateSharedDomainReturns(result1 v7action.Warnings, result2 error) { @@ -6142,6 +6287,73 @@ func (fake *FakeActor) CreateUserProvidedServiceInstanceReturnsOnCall(i int, res }{result1, result2} } +func (fake *FakeActor) DeleteAccessRule(arg1 string, arg2 string, arg3 string, arg4 string) (v7action.Warnings, error) { + fake.deleteAccessRuleMutex.Lock() + ret, specificReturn := fake.deleteAccessRuleReturnsOnCall[len(fake.deleteAccessRuleArgsForCall)] + fake.deleteAccessRuleArgsForCall = append(fake.deleteAccessRuleArgsForCall, struct { + arg1 string + arg2 string + arg3 string + arg4 string + }{arg1, arg2, arg3, arg4}) + stub := fake.DeleteAccessRuleStub + fakeReturns := fake.deleteAccessRuleReturns + fake.recordInvocation("DeleteAccessRule", []interface{}{arg1, arg2, arg3, arg4}) + fake.deleteAccessRuleMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3, arg4) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeActor) DeleteAccessRuleCallCount() int { + fake.deleteAccessRuleMutex.RLock() + defer fake.deleteAccessRuleMutex.RUnlock() + return len(fake.deleteAccessRuleArgsForCall) +} + +func (fake *FakeActor) DeleteAccessRuleCalls(stub func(string, string, string, string) (v7action.Warnings, error)) { + fake.deleteAccessRuleMutex.Lock() + defer fake.deleteAccessRuleMutex.Unlock() + fake.DeleteAccessRuleStub = stub +} + +func (fake *FakeActor) DeleteAccessRuleArgsForCall(i int) (string, string, string, string) { + fake.deleteAccessRuleMutex.RLock() + defer fake.deleteAccessRuleMutex.RUnlock() + argsForCall := fake.deleteAccessRuleArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 +} + +func (fake *FakeActor) DeleteAccessRuleReturns(result1 v7action.Warnings, result2 error) { + fake.deleteAccessRuleMutex.Lock() + defer fake.deleteAccessRuleMutex.Unlock() + fake.DeleteAccessRuleStub = nil + fake.deleteAccessRuleReturns = struct { + result1 v7action.Warnings + result2 error + }{result1, result2} +} + +func (fake *FakeActor) DeleteAccessRuleReturnsOnCall(i int, result1 v7action.Warnings, result2 error) { + fake.deleteAccessRuleMutex.Lock() + defer fake.deleteAccessRuleMutex.Unlock() + fake.DeleteAccessRuleStub = nil + if fake.deleteAccessRuleReturnsOnCall == nil { + fake.deleteAccessRuleReturnsOnCall = make(map[int]struct { + result1 v7action.Warnings + result2 error + }) + } + fake.deleteAccessRuleReturnsOnCall[i] = struct { + result1 v7action.Warnings + result2 error + }{result1, result2} +} + func (fake *FakeActor) DeleteApplicationByNameAndSpace(arg1 string, arg2 string, arg3 bool) (v7action.Warnings, error) { fake.deleteApplicationByNameAndSpaceMutex.Lock() ret, specificReturn := fake.deleteApplicationByNameAndSpaceReturnsOnCall[len(fake.deleteApplicationByNameAndSpaceArgsForCall)] @@ -8068,6 +8280,146 @@ func (fake *FakeActor) EntitleIsolationSegmentToOrganizationByNameReturnsOnCall( }{result1, result2} } +func (fake *FakeActor) GetAccessRulesByRoute(arg1 string, arg2 string, arg3 string) ([]resources.AccessRule, v7action.Warnings, error) { + fake.getAccessRulesByRouteMutex.Lock() + ret, specificReturn := fake.getAccessRulesByRouteReturnsOnCall[len(fake.getAccessRulesByRouteArgsForCall)] + fake.getAccessRulesByRouteArgsForCall = append(fake.getAccessRulesByRouteArgsForCall, struct { + arg1 string + arg2 string + arg3 string + }{arg1, arg2, arg3}) + stub := fake.GetAccessRulesByRouteStub + fakeReturns := fake.getAccessRulesByRouteReturns + fake.recordInvocation("GetAccessRulesByRoute", []interface{}{arg1, arg2, arg3}) + fake.getAccessRulesByRouteMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3) + } + if specificReturn { + return ret.result1, ret.result2, ret.result3 + } + return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 +} + +func (fake *FakeActor) GetAccessRulesByRouteCallCount() int { + fake.getAccessRulesByRouteMutex.RLock() + defer fake.getAccessRulesByRouteMutex.RUnlock() + return len(fake.getAccessRulesByRouteArgsForCall) +} + +func (fake *FakeActor) GetAccessRulesByRouteCalls(stub func(string, string, string) ([]resources.AccessRule, v7action.Warnings, error)) { + fake.getAccessRulesByRouteMutex.Lock() + defer fake.getAccessRulesByRouteMutex.Unlock() + fake.GetAccessRulesByRouteStub = stub +} + +func (fake *FakeActor) GetAccessRulesByRouteArgsForCall(i int) (string, string, string) { + fake.getAccessRulesByRouteMutex.RLock() + defer fake.getAccessRulesByRouteMutex.RUnlock() + argsForCall := fake.getAccessRulesByRouteArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *FakeActor) GetAccessRulesByRouteReturns(result1 []resources.AccessRule, result2 v7action.Warnings, result3 error) { + fake.getAccessRulesByRouteMutex.Lock() + defer fake.getAccessRulesByRouteMutex.Unlock() + fake.GetAccessRulesByRouteStub = nil + fake.getAccessRulesByRouteReturns = struct { + result1 []resources.AccessRule + result2 v7action.Warnings + result3 error + }{result1, result2, result3} +} + +func (fake *FakeActor) GetAccessRulesByRouteReturnsOnCall(i int, result1 []resources.AccessRule, result2 v7action.Warnings, result3 error) { + fake.getAccessRulesByRouteMutex.Lock() + defer fake.getAccessRulesByRouteMutex.Unlock() + fake.GetAccessRulesByRouteStub = nil + if fake.getAccessRulesByRouteReturnsOnCall == nil { + fake.getAccessRulesByRouteReturnsOnCall = make(map[int]struct { + result1 []resources.AccessRule + result2 v7action.Warnings + result3 error + }) + } + fake.getAccessRulesByRouteReturnsOnCall[i] = struct { + result1 []resources.AccessRule + result2 v7action.Warnings + result3 error + }{result1, result2, result3} +} + +func (fake *FakeActor) GetAccessRulesForSpace(arg1 string, arg2 string, arg3 string, arg4 string, arg5 string) ([]v7action.AccessRuleWithRoute, v7action.Warnings, error) { + fake.getAccessRulesForSpaceMutex.Lock() + ret, specificReturn := fake.getAccessRulesForSpaceReturnsOnCall[len(fake.getAccessRulesForSpaceArgsForCall)] + fake.getAccessRulesForSpaceArgsForCall = append(fake.getAccessRulesForSpaceArgsForCall, struct { + arg1 string + arg2 string + arg3 string + arg4 string + arg5 string + }{arg1, arg2, arg3, arg4, arg5}) + stub := fake.GetAccessRulesForSpaceStub + fakeReturns := fake.getAccessRulesForSpaceReturns + fake.recordInvocation("GetAccessRulesForSpace", []interface{}{arg1, arg2, arg3, arg4, arg5}) + fake.getAccessRulesForSpaceMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3, arg4, arg5) + } + if specificReturn { + return ret.result1, ret.result2, ret.result3 + } + return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 +} + +func (fake *FakeActor) GetAccessRulesForSpaceCallCount() int { + fake.getAccessRulesForSpaceMutex.RLock() + defer fake.getAccessRulesForSpaceMutex.RUnlock() + return len(fake.getAccessRulesForSpaceArgsForCall) +} + +func (fake *FakeActor) GetAccessRulesForSpaceCalls(stub func(string, string, string, string, string) ([]v7action.AccessRuleWithRoute, v7action.Warnings, error)) { + fake.getAccessRulesForSpaceMutex.Lock() + defer fake.getAccessRulesForSpaceMutex.Unlock() + fake.GetAccessRulesForSpaceStub = stub +} + +func (fake *FakeActor) GetAccessRulesForSpaceArgsForCall(i int) (string, string, string, string, string) { + fake.getAccessRulesForSpaceMutex.RLock() + defer fake.getAccessRulesForSpaceMutex.RUnlock() + argsForCall := fake.getAccessRulesForSpaceArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5 +} + +func (fake *FakeActor) GetAccessRulesForSpaceReturns(result1 []v7action.AccessRuleWithRoute, result2 v7action.Warnings, result3 error) { + fake.getAccessRulesForSpaceMutex.Lock() + defer fake.getAccessRulesForSpaceMutex.Unlock() + fake.GetAccessRulesForSpaceStub = nil + fake.getAccessRulesForSpaceReturns = struct { + result1 []v7action.AccessRuleWithRoute + result2 v7action.Warnings + result3 error + }{result1, result2, result3} +} + +func (fake *FakeActor) GetAccessRulesForSpaceReturnsOnCall(i int, result1 []v7action.AccessRuleWithRoute, result2 v7action.Warnings, result3 error) { + fake.getAccessRulesForSpaceMutex.Lock() + defer fake.getAccessRulesForSpaceMutex.Unlock() + fake.GetAccessRulesForSpaceStub = nil + if fake.getAccessRulesForSpaceReturnsOnCall == nil { + fake.getAccessRulesForSpaceReturnsOnCall = make(map[int]struct { + result1 []v7action.AccessRuleWithRoute + result2 v7action.Warnings + result3 error + }) + } + fake.getAccessRulesForSpaceReturnsOnCall[i] = struct { + result1 []v7action.AccessRuleWithRoute + result2 v7action.Warnings + result3 error + }{result1, result2, result3} +} + func (fake *FakeActor) GetAppFeature(arg1 string, arg2 string) (resources.ApplicationFeature, v7action.Warnings, error) { fake.getAppFeatureMutex.Lock() ret, specificReturn := fake.getAppFeatureReturnsOnCall[len(fake.getAppFeatureArgsForCall)] diff --git a/resources/access_rule_resource.go b/resources/access_rule_resource.go new file mode 100644 index 00000000000..6ccf5b34ad9 --- /dev/null +++ b/resources/access_rule_resource.go @@ -0,0 +1,84 @@ +package resources + +import ( + "encoding/json" + "time" + + "code.cloudfoundry.org/cli/v9/api/cloudcontroller" +) + +type AccessRule struct { + GUID string `json:"guid,omitempty"` + CreatedAt *time.Time `json:"created_at,omitempty"` + UpdatedAt *time.Time `json:"updated_at,omitempty"` + Name string `json:"name"` + Selector string `json:"selector"` + RouteGUID string `json:"-"` + + // Metadata is used for custom tagging of API resources + Metadata *Metadata `json:"metadata,omitempty"` +} + +func (a AccessRule) MarshalJSON() ([]byte, error) { + type alias struct { + GUID string `json:"guid,omitempty"` + CreatedAt *time.Time `json:"created_at,omitempty"` + UpdatedAt *time.Time `json:"updated_at,omitempty"` + Name string `json:"name"` + Selector string `json:"selector"` + Metadata *Metadata `json:"metadata,omitempty"` + + Relationships struct { + Route struct { + Data struct { + GUID string `json:"guid"` + } `json:"data"` + } `json:"route"` + } `json:"relationships"` + } + + var aliasData alias + aliasData.GUID = a.GUID + aliasData.CreatedAt = a.CreatedAt + aliasData.UpdatedAt = a.UpdatedAt + aliasData.Name = a.Name + aliasData.Selector = a.Selector + aliasData.Metadata = a.Metadata + aliasData.Relationships.Route.Data.GUID = a.RouteGUID + + return json.Marshal(aliasData) +} + +func (a *AccessRule) UnmarshalJSON(data []byte) error { + var alias struct { + GUID string `json:"guid,omitempty"` + CreatedAt *time.Time `json:"created_at,omitempty"` + UpdatedAt *time.Time `json:"updated_at,omitempty"` + Name string `json:"name"` + Selector string `json:"selector"` + Metadata *Metadata `json:"metadata,omitempty"` + + Relationships struct { + Route struct { + Data struct { + GUID string `json:"guid,omitempty"` + } `json:"data,omitempty"` + } `json:"route,omitempty"` + } `json:"relationships,omitempty"` + } + + err := cloudcontroller.DecodeJSON(data, &alias) + if err != nil { + return err + } + + a.GUID = alias.GUID + a.CreatedAt = alias.CreatedAt + a.UpdatedAt = alias.UpdatedAt + a.Name = alias.Name + a.Selector = alias.Selector + a.RouteGUID = alias.Relationships.Route.Data.GUID + a.Metadata = alias.Metadata + + return nil +} diff --git a/resources/access_rule_resource_test.go b/resources/access_rule_resource_test.go new file mode 100644 index 00000000000..52e3a9b5110 --- /dev/null +++ b/resources/access_rule_resource_test.go @@ -0,0 +1,69 @@ +package resources_test + +import ( + "encoding/json" + "testing" + + "code.cloudfoundry.org/cli/v9/resources" + . "github.com/onsi/ginkgo/v2" + . "github.com/onsi/gomega" +) + +func TestAccessRuleResource(t *testing.T) { + RegisterFailHandler(Fail) + RunSpecs(t, "AccessRule Resource Suite") +} + +var _ = Describe("AccessRule", func() { + Describe("MarshalJSON", func() { + It("marshals the access rule with relationships", func() { + rule := resources.AccessRule{ + Name: "allow-backend", + Selector: "cf:app:some-app-guid", + RouteGUID: "some-route-guid", + } + + data, err := json.Marshal(rule) + Expect(err).NotTo(HaveOccurred()) + + var result map[string]interface{} + err = json.Unmarshal(data, &result) + Expect(err).NotTo(HaveOccurred()) + + Expect(result["name"]).To(Equal("allow-backend")) + Expect(result["selector"]).To(Equal("cf:app:some-app-guid")) + Expect(result["relationships"]).NotTo(BeNil()) + + relationships := result["relationships"].(map[string]interface{}) + route := relationships["route"].(map[string]interface{}) + routeData := route["data"].(map[string]interface{}) + Expect(routeData["guid"]).To(Equal("some-route-guid")) + }) + }) + + Describe("UnmarshalJSON", func() { + It("unmarshals the access rule from relationships", func() { + jsonData := `{ + "guid": "some-guid", + "name": "test-rule", + "selector": "cf:app:app-guid", + "relationships": { + "route": { + "data": { + "guid": "route-guid-123" + } + } + } + }` + + var rule resources.AccessRule + err := json.Unmarshal([]byte(jsonData), &rule) + Expect(err).NotTo(HaveOccurred()) + + Expect(rule.GUID).To(Equal("some-guid")) + Expect(rule.Name).To(Equal("test-rule")) + Expect(rule.Selector).To(Equal("cf:app:app-guid")) + Expect(rule.RouteGUID).To(Equal("route-guid-123")) + }) + }) +}) diff --git a/resources/domain_resource.go b/resources/domain_resource.go index 1a032a78b01..44841048165 100644 --- a/resources/domain_resource.go +++ b/resources/domain_resource.go @@ -6,12 +6,14 @@ import ( ) type Domain struct { - GUID string `json:"guid,omitempty"` - Name string `json:"name"` - Internal types.NullBool `json:"internal,omitempty"` - OrganizationGUID string `jsonry:"relationships.organization.data.guid,omitempty"` - RouterGroup string `jsonry:"router_group.guid,omitempty"` - Protocols []string `jsonry:"supported_protocols,omitempty"` + GUID string `json:"guid,omitempty"` + Name string `json:"name"` + Internal types.NullBool `json:"internal,omitempty"` + OrganizationGUID string `jsonry:"relationships.organization.data.guid,omitempty"` + RouterGroup string `jsonry:"router_group.guid,omitempty"` + Protocols []string `jsonry:"supported_protocols,omitempty"` + EnforceAccessRules types.NullBool `json:"enforce_access_rules,omitempty"` + AccessRulesScope string `json:"access_rules_scope,omitempty"` // Metadata is used for custom tagging of API resources Metadata *Metadata `json:"metadata,omitempty"` @@ -19,12 +21,14 @@ type Domain struct { func (d Domain) MarshalJSON() ([]byte, error) { type domainWithBoolPointer struct { - GUID string `jsonry:"guid,omitempty"` - Name string `jsonry:"name"` - Internal *bool `jsonry:"internal,omitempty"` - OrganizationGUID string `jsonry:"relationships.organization.data.guid,omitempty"` - RouterGroup string `jsonry:"router_group.guid,omitempty"` - Protocols []string `jsonry:"supported_protocols,omitempty"` + GUID string `jsonry:"guid,omitempty"` + Name string `jsonry:"name"` + Internal *bool `jsonry:"internal,omitempty"` + OrganizationGUID string `jsonry:"relationships.organization.data.guid,omitempty"` + RouterGroup string `jsonry:"router_group.guid,omitempty"` + Protocols []string `jsonry:"supported_protocols,omitempty"` + EnforceAccessRules *bool `jsonry:"enforce_access_rules,omitempty"` + AccessRulesScope string `jsonry:"access_rules_scope,omitempty"` } clone := domainWithBoolPointer{ @@ -33,11 +37,15 @@ func (d Domain) MarshalJSON() ([]byte, error) { OrganizationGUID: d.OrganizationGUID, RouterGroup: d.RouterGroup, Protocols: d.Protocols, + AccessRulesScope: d.AccessRulesScope, } if d.Internal.IsSet { clone.Internal = &d.Internal.Value } + if d.EnforceAccessRules.IsSet { + clone.EnforceAccessRules = &d.EnforceAccessRules.Value + } return jsonry.Marshal(clone) } From 683d91bab37bd7177a6d63431a870a5668342721 Mon Sep 17 00:00:00 2001 From: rkoster Date: Wed, 15 Apr 2026 08:20:07 +0000 Subject: [PATCH 2/4] Remove access rule names per RFC updates Per RFC commits 882b69a and 11752f2, access rules no longer have user-provided names. They are identified by their selector only, with labels/annotations used for metadata instead. Changes: - Removed RULE_NAME argument from add-access-rule command - Removed Name field from AccessRule API resource - Updated access-rules list to show 4 columns (route, selector, scope, source) - SourceName now represents resolved app/space/org name from selector - Updated remove-access-rule to use --selector flag instead of rule name - Renamed DeleteAccessRule() to DeleteAccessRuleBySelector() - Updated all tests to remove Name field references All tests passing. --- .../access_rule_not_found_error.go | 4 +- actor/v7action/access_rule.go | 14 +-- actor/v7action/access_rule_test.go | 79 ++++++++-------- command/flag/arguments.go | 6 +- command/v7/access_rules_command.go | 2 - command/v7/access_rules_command_test.go | 28 +++--- command/v7/actor.go | 4 +- command/v7/add_access_rule_command.go | 12 +-- command/v7/add_access_rule_command_test.go | 31 +++---- command/v7/remove_access_rule_command.go | 22 +++-- command/v7/v7fakes/fake_actor.go | 92 +++++++++---------- resources/access_rule_resource.go | 5 - 12 files changed, 134 insertions(+), 165 deletions(-) diff --git a/actor/actionerror/access_rule_not_found_error.go b/actor/actionerror/access_rule_not_found_error.go index bf5710421e5..02fc1d6c57b 100644 --- a/actor/actionerror/access_rule_not_found_error.go +++ b/actor/actionerror/access_rule_not_found_error.go @@ -3,9 +3,9 @@ package actionerror import "fmt" type AccessRuleNotFoundError struct { - Name string + Selector string } func (e AccessRuleNotFoundError) Error() string { - return fmt.Sprintf("Access rule '%s' not found.", e.Name) + return fmt.Sprintf("Access rule with selector '%s' not found.", e.Selector) } diff --git a/actor/v7action/access_rule.go b/actor/v7action/access_rule.go index e74bd789497..909fc8dffdc 100644 --- a/actor/v7action/access_rule.go +++ b/actor/v7action/access_rule.go @@ -6,7 +6,7 @@ import ( "code.cloudfoundry.org/cli/v9/resources" ) -func (actor Actor) AddAccessRule(ruleName, domainName, selector, hostname, path string) (Warnings, error) { +func (actor Actor) AddAccessRule(domainName, selector, hostname, path string) (Warnings, error) { allWarnings := Warnings{} // Get the domain to ensure it exists and supports access rules @@ -35,7 +35,6 @@ func (actor Actor) AddAccessRule(ruleName, domainName, selector, hostname, path // Create the access rule accessRule := resources.AccessRule{ - Name: ruleName, Selector: selector, RouteGUID: route.GUID, } @@ -87,7 +86,7 @@ func (actor Actor) GetAccessRulesByRoute(domainName, hostname, path string) ([]r return rules, allWarnings, err } -func (actor Actor) DeleteAccessRule(ruleName, domainName, hostname, path string) (Warnings, error) { +func (actor Actor) DeleteAccessRuleBySelector(domainName, selector, hostname, path string) (Warnings, error) { allWarnings := Warnings{} // Get the domain @@ -114,7 +113,7 @@ func (actor Actor) DeleteAccessRule(ruleName, domainName, hostname, path string) route := routes[0] - // Get access rules for this route to find the one with matching name + // Get access rules for this route to find the one with matching selector accessRules, _, apiWarnings, err := actor.CloudControllerClient.GetAccessRules( ccv3.Query{Key: ccv3.RouteGUIDFilter, Values: []string{route.GUID}}, ) @@ -123,17 +122,17 @@ func (actor Actor) DeleteAccessRule(ruleName, domainName, hostname, path string) return allWarnings, err } - // Find the rule with matching name + // Find the rule with matching selector var ruleGUID string for _, rule := range accessRules { - if rule.Name == ruleName { + if rule.Selector == selector { ruleGUID = rule.GUID break } } if ruleGUID == "" { - return allWarnings, actionerror.AccessRuleNotFoundError{Name: ruleName} + return allWarnings, actionerror.AccessRuleNotFoundError{Selector: selector} } // Delete the access rule @@ -143,6 +142,7 @@ func (actor Actor) DeleteAccessRule(ruleName, domainName, hostname, path string) return allWarnings, err } + // GetRoutesByDomain gets routes for a domain with optional hostname and path filters func (actor Actor) GetRoutesByDomain(domainGUID, hostname, path string) ([]resources.Route, Warnings, error) { queries := []ccv3.Query{ diff --git a/actor/v7action/access_rule_test.go b/actor/v7action/access_rule_test.go index 64c4fc52343..38b81bb67b4 100644 --- a/actor/v7action/access_rule_test.go +++ b/actor/v7action/access_rule_test.go @@ -122,13 +122,12 @@ var _ = Describe("Access Rule Actions", func() { "get-domain-warning-1", "get-domain-warning-2", "get-app-warning", - )) + )) - Expect(results).To(HaveLen(2)) + Expect(results).To(HaveLen(2)) - // First rule + // First rule Expect(results[0].GUID).To(Equal("rule-guid-1")) - Expect(results[0].Name).To(Equal("rule-1")) Expect(results[0].Selector).To(Equal("cf:app:app-guid-1")) Expect(results[0].Route.GUID).To(Equal("route-guid-1")) Expect(results[0].Route.Host).To(Equal("app1")) @@ -139,7 +138,6 @@ var _ = Describe("Access Rule Actions", func() { // Second rule Expect(results[1].GUID).To(Equal("rule-guid-2")) - Expect(results[1].Name).To(Equal("rule-2")) Expect(results[1].Selector).To(Equal("cf:any")) Expect(results[1].Route.GUID).To(Equal("route-guid-2")) Expect(results[1].Route.Host).To(Equal("app2")) @@ -498,8 +496,8 @@ var _ = Describe("Access Rule Actions", func() { It("returns the access rules", func() { Expect(executeErr).ToNot(HaveOccurred()) Expect(rules).To(HaveLen(2)) - Expect(rules[0].Name).To(Equal("rule-1")) - Expect(rules[1].Name).To(Equal("rule-2")) + Expect(rules[0].Selector).To(Equal("cf:app:app-guid-1")) + Expect(rules[1].Selector).To(Equal("cf:app:app-guid-2")) Expect(warnings).To(ConsistOf( "get-domains-warning", "get-routes-warning", @@ -538,7 +536,6 @@ var _ = Describe("Access Rule Actions", func() { Describe("AddAccessRule", func() { var ( - ruleName string domainName string selector string hostname string @@ -549,7 +546,6 @@ var _ = Describe("Access Rule Actions", func() { ) BeforeEach(func() { - ruleName = "my-rule" domainName = "example.com" selector = "cf:app:app-guid-1" hostname = "myapp" @@ -557,7 +553,7 @@ var _ = Describe("Access Rule Actions", func() { }) JustBeforeEach(func() { - warnings, executeErr = actor.AddAccessRule(ruleName, domainName, selector, hostname, path) + warnings, executeErr = actor.AddAccessRule(domainName, selector, hostname, path) }) When("creating the access rule succeeds", func() { @@ -594,16 +590,15 @@ var _ = Describe("Access Rule Actions", func() { Expect(executeErr).ToNot(HaveOccurred()) Expect(warnings).To(ConsistOf( "get-domains-warning", - "get-routes-warning", - "create-rule-warning", - )) - - Expect(fakeCloudControllerClient.CreateAccessRuleCallCount()).To(Equal(1)) - rule := fakeCloudControllerClient.CreateAccessRuleArgsForCall(0) - Expect(rule.Name).To(Equal("my-rule")) - Expect(rule.Selector).To(Equal("cf:app:app-guid-1")) - Expect(rule.RouteGUID).To(Equal("route-guid-1")) - }) + "get-routes-warning", + "create-rule-warning", + )) + + Expect(fakeCloudControllerClient.CreateAccessRuleCallCount()).To(Equal(1)) + rule := fakeCloudControllerClient.CreateAccessRuleArgsForCall(0) + Expect(rule.Selector).To(Equal("cf:app:app-guid-1")) + Expect(rule.RouteGUID).To(Equal("route-guid-1")) + }) }) When("the route does not exist", func() { @@ -633,9 +628,9 @@ var _ = Describe("Access Rule Actions", func() { }) }) - Describe("DeleteAccessRule", func() { + Describe("DeleteAccessRuleBySelector", func() { var ( - ruleName string + selector string domainName string hostname string path string @@ -645,14 +640,14 @@ var _ = Describe("Access Rule Actions", func() { ) BeforeEach(func() { - ruleName = "my-rule" + selector = "cf:any" domainName = "example.com" hostname = "myapp" path = "" }) JustBeforeEach(func() { - warnings, executeErr = actor.DeleteAccessRule(ruleName, domainName, hostname, path) + warnings, executeErr = actor.DeleteAccessRuleBySelector(domainName, selector, hostname, path) }) When("the access rule exists", func() { @@ -680,7 +675,7 @@ var _ = Describe("Access Rule Actions", func() { fakeCloudControllerClient.GetAccessRulesReturns( []resources.AccessRule{ - {GUID: "rule-guid-1", Name: "my-rule", Selector: "cf:any"}, + {GUID: "rule-guid-1", Selector: "cf:any"}, }, ccv3.IncludedResources{}, ccv3.Warnings{"get-access-rules-warning"}, @@ -732,24 +727,24 @@ var _ = Describe("Access Rule Actions", func() { nil, ) - fakeCloudControllerClient.GetAccessRulesReturns( - []resources.AccessRule{ - {GUID: "rule-guid-other", Name: "other-rule", Selector: "cf:any"}, - }, - ccv3.IncludedResources{}, - ccv3.Warnings{"get-access-rules-warning"}, - nil, - ) - }) + fakeCloudControllerClient.GetAccessRulesReturns( + []resources.AccessRule{ + {GUID: "rule-guid-other", Selector: "cf:app:other-guid"}, + }, + ccv3.IncludedResources{}, + ccv3.Warnings{"get-access-rules-warning"}, + nil, + ) + }) - It("returns an AccessRuleNotFoundError", func() { - Expect(executeErr).To(MatchError(actionerror.AccessRuleNotFoundError{Name: "my-rule"})) - Expect(warnings).To(ConsistOf( - "get-domains-warning", - "get-routes-warning", - "get-access-rules-warning", - )) - }) + It("returns an AccessRuleNotFoundError", func() { + Expect(executeErr).To(MatchError(actionerror.AccessRuleNotFoundError{Selector: "cf:any"})) + Expect(warnings).To(ConsistOf( + "get-domains-warning", + "get-routes-warning", + "get-access-rules-warning", + )) }) }) }) +}) diff --git a/command/flag/arguments.go b/command/flag/arguments.go index 84195b1d4e6..0afd5568955 100644 --- a/command/flag/arguments.go +++ b/command/flag/arguments.go @@ -415,11 +415,9 @@ type TaskArgs struct { } type AddAccessRuleArgs struct { - RuleName string `positional-arg-name:"RULE_NAME" required:"true" description:"The access rule name"` - Domain string `positional-arg-name:"DOMAIN" required:"true" description:"The domain name"` + Domain string `positional-arg-name:"DOMAIN" required:"true" description:"The domain name"` } type RemoveAccessRuleArgs struct { - RuleName string `positional-arg-name:"RULE_NAME" required:"true" description:"The access rule name"` - Domain string `positional-arg-name:"DOMAIN" required:"true" description:"The domain name"` + Domain string `positional-arg-name:"DOMAIN" required:"true" description:"The domain name"` } diff --git a/command/v7/access_rules_command.go b/command/v7/access_rules_command.go index 0b29c17e4d9..5148c801911 100644 --- a/command/v7/access_rules_command.go +++ b/command/v7/access_rules_command.go @@ -64,7 +64,6 @@ func (cmd AccessRulesCommand) Execute(args []string) error { // Build table data table := [][]string{ { - cmd.UI.TranslateText("name"), cmd.UI.TranslateText("route"), cmd.UI.TranslateText("selector"), cmd.UI.TranslateText("scope"), @@ -74,7 +73,6 @@ func (cmd AccessRulesCommand) Execute(args []string) error { for _, ruleWithRoute := range rulesWithRoutes { table = append(table, []string{ - ruleWithRoute.Name, formatRoute(ruleWithRoute.Route, ruleWithRoute.DomainName), ruleWithRoute.Selector, ruleWithRoute.ScopeType, diff --git a/command/v7/access_rules_command_test.go b/command/v7/access_rules_command_test.go index bf34d3ea2b9..6629be6c026 100644 --- a/command/v7/access_rules_command_test.go +++ b/command/v7/access_rules_command_test.go @@ -114,7 +114,6 @@ var _ = Describe("access-rules Command", func() { { AccessRule: resources.AccessRule{ GUID: "rule-guid-1", - Name: "rule-1", Selector: "cf:app:app-guid-1", }, Route: resources.Route{ @@ -129,7 +128,6 @@ var _ = Describe("access-rules Command", func() { { AccessRule: resources.AccessRule{ GUID: "rule-guid-2", - Name: "rule-2", Selector: "cf:any", }, Route: resources.Route{ @@ -139,7 +137,7 @@ var _ = Describe("access-rules Command", func() { }, DomainName: "test.com", ScopeType: "any", - SourceName: "(any app)", + SourceName: "", }, }, v7action.Warnings{"warning-1"}, nil) }) @@ -148,9 +146,9 @@ var _ = Describe("access-rules Command", func() { Expect(executeErr).ToNot(HaveOccurred()) Expect(testUI.Out).To(Say(`Getting access rules in org some-org / space some-space as steve\.\.\.`)) - Expect(testUI.Out).To(Say(`name\s+route\s+selector\s+scope\s+source`)) - Expect(testUI.Out).To(Say(`rule-1\s+myapp\.example\.com/api\s+cf:app:app-guid-1\s+my-app`)) - Expect(testUI.Out).To(Say(`rule-2\s+webapp\.test\.com\s+cf:any\s+\(any app\)`)) + Expect(testUI.Out).To(Say(`route\s+selector\s+scope\s+source`)) + Expect(testUI.Out).To(Say(`myapp\.example\.com/api\s+cf:app:app-guid-1\s+app\s+my-app`)) + Expect(testUI.Out).To(Say(`webapp\.test\.com\s+cf:any\s+any`)) Expect(testUI.Err).To(Say("warning-1")) @@ -185,7 +183,6 @@ var _ = Describe("access-rules Command", func() { { AccessRule: resources.AccessRule{ GUID: "rule-guid-1", - Name: "rule-1", Selector: "cf:any", }, Route: resources.Route{ @@ -194,7 +191,7 @@ var _ = Describe("access-rules Command", func() { }, DomainName: "example.com", ScopeType: "any", - SourceName: "(any app)", + SourceName: "", }, }, v7action.Warnings{}, nil) }) @@ -271,7 +268,6 @@ var _ = Describe("access-rules Command", func() { { AccessRule: resources.AccessRule{ GUID: "rule-guid-1", - Name: "filtered-rule", Selector: "cf:app:app-guid-1", }, Route: resources.Route{ @@ -302,8 +298,8 @@ var _ = Describe("access-rules Command", func() { Expect(executeErr).ToNot(HaveOccurred()) Expect(testUI.Out).To(Say(`Getting access rules in org some-org / space some-space as steve\.\.\.`)) - Expect(testUI.Out).To(Say(`name\s+route\s+selector\s+scope\s+source`)) - Expect(testUI.Out).To(Say(`filtered-rule\s+myapp\.example\.com/api\s+cf:app:app-guid-1\s+my-app`)) + Expect(testUI.Out).To(Say(`route\s+selector\s+scope\s+source`)) + Expect(testUI.Out).To(Say(`myapp\.example\.com/api\s+cf:app:app-guid-1\s+app\s+my-app`)) }) }) @@ -313,7 +309,6 @@ var _ = Describe("access-rules Command", func() { { AccessRule: resources.AccessRule{ GUID: "rule-guid-1", - Name: "no-host-rule", Selector: "cf:any", }, Route: resources.Route{ @@ -323,12 +318,11 @@ var _ = Describe("access-rules Command", func() { }, DomainName: "example.com", ScopeType: "any", - SourceName: "(any app)", + SourceName: "", }, { AccessRule: resources.AccessRule{ GUID: "rule-guid-2", - Name: "no-path-rule", Selector: "cf:any", }, Route: resources.Route{ @@ -338,7 +332,7 @@ var _ = Describe("access-rules Command", func() { }, DomainName: "test.com", ScopeType: "any", - SourceName: "(any app)", + SourceName: "", }, }, v7action.Warnings{}, nil) }) @@ -347,10 +341,10 @@ var _ = Describe("access-rules Command", func() { Expect(executeErr).ToNot(HaveOccurred()) // No host, with path: "example.com/api" - Expect(testUI.Out).To(Say(`no-host-rule\s+example\.com/api`)) + Expect(testUI.Out).To(Say(`example\.com/api`)) // With host, no path: "myapp.test.com" - Expect(testUI.Out).To(Say(`no-path-rule\s+myapp\.test\.com`)) + Expect(testUI.Out).To(Say(`myapp\.test\.com`)) }) }) }) diff --git a/command/v7/actor.go b/command/v7/actor.go index a5fecefc786..9c04eba1d7e 100644 --- a/command/v7/actor.go +++ b/command/v7/actor.go @@ -23,7 +23,7 @@ import ( type Actor interface { ApplyOrganizationQuotaByName(quotaName string, orgGUID string) (v7action.Warnings, error) ApplySpaceQuotaByName(quotaName string, spaceGUID string, orgGUID string) (v7action.Warnings, error) - AddAccessRule(ruleName, domainName, selector, hostname, path string) (v7action.Warnings, error) + AddAccessRule(domainName, selector, hostname, path string) (v7action.Warnings, error) AssignIsolationSegmentToSpaceByNameAndSpace(isolationSegmentName string, spaceGUID string) (v7action.Warnings, error) Authenticate(credentials map[string]string, origin string, grantType uaa.GrantType) error BindSecurityGroupToSpaces(securityGroupGUID string, spaces []resources.Space, lifecycle constant.SecurityGroupLifecycle) (v7action.Warnings, error) @@ -59,7 +59,7 @@ type Actor interface { CreateUser(username string, password string, origin string) (resources.User, v7action.Warnings, error) CreateUserProvidedServiceInstance(instance resources.ServiceInstance) (v7action.Warnings, error) DeleteApplicationByNameAndSpace(name, spaceGUID string, deleteRoutes bool) (v7action.Warnings, error) - DeleteAccessRule(ruleName, domainName, hostname, path string) (v7action.Warnings, error) + DeleteAccessRuleBySelector(domainName, selector, hostname, path string) (v7action.Warnings, error) DeleteBuildpackByNameAndStackAndLifecycle(buildpackName string, buildpackStack string, buildpackLifecycle string) (v7action.Warnings, error) DeleteDomain(domain resources.Domain) (v7action.Warnings, error) DeleteInstanceByApplicationNameSpaceProcessTypeAndIndex(appName string, spaceGUID string, processType string, instanceIndex int) (v7action.Warnings, error) diff --git a/command/v7/add_access_rule_command.go b/command/v7/add_access_rule_command.go index b3db3914811..ac386efd408 100644 --- a/command/v7/add_access_rule_command.go +++ b/command/v7/add_access_rule_command.go @@ -25,7 +25,7 @@ type AddAccessRuleCommand struct { // Advanced: raw selector flag Selector string `long:"selector" description:"Raw selector (cf:app:, cf:space:, cf:org:, or cf:any)"` - usage interface{} `usage:"CF_NAME add-access-rule RULE_NAME DOMAIN --hostname HOSTNAME [--source-app APP_NAME [--source-space SPACE_NAME] [--source-org ORG_NAME] | --source-space SPACE_NAME [--source-org ORG_NAME] | --source-org ORG_NAME | --source-any | --selector SELECTOR] [--path PATH]\n\nALLOW ACCESS TO A ROUTE:\n Create an access rule that allows specific apps, spaces, or orgs to access a route using mTLS authentication.\n\nEXAMPLES:\n # Allow the \"frontend-app\" (in current space) to access the backend route\n cf add-access-rule allow-frontend apps.identity --source-app frontend-app --hostname backend\n\n # Allow an app in a different space to access the route\n cf add-access-rule allow-other-space apps.identity --source-app api-client --source-space other-space --hostname backend\n\n # Allow an app in a different org to access the route\n cf add-access-rule allow-other-org apps.identity --source-app external-client --source-space external-space --source-org external-org --hostname backend\n\n # Allow all apps in the \"monitoring\" space to access the API metrics endpoint\n cf add-access-rule allow-monitoring apps.identity --source-space monitoring --hostname api --path /metrics\n\n # Allow all apps in a space in a different org\n cf add-access-rule allow-prod-space apps.identity --source-space prod-space --source-org prod-org --hostname api\n\n # Allow all apps in the \"platform\" org to access the route\n cf add-access-rule allow-platform-org apps.identity --source-org platform --hostname shared-api\n\n # Allow any authenticated app to access the public API\n cf add-access-rule allow-all apps.identity --source-any --hostname public-api\n\n # Use raw selector (advanced)\n cf add-access-rule allow-raw apps.identity --selector cf:app:d76446a1-f429-4444-8797-be2f78b75b08 --hostname backend"` + usage interface{} `usage:"CF_NAME add-access-rule DOMAIN --hostname HOSTNAME [--source-app APP_NAME [--source-space SPACE_NAME] [--source-org ORG_NAME] | --source-space SPACE_NAME [--source-org ORG_NAME] | --source-org ORG_NAME | --source-any | --selector SELECTOR] [--path PATH]\n\nALLOW ACCESS TO A ROUTE:\n Create an access rule that allows specific apps, spaces, or orgs to access a route using mTLS authentication.\n\nEXAMPLES:\n # Allow the \"frontend-app\" (in current space) to access the backend route\n cf add-access-rule apps.identity --source-app frontend-app --hostname backend\n\n # Allow an app in a different space to access the route\n cf add-access-rule apps.identity --source-app api-client --source-space other-space --hostname backend\n\n # Allow an app in a different org to access the route\n cf add-access-rule apps.identity --source-app external-client --source-space external-space --source-org external-org --hostname backend\n\n # Allow all apps in the \"monitoring\" space to access the API metrics endpoint\n cf add-access-rule apps.identity --source-space monitoring --hostname api --path /metrics\n\n # Allow all apps in a space in a different org\n cf add-access-rule apps.identity --source-space prod-space --source-org prod-org --hostname api\n\n # Allow all apps in the \"platform\" org to access the route\n cf add-access-rule apps.identity --source-org platform --hostname shared-api\n\n # Allow any authenticated app to access the public API\n cf add-access-rule apps.identity --source-any --hostname public-api\n\n # Use raw selector (advanced)\n cf add-access-rule apps.identity --selector cf:app:d76446a1-f429-4444-8797-be2f78b75b08 --hostname backend"` relatedCommands interface{} `related_commands:"access-rules, remove-access-rule, create-shared-domain"` } @@ -57,12 +57,10 @@ func (cmd AddAccessRuleCommand) Execute(args []string) error { return err } - ruleName := cmd.RequiredArgs.RuleName domainName := cmd.RequiredArgs.Domain - cmd.UI.DisplayTextWithFlavor("Adding access rule {{.RuleName}} for route {{.Hostname}}.{{.Domain}}{{.Path}} as {{.User}}...", + cmd.UI.DisplayTextWithFlavor("Adding access rule for route {{.Hostname}}.{{.Domain}}{{.Path}} as {{.User}}...", map[string]interface{}{ - "RuleName": ruleName, "Hostname": cmd.Hostname, "Domain": domainName, "Path": formatPath(cmd.Path), @@ -79,17 +77,13 @@ func (cmd AddAccessRuleCommand) Execute(args []string) error { "Selector": selector, }) - warnings, err = cmd.Actor.AddAccessRule(ruleName, domainName, selector, cmd.Hostname, cmd.Path) + warnings, err = cmd.Actor.AddAccessRule(domainName, selector, cmd.Hostname, cmd.Path) cmd.UI.DisplayWarnings(warnings) if err != nil { return err } cmd.UI.DisplayOK() - cmd.UI.DisplayText("TIP: Access rule '{{.RuleName}}' has been created. It may take a few seconds for the rule to propagate to GoRouter.", - map[string]interface{}{ - "RuleName": ruleName, - }) return nil } diff --git a/command/v7/add_access_rule_command_test.go b/command/v7/add_access_rule_command_test.go index f6b73907d28..1a81d016b33 100644 --- a/command/v7/add_access_rule_command_test.go +++ b/command/v7/add_access_rule_command_test.go @@ -65,8 +65,7 @@ var _ = Describe("add-access-rule Command", func() { Context("when no source flags are provided", func() { BeforeEach(func() { cmd.RequiredArgs = flag.AddAccessRuleArgs{ - RuleName: "test-rule", - Domain: "apps.internal", + Domain: "apps.internal", } cmd.Hostname = "backend" }) @@ -81,8 +80,7 @@ var _ = Describe("add-access-rule Command", func() { Context("when multiple mutually exclusive source flags are provided", func() { BeforeEach(func() { cmd.RequiredArgs = flag.AddAccessRuleArgs{ - RuleName: "test-rule", - Domain: "apps.internal", + Domain: "apps.internal", } cmd.Hostname = "backend" cmd.SourceApp = "app-name" @@ -99,8 +97,7 @@ var _ = Describe("add-access-rule Command", func() { Context("when --source-space and --source-any are both provided", func() { BeforeEach(func() { cmd.RequiredArgs = flag.AddAccessRuleArgs{ - RuleName: "test-rule", - Domain: "apps.internal", + Domain: "apps.internal", } cmd.Hostname = "backend" cmd.SourceSpace = "some-space" @@ -118,8 +115,7 @@ var _ = Describe("add-access-rule Command", func() { When("the user is logged in, an org is targeted, and a space is targeted", func() { BeforeEach(func() { cmd.RequiredArgs = flag.AddAccessRuleArgs{ - RuleName: "test-rule", - Domain: "apps.internal", + Domain: "apps.internal", } cmd.Hostname = "backend" }) @@ -147,15 +143,14 @@ var _ = Describe("add-access-rule Command", func() { // Verify access rule creation with resolved selector Expect(fakeActor.AddAccessRuleCallCount()).To(Equal(1)) - ruleName, domain, selector, hostname, path := fakeActor.AddAccessRuleArgsForCall(0) - Expect(ruleName).To(Equal("test-rule")) + domain, selector, hostname, path := fakeActor.AddAccessRuleArgsForCall(0) Expect(domain).To(Equal("apps.internal")) Expect(selector).To(Equal("cf:app:app-guid")) Expect(hostname).To(Equal("backend")) Expect(path).To(BeEmpty()) // Verify output - Expect(testUI.Out).To(Say("Adding access rule test-rule")) + Expect(testUI.Out).To(Say("Adding access rule for route")) Expect(testUI.Out).To(Say("scope: app, source: frontend-app")) Expect(testUI.Out).To(Say("selector: cf:app:app-guid")) Expect(testUI.Out).To(Say("OK")) @@ -201,7 +196,7 @@ var _ = Describe("add-access-rule Command", func() { Expect(spaceGUID).To(Equal("other-space-guid")) // Verify selector - _, _, selector, _, _ := fakeActor.AddAccessRuleArgsForCall(0) + _, selector, _, _ := fakeActor.AddAccessRuleArgsForCall(0) Expect(selector).To(Equal("cf:app:app-guid")) // Verify output shows cross-space info @@ -283,7 +278,7 @@ var _ = Describe("add-access-rule Command", func() { Expect(executeErr).NotTo(HaveOccurred()) // Verify selector is space-level - _, _, selector, _, _ := fakeActor.AddAccessRuleArgsForCall(0) + _, selector, _, _ := fakeActor.AddAccessRuleArgsForCall(0) Expect(selector).To(Equal("cf:space:space-guid-123")) Expect(testUI.Out).To(Say("scope: space, source: monitoring-space")) @@ -322,7 +317,7 @@ var _ = Describe("add-access-rule Command", func() { Expect(orgGUID).To(Equal("prod-org-guid")) // Verify selector is space-level - _, _, selector, _, _ := fakeActor.AddAccessRuleArgsForCall(0) + _, selector, _, _ := fakeActor.AddAccessRuleArgsForCall(0) Expect(selector).To(Equal("cf:space:prod-space-guid")) Expect(testUI.Out).To(Say("scope: space, source: prod-space \\(org: prod-org\\)")) @@ -344,7 +339,7 @@ var _ = Describe("add-access-rule Command", func() { Expect(executeErr).NotTo(HaveOccurred()) // Verify selector is org-level - _, _, selector, _, _ := fakeActor.AddAccessRuleArgsForCall(0) + _, selector, _, _ := fakeActor.AddAccessRuleArgsForCall(0) Expect(selector).To(Equal("cf:org:org-guid-456")) Expect(testUI.Out).To(Say("scope: org, source: platform-org")) @@ -360,7 +355,7 @@ var _ = Describe("add-access-rule Command", func() { It("creates an 'any' access rule", func() { Expect(executeErr).NotTo(HaveOccurred()) - _, _, selector, _, _ := fakeActor.AddAccessRuleArgsForCall(0) + _, selector, _, _ := fakeActor.AddAccessRuleArgsForCall(0) Expect(selector).To(Equal("cf:any")) Expect(testUI.Out).To(Say("scope: any, source: any authenticated app")) @@ -376,7 +371,7 @@ var _ = Describe("add-access-rule Command", func() { It("uses the raw selector without resolution", func() { Expect(executeErr).NotTo(HaveOccurred()) - _, _, selector, _, _ := fakeActor.AddAccessRuleArgsForCall(0) + _, selector, _, _ := fakeActor.AddAccessRuleArgsForCall(0) Expect(selector).To(Equal("cf:app:raw-guid-123")) Expect(testUI.Out).To(Say("selector: cf:app:raw-guid-123")) @@ -398,7 +393,7 @@ var _ = Describe("add-access-rule Command", func() { It("passes the path to the actor", func() { Expect(executeErr).NotTo(HaveOccurred()) - _, _, _, _, path := fakeActor.AddAccessRuleArgsForCall(0) + _, _, _, path := fakeActor.AddAccessRuleArgsForCall(0) Expect(path).To(Equal("/metrics")) }) }) diff --git a/command/v7/remove_access_rule_command.go b/command/v7/remove_access_rule_command.go index 12d0b08eb4b..4a2edb69892 100644 --- a/command/v7/remove_access_rule_command.go +++ b/command/v7/remove_access_rule_command.go @@ -8,10 +8,11 @@ type RemoveAccessRuleCommand struct { BaseCommand RequiredArgs flag.RemoveAccessRuleArgs `positional-args:"yes"` + Selector string `long:"selector" required:"true" description:"Selector to identify the access rule (cf:app:, cf:space:, cf:org:, or cf:any)"` Hostname string `long:"hostname" required:"true" description:"Hostname for the route"` Path string `long:"path" description:"Path for the route"` Force bool `short:"f" description:"Force deletion without confirmation"` - usage interface{} `usage:"CF_NAME remove-access-rule RULE_NAME DOMAIN --hostname HOSTNAME [--path PATH] [-f]\n\nEXAMPLES:\n cf remove-access-rule allow-frontend apps.identity --hostname backend\n cf remove-access-rule allow-monitoring apps.identity --hostname api --path /metrics -f"` + usage interface{} `usage:"CF_NAME remove-access-rule DOMAIN --selector SELECTOR --hostname HOSTNAME [--path PATH] [-f]\n\nEXAMPLES:\n cf remove-access-rule apps.identity --selector cf:app:d76446a1-f429-4444-8797-be2f78b75b08 --hostname backend\n cf remove-access-rule apps.identity --selector cf:space:2b26e210-1b48-4e60-8432-f24bc5927789 --hostname api --path /metrics -f\n cf remove-access-rule apps.identity --selector cf:any --hostname public-api -f"` relatedCommands interface{} `related_commands:"access-rules, add-access-rule"` } @@ -26,13 +27,17 @@ func (cmd RemoveAccessRuleCommand) Execute(args []string) error { return err } - ruleName := cmd.RequiredArgs.RuleName + // Validate selector format + if err := validateSelector(cmd.Selector); err != nil { + return err + } + domainName := cmd.RequiredArgs.Domain if !cmd.Force { - prompt := "Really remove access rule {{.RuleName}} for route {{.Hostname}}.{{.Domain}}{{.Path}}?" + prompt := "Really remove access rule with selector {{.Selector}} for route {{.Hostname}}.{{.Domain}}{{.Path}}?" response, promptErr := cmd.UI.DisplayBoolPrompt(false, prompt, map[string]interface{}{ - "RuleName": ruleName, + "Selector": cmd.Selector, "Hostname": cmd.Hostname, "Domain": domainName, "Path": formatPath(cmd.Path), @@ -43,23 +48,20 @@ func (cmd RemoveAccessRuleCommand) Execute(args []string) error { } if !response { - cmd.UI.DisplayText("Access rule '{{.RuleName}}' has not been removed.", map[string]interface{}{ - "RuleName": ruleName, - }) + cmd.UI.DisplayText("Access rule has not been removed.") return nil } } - cmd.UI.DisplayTextWithFlavor("Removing access rule {{.RuleName}} for route {{.Hostname}}.{{.Domain}}{{.Path}} as {{.User}}...", + cmd.UI.DisplayTextWithFlavor("Removing access rule for route {{.Hostname}}.{{.Domain}}{{.Path}} as {{.User}}...", map[string]interface{}{ - "RuleName": ruleName, "Hostname": cmd.Hostname, "Domain": domainName, "Path": formatPath(cmd.Path), "User": user.Name, }) - warnings, err := cmd.Actor.DeleteAccessRule(ruleName, domainName, cmd.Hostname, cmd.Path) + warnings, err := cmd.Actor.DeleteAccessRuleBySelector(domainName, cmd.Selector, cmd.Hostname, cmd.Path) cmd.UI.DisplayWarnings(warnings) if err != nil { return err diff --git a/command/v7/v7fakes/fake_actor.go b/command/v7/v7fakes/fake_actor.go index b3093ad655e..bfdbfe9b10d 100644 --- a/command/v7/v7fakes/fake_actor.go +++ b/command/v7/v7fakes/fake_actor.go @@ -22,14 +22,13 @@ import ( ) type FakeActor struct { - AddAccessRuleStub func(string, string, string, string, string) (v7action.Warnings, error) + AddAccessRuleStub func(string, string, string, string) (v7action.Warnings, error) addAccessRuleMutex sync.RWMutex addAccessRuleArgsForCall []struct { arg1 string arg2 string arg3 string arg4 string - arg5 string } addAccessRuleReturns struct { result1 v7action.Warnings @@ -578,19 +577,19 @@ type FakeActor struct { result1 v7action.Warnings result2 error } - DeleteAccessRuleStub func(string, string, string, string) (v7action.Warnings, error) - deleteAccessRuleMutex sync.RWMutex - deleteAccessRuleArgsForCall []struct { + DeleteAccessRuleBySelectorStub func(string, string, string, string) (v7action.Warnings, error) + deleteAccessRuleBySelectorMutex sync.RWMutex + deleteAccessRuleBySelectorArgsForCall []struct { arg1 string arg2 string arg3 string arg4 string } - deleteAccessRuleReturns struct { + deleteAccessRuleBySelectorReturns struct { result1 v7action.Warnings result2 error } - deleteAccessRuleReturnsOnCall map[int]struct { + deleteAccessRuleBySelectorReturnsOnCall map[int]struct { result1 v7action.Warnings result2 error } @@ -3853,7 +3852,7 @@ type FakeActor struct { invocationsMutex sync.RWMutex } -func (fake *FakeActor) AddAccessRule(arg1 string, arg2 string, arg3 string, arg4 string, arg5 string) (v7action.Warnings, error) { +func (fake *FakeActor) AddAccessRule(arg1 string, arg2 string, arg3 string, arg4 string) (v7action.Warnings, error) { fake.addAccessRuleMutex.Lock() ret, specificReturn := fake.addAccessRuleReturnsOnCall[len(fake.addAccessRuleArgsForCall)] fake.addAccessRuleArgsForCall = append(fake.addAccessRuleArgsForCall, struct { @@ -3861,14 +3860,13 @@ func (fake *FakeActor) AddAccessRule(arg1 string, arg2 string, arg3 string, arg4 arg2 string arg3 string arg4 string - arg5 string - }{arg1, arg2, arg3, arg4, arg5}) + }{arg1, arg2, arg3, arg4}) stub := fake.AddAccessRuleStub fakeReturns := fake.addAccessRuleReturns - fake.recordInvocation("AddAccessRule", []interface{}{arg1, arg2, arg3, arg4, arg5}) + fake.recordInvocation("AddAccessRule", []interface{}{arg1, arg2, arg3, arg4}) fake.addAccessRuleMutex.Unlock() if stub != nil { - return stub(arg1, arg2, arg3, arg4, arg5) + return stub(arg1, arg2, arg3, arg4) } if specificReturn { return ret.result1, ret.result2 @@ -3882,17 +3880,17 @@ func (fake *FakeActor) AddAccessRuleCallCount() int { return len(fake.addAccessRuleArgsForCall) } -func (fake *FakeActor) AddAccessRuleCalls(stub func(string, string, string, string, string) (v7action.Warnings, error)) { +func (fake *FakeActor) AddAccessRuleCalls(stub func(string, string, string, string) (v7action.Warnings, error)) { fake.addAccessRuleMutex.Lock() defer fake.addAccessRuleMutex.Unlock() fake.AddAccessRuleStub = stub } -func (fake *FakeActor) AddAccessRuleArgsForCall(i int) (string, string, string, string, string) { +func (fake *FakeActor) AddAccessRuleArgsForCall(i int) (string, string, string, string) { fake.addAccessRuleMutex.RLock() defer fake.addAccessRuleMutex.RUnlock() argsForCall := fake.addAccessRuleArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5 + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 } func (fake *FakeActor) AddAccessRuleReturns(result1 v7action.Warnings, result2 error) { @@ -6287,19 +6285,19 @@ func (fake *FakeActor) CreateUserProvidedServiceInstanceReturnsOnCall(i int, res }{result1, result2} } -func (fake *FakeActor) DeleteAccessRule(arg1 string, arg2 string, arg3 string, arg4 string) (v7action.Warnings, error) { - fake.deleteAccessRuleMutex.Lock() - ret, specificReturn := fake.deleteAccessRuleReturnsOnCall[len(fake.deleteAccessRuleArgsForCall)] - fake.deleteAccessRuleArgsForCall = append(fake.deleteAccessRuleArgsForCall, struct { +func (fake *FakeActor) DeleteAccessRuleBySelector(arg1 string, arg2 string, arg3 string, arg4 string) (v7action.Warnings, error) { + fake.deleteAccessRuleBySelectorMutex.Lock() + ret, specificReturn := fake.deleteAccessRuleBySelectorReturnsOnCall[len(fake.deleteAccessRuleBySelectorArgsForCall)] + fake.deleteAccessRuleBySelectorArgsForCall = append(fake.deleteAccessRuleBySelectorArgsForCall, struct { arg1 string arg2 string arg3 string arg4 string }{arg1, arg2, arg3, arg4}) - stub := fake.DeleteAccessRuleStub - fakeReturns := fake.deleteAccessRuleReturns - fake.recordInvocation("DeleteAccessRule", []interface{}{arg1, arg2, arg3, arg4}) - fake.deleteAccessRuleMutex.Unlock() + stub := fake.DeleteAccessRuleBySelectorStub + fakeReturns := fake.deleteAccessRuleBySelectorReturns + fake.recordInvocation("DeleteAccessRuleBySelector", []interface{}{arg1, arg2, arg3, arg4}) + fake.deleteAccessRuleBySelectorMutex.Unlock() if stub != nil { return stub(arg1, arg2, arg3, arg4) } @@ -6309,46 +6307,46 @@ func (fake *FakeActor) DeleteAccessRule(arg1 string, arg2 string, arg3 string, a return fakeReturns.result1, fakeReturns.result2 } -func (fake *FakeActor) DeleteAccessRuleCallCount() int { - fake.deleteAccessRuleMutex.RLock() - defer fake.deleteAccessRuleMutex.RUnlock() - return len(fake.deleteAccessRuleArgsForCall) +func (fake *FakeActor) DeleteAccessRuleBySelectorCallCount() int { + fake.deleteAccessRuleBySelectorMutex.RLock() + defer fake.deleteAccessRuleBySelectorMutex.RUnlock() + return len(fake.deleteAccessRuleBySelectorArgsForCall) } -func (fake *FakeActor) DeleteAccessRuleCalls(stub func(string, string, string, string) (v7action.Warnings, error)) { - fake.deleteAccessRuleMutex.Lock() - defer fake.deleteAccessRuleMutex.Unlock() - fake.DeleteAccessRuleStub = stub +func (fake *FakeActor) DeleteAccessRuleBySelectorCalls(stub func(string, string, string, string) (v7action.Warnings, error)) { + fake.deleteAccessRuleBySelectorMutex.Lock() + defer fake.deleteAccessRuleBySelectorMutex.Unlock() + fake.DeleteAccessRuleBySelectorStub = stub } -func (fake *FakeActor) DeleteAccessRuleArgsForCall(i int) (string, string, string, string) { - fake.deleteAccessRuleMutex.RLock() - defer fake.deleteAccessRuleMutex.RUnlock() - argsForCall := fake.deleteAccessRuleArgsForCall[i] +func (fake *FakeActor) DeleteAccessRuleBySelectorArgsForCall(i int) (string, string, string, string) { + fake.deleteAccessRuleBySelectorMutex.RLock() + defer fake.deleteAccessRuleBySelectorMutex.RUnlock() + argsForCall := fake.deleteAccessRuleBySelectorArgsForCall[i] return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 } -func (fake *FakeActor) DeleteAccessRuleReturns(result1 v7action.Warnings, result2 error) { - fake.deleteAccessRuleMutex.Lock() - defer fake.deleteAccessRuleMutex.Unlock() - fake.DeleteAccessRuleStub = nil - fake.deleteAccessRuleReturns = struct { +func (fake *FakeActor) DeleteAccessRuleBySelectorReturns(result1 v7action.Warnings, result2 error) { + fake.deleteAccessRuleBySelectorMutex.Lock() + defer fake.deleteAccessRuleBySelectorMutex.Unlock() + fake.DeleteAccessRuleBySelectorStub = nil + fake.deleteAccessRuleBySelectorReturns = struct { result1 v7action.Warnings result2 error }{result1, result2} } -func (fake *FakeActor) DeleteAccessRuleReturnsOnCall(i int, result1 v7action.Warnings, result2 error) { - fake.deleteAccessRuleMutex.Lock() - defer fake.deleteAccessRuleMutex.Unlock() - fake.DeleteAccessRuleStub = nil - if fake.deleteAccessRuleReturnsOnCall == nil { - fake.deleteAccessRuleReturnsOnCall = make(map[int]struct { +func (fake *FakeActor) DeleteAccessRuleBySelectorReturnsOnCall(i int, result1 v7action.Warnings, result2 error) { + fake.deleteAccessRuleBySelectorMutex.Lock() + defer fake.deleteAccessRuleBySelectorMutex.Unlock() + fake.DeleteAccessRuleBySelectorStub = nil + if fake.deleteAccessRuleBySelectorReturnsOnCall == nil { + fake.deleteAccessRuleBySelectorReturnsOnCall = make(map[int]struct { result1 v7action.Warnings result2 error }) } - fake.deleteAccessRuleReturnsOnCall[i] = struct { + fake.deleteAccessRuleBySelectorReturnsOnCall[i] = struct { result1 v7action.Warnings result2 error }{result1, result2} diff --git a/resources/access_rule_resource.go b/resources/access_rule_resource.go index 6ccf5b34ad9..7900ca03392 100644 --- a/resources/access_rule_resource.go +++ b/resources/access_rule_resource.go @@ -11,7 +11,6 @@ type AccessRule struct { GUID string `json:"guid,omitempty"` CreatedAt *time.Time `json:"created_at,omitempty"` UpdatedAt *time.Time `json:"updated_at,omitempty"` - Name string `json:"name"` Selector string `json:"selector"` RouteGUID string `json:"-"` @@ -24,7 +23,6 @@ func (a AccessRule) MarshalJSON() ([]byte, error) { GUID string `json:"guid,omitempty"` CreatedAt *time.Time `json:"created_at,omitempty"` UpdatedAt *time.Time `json:"updated_at,omitempty"` - Name string `json:"name"` Selector string `json:"selector"` Metadata *Metadata `json:"metadata,omitempty"` @@ -41,7 +39,6 @@ func (a AccessRule) MarshalJSON() ([]byte, error) { aliasData.GUID = a.GUID aliasData.CreatedAt = a.CreatedAt aliasData.UpdatedAt = a.UpdatedAt - aliasData.Name = a.Name aliasData.Selector = a.Selector aliasData.Metadata = a.Metadata aliasData.Relationships.Route.Data.GUID = a.RouteGUID @@ -54,7 +51,6 @@ func (a *AccessRule) UnmarshalJSON(data []byte) error { GUID string `json:"guid,omitempty"` CreatedAt *time.Time `json:"created_at,omitempty"` UpdatedAt *time.Time `json:"updated_at,omitempty"` - Name string `json:"name"` Selector string `json:"selector"` Metadata *Metadata `json:"metadata,omitempty"` @@ -75,7 +71,6 @@ func (a *AccessRule) UnmarshalJSON(data []byte) error { a.GUID = alias.GUID a.CreatedAt = alias.CreatedAt a.UpdatedAt = alias.UpdatedAt - a.Name = alias.Name a.Selector = alias.Selector a.RouteGUID = alias.Relationships.Route.Data.GUID a.Metadata = alias.Metadata From 255bab9a319bbf46dc1fb7dc1a8f7e90e0fe9494 Mon Sep 17 00:00:00 2001 From: rkoster Date: Wed, 15 Apr 2026 09:04:58 +0000 Subject: [PATCH 3/4] Refine access-rules output to show separate host, domain, and path columns Changed table format from: route selector scope source backend.apps.identity ... app frontend-app To: host domain path selector scope source backend apps.identity ... app frontend-app api apps.identity /metrics ... space monitoring This provides better clarity by separating the route components into individual columns, making it easier to scan and filter visually. --- command/v7/access_rules_command.go | 24 ++++++------------------ command/v7/access_rules_command_test.go | 18 +++++++++--------- 2 files changed, 15 insertions(+), 27 deletions(-) diff --git a/command/v7/access_rules_command.go b/command/v7/access_rules_command.go index 5148c801911..6d8a9c8b169 100644 --- a/command/v7/access_rules_command.go +++ b/command/v7/access_rules_command.go @@ -1,9 +1,6 @@ package v7 import ( - "fmt" - - "code.cloudfoundry.org/cli/v9/resources" "code.cloudfoundry.org/cli/v9/util/ui" ) @@ -64,7 +61,9 @@ func (cmd AccessRulesCommand) Execute(args []string) error { // Build table data table := [][]string{ { - cmd.UI.TranslateText("route"), + cmd.UI.TranslateText("host"), + cmd.UI.TranslateText("domain"), + cmd.UI.TranslateText("path"), cmd.UI.TranslateText("selector"), cmd.UI.TranslateText("scope"), cmd.UI.TranslateText("source"), @@ -73,7 +72,9 @@ func (cmd AccessRulesCommand) Execute(args []string) error { for _, ruleWithRoute := range rulesWithRoutes { table = append(table, []string{ - formatRoute(ruleWithRoute.Route, ruleWithRoute.DomainName), + ruleWithRoute.Route.Host, + ruleWithRoute.DomainName, + ruleWithRoute.Route.Path, ruleWithRoute.Selector, ruleWithRoute.ScopeType, ruleWithRoute.SourceName, @@ -86,16 +87,3 @@ func (cmd AccessRulesCommand) Execute(args []string) error { return nil } -// formatRoute formats a route as hostname.domain/path -func formatRoute(route resources.Route, domainName string) string { - var formatted string - if route.Host != "" { - formatted = fmt.Sprintf("%s.%s", route.Host, domainName) - } else { - formatted = domainName - } - if route.Path != "" { - formatted += route.Path - } - return formatted -} diff --git a/command/v7/access_rules_command_test.go b/command/v7/access_rules_command_test.go index 6629be6c026..e161144cf6b 100644 --- a/command/v7/access_rules_command_test.go +++ b/command/v7/access_rules_command_test.go @@ -146,9 +146,9 @@ var _ = Describe("access-rules Command", func() { Expect(executeErr).ToNot(HaveOccurred()) Expect(testUI.Out).To(Say(`Getting access rules in org some-org / space some-space as steve\.\.\.`)) - Expect(testUI.Out).To(Say(`route\s+selector\s+scope\s+source`)) - Expect(testUI.Out).To(Say(`myapp\.example\.com/api\s+cf:app:app-guid-1\s+app\s+my-app`)) - Expect(testUI.Out).To(Say(`webapp\.test\.com\s+cf:any\s+any`)) + Expect(testUI.Out).To(Say(`host\s+domain\s+path\s+selector\s+scope\s+source`)) + Expect(testUI.Out).To(Say(`myapp\s+example\.com\s+/api\s+cf:app:app-guid-1\s+app\s+my-app`)) + Expect(testUI.Out).To(Say(`webapp\s+test\.com\s+cf:any\s+any`)) Expect(testUI.Err).To(Say("warning-1")) @@ -298,8 +298,8 @@ var _ = Describe("access-rules Command", func() { Expect(executeErr).ToNot(HaveOccurred()) Expect(testUI.Out).To(Say(`Getting access rules in org some-org / space some-space as steve\.\.\.`)) - Expect(testUI.Out).To(Say(`route\s+selector\s+scope\s+source`)) - Expect(testUI.Out).To(Say(`myapp\.example\.com/api\s+cf:app:app-guid-1\s+app\s+my-app`)) + Expect(testUI.Out).To(Say(`host\s+domain\s+path\s+selector\s+scope\s+source`)) + Expect(testUI.Out).To(Say(`myapp\s+example\.com\s+/api\s+cf:app:app-guid-1\s+app\s+my-app`)) }) }) @@ -340,11 +340,11 @@ var _ = Describe("access-rules Command", func() { It("formats routes correctly", func() { Expect(executeErr).ToNot(HaveOccurred()) - // No host, with path: "example.com/api" - Expect(testUI.Out).To(Say(`example\.com/api`)) + // No host, with path: empty host, example.com, /api + Expect(testUI.Out).To(Say(`\s+example\.com\s+/api`)) - // With host, no path: "myapp.test.com" - Expect(testUI.Out).To(Say(`myapp\.test\.com`)) + // With host, no path: myapp, test.com, empty path + Expect(testUI.Out).To(Say(`myapp\s+test\.com\s+`)) }) }) }) From 9409dbbb212ea052614c630a7c9b9b7c4425bda5 Mon Sep 17 00:00:00 2001 From: rkoster Date: Tue, 21 Apr 2026 11:17:10 +0000 Subject: [PATCH 4/4] =?UTF-8?q?Rebrand=20RFC=20terminology:=20access=20rul?= =?UTF-8?q?es=20=E2=86=92=20route=20policies,=20selector=20=E2=86=92=20sou?= =?UTF-8?q?rce?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Complete terminology shift for identity-aware routing RFC implementation: **Access Rules → Route Policies** - API: /v3/access_rules → /v3/route_policies - CLI commands: - cf access-rules → cf route-policies - cf add-access-rule → cf add-route-policy - cf remove-access-rule → cf remove-route-policy - Domain flags: --enforce-access-rules → --enforce-route-policies - Domain fields: enforce_access_rules → enforce_route_policies, access_rules_scope → route_policies_scope **Selector → Source** - API field: "selector" → "source" - CLI flag: --selector → --source - Query params: selectors → sources, selector_resource_guids → source_guids - Table column headers: "selector/source" → "source/name" - Internal types: AccessRule → RoutePolicy, AccessRuleWithRoute → RoutePolicyWithRoute - Error types: AccessRuleNotFoundError → RoutePolicyNotFoundError **Rationale (per RFC)** - "Route policies" aligns with existing CF "network policies" terminology - "Source" matches C2C network policy convention (source → destination) - Improves clarity: policies define allowed sources that can reach routes - Better mental model for users familiar with CF networking concepts This is a breaking change but acceptable since RFC is pre-GA with only POC/lab implementations. Clean terminology is preferred over backward compatibility at this stage. Co-authored-by: RFC Community Aligns-with: https://github.com/cloudfoundry/community/pull/1438/commits/be8d74c1 --- .../access_rule_not_found_error.go | 11 - .../route_policy_not_found_error.go | 11 + actor/v7action/access_rule_test.go | 750 ------------------ actor/v7action/cloud_controller_client.go | 6 +- actor/v7action/domain.go | 14 +- .../{access_rule.go => route_policy.go} | 125 ++- .../fake_cloud_controller_client.go | 502 ++++++------ actor/v7action/v7actionfakes/fake_config.go | 42 - .../v7action/v7actionfakes/fake_downloader.go | 2 - .../fake_kubernetes_config_getter.go | 2 - .../v7actionfakes/fake_manifest_parser.go | 4 - .../v7actionfakes/fake_routing_client.go | 4 - .../v7actionfakes/fake_shared_actor.go | 8 - .../v7actionfakes/fake_simple_progress_bar.go | 4 - actor/v7action/v7actionfakes/fake_sshactor.go | 2 - .../v7action/v7actionfakes/fake_uaaclient.go | 22 - .../v7action/v7actionfakes/fake_who_am_ier.go | 2 - .../create_deployment_for_push_plan_test.go | 2 +- actor/v7pushaction/handle_disk_override.go | 2 +- .../v7pushaction/handle_disk_override_test.go | 2 +- .../v7pushaction/handle_instances_override.go | 2 +- .../handle_instances_override_test.go | 2 +- .../handle_log_rate_limit_override.go | 2 +- .../handle_log_rate_limit_override_test.go | 2 +- actor/v7pushaction/handle_memory_override.go | 2 +- .../handle_memory_override_test.go | 2 +- ...up_deployment_information_for_push_plan.go | 2 +- ...ployment_information_for_push_plan_test.go | 4 +- api/cfnetworking/cfnetv1/client.go | 144 ++-- api/cfnetworking/errors.go | 74 +- api/cfnetworking/wrapper/retry_request.go | 64 +- api/cloudcontroller/ccv3/access_rule.go | 59 -- api/cloudcontroller/ccv3/deployment_test.go | 2 +- api/cloudcontroller/ccv3/info.go | 2 +- .../ccv3/internal/api_routes.go | 16 +- api/cloudcontroller/ccv3/query.go | 6 +- api/cloudcontroller/ccv3/route_policy.go | 59 ++ cf/actors/push.go | 4 +- cf/cli | Bin 0 -> 39064693 bytes cf/net/warnings_collector.go | 4 +- command/common/command_list_v7.go | 6 +- command/common/internal/help_all_display.go | 2 +- command/flag/arguments.go | 8 +- command/v7/access_rules_command_test.go | 350 -------- command/v7/actor.go | 8 +- command/v7/add_access_rule_command_test.go | 448 ----------- ...command.go => add_route_policy_command.go} | 74 +- command/v7/buildpacks_command.go | 4 +- command/v7/buildpacks_command_test.go | 2 +- command/v7/copy_source_command.go | 10 +- command/v7/create_buildpack_command.go | 2 +- command/v7/create_private_domain_command.go | 22 +- command/v7/create_route_command.go | 4 +- command/v7/create_route_command_test.go | 2 +- command/v7/create_shared_domain_command.go | 28 +- .../create_user_provided_service_command.go | 2 +- command/v7/delete_buildpack_command.go | 4 +- command/v7/delete_buildpack_command_test.go | 2 +- command/v7/remove_access_rule_command.go | 73 -- command/v7/remove_route_policy_command.go | 73 ++ command/v7/restage_command.go | 10 +- command/v7/restart_command.go | 10 +- command/v7/revision_command_test.go | 12 +- command/v7/rollback_command.go | 4 +- ...s_command.go => route_policies_command.go} | 39 +- .../v7/shared/sharedfakes/fake_app_stager.go | 6 - command/v7/stack_command_test.go | 38 +- command/v7/update_buildpack_command.go | 2 +- command/v7/update_stack_command_test.go | 95 ++- command/v7/v7fakes/fake_actor.go | 592 +++++++------- command/v7/v7fakes/fake_actor_reloader.go | 2 - command/v7/v7fakes/fake_diff_displayer.go | 2 - command/v7/v7fakes/fake_label_setter.go | 2 - command/v7/v7fakes/fake_label_unsetter.go | 2 - command/v7/v7fakes/fake_manifest_locator.go | 2 - command/v7/v7fakes/fake_manifest_parser.go | 6 - .../v7/v7fakes/fake_network_policies_actor.go | 4 - command/v7/v7fakes/fake_networking_actor.go | 2 - command/v7/v7fakes/fake_progress_bar.go | 6 - command/v7/v7fakes/fake_push_actor.go | 8 - .../fake_remove_network_policy_actor.go | 2 - command/v7/v7fakes/fake_revisions_actor.go | 2 - command/v7/v7fakes/fake_set_label_actor.go | 44 +- command/v7/v7fakes/fake_shared_sshactor.go | 2 - command/v7/v7fakes/fake_v7actor_for_push.go | 10 - devbox.json | 14 + devbox.lock | 57 ++ .../v7/isolated/revision_command_test.go | 12 +- .../v7/isolated/update_stack_command_test.go | 1 - resources/deployment_resource.go | 2 +- resources/domain_resource.go | 48 +- resources/process_resource.go | 6 +- ...e_resource.go => route_policy_resource.go} | 36 +- ..._test.go => route_policy_resource_test.go} | 34 +- 94 files changed, 1278 insertions(+), 2929 deletions(-) delete mode 100644 actor/actionerror/access_rule_not_found_error.go create mode 100644 actor/actionerror/route_policy_not_found_error.go delete mode 100644 actor/v7action/access_rule_test.go rename actor/v7action/{access_rule.go => route_policy.go} (69%) delete mode 100644 api/cloudcontroller/ccv3/access_rule.go create mode 100644 api/cloudcontroller/ccv3/route_policy.go create mode 100755 cf/cli delete mode 100644 command/v7/access_rules_command_test.go delete mode 100644 command/v7/add_access_rule_command_test.go rename command/v7/{add_access_rule_command.go => add_route_policy_command.go} (64%) delete mode 100644 command/v7/remove_access_rule_command.go create mode 100644 command/v7/remove_route_policy_command.go rename command/v7/{access_rules_command.go => route_policies_command.go} (55%) create mode 100644 devbox.json create mode 100644 devbox.lock rename resources/{access_rule_resource.go => route_policy_resource.go} (67%) rename resources/{access_rule_resource_test.go => route_policy_resource_test.go} (53%) diff --git a/actor/actionerror/access_rule_not_found_error.go b/actor/actionerror/access_rule_not_found_error.go deleted file mode 100644 index 02fc1d6c57b..00000000000 --- a/actor/actionerror/access_rule_not_found_error.go +++ /dev/null @@ -1,11 +0,0 @@ -package actionerror - -import "fmt" - -type AccessRuleNotFoundError struct { - Selector string -} - -func (e AccessRuleNotFoundError) Error() string { - return fmt.Sprintf("Access rule with selector '%s' not found.", e.Selector) -} diff --git a/actor/actionerror/route_policy_not_found_error.go b/actor/actionerror/route_policy_not_found_error.go new file mode 100644 index 00000000000..31410af83be --- /dev/null +++ b/actor/actionerror/route_policy_not_found_error.go @@ -0,0 +1,11 @@ +package actionerror + +import "fmt" + +type RoutePolicyNotFoundError struct { + Source string +} + +func (e RoutePolicyNotFoundError) Error() string { + return fmt.Sprintf("Route policy with source '%s' not found.", e.Source) +} diff --git a/actor/v7action/access_rule_test.go b/actor/v7action/access_rule_test.go deleted file mode 100644 index 38b81bb67b4..00000000000 --- a/actor/v7action/access_rule_test.go +++ /dev/null @@ -1,750 +0,0 @@ -package v7action_test - -import ( - "errors" - - "code.cloudfoundry.org/cli/v9/actor/actionerror" - . "code.cloudfoundry.org/cli/v9/actor/v7action" - "code.cloudfoundry.org/cli/v9/actor/v7action/v7actionfakes" - "code.cloudfoundry.org/cli/v9/api/cloudcontroller/ccv3" - "code.cloudfoundry.org/cli/v9/resources" - . "github.com/onsi/ginkgo/v2" - . "github.com/onsi/gomega" -) - -var _ = Describe("Access Rule Actions", func() { - var ( - actor *Actor - fakeCloudControllerClient *v7actionfakes.FakeCloudControllerClient - ) - - BeforeEach(func() { - actor, fakeCloudControllerClient, _, _, _, _, _ = NewTestActor() - }) - - Describe("GetAccessRulesForSpace", func() { - var ( - spaceGUID string - domainName string - hostname string - path string - labelSelector string - - results []AccessRuleWithRoute - warnings Warnings - executeErr error - ) - - BeforeEach(func() { - spaceGUID = "space-guid-1" - domainName = "" - hostname = "" - path = "" - labelSelector = "" - }) - - JustBeforeEach(func() { - results, warnings, executeErr = actor.GetAccessRulesForSpace( - spaceGUID, - domainName, - hostname, - path, - labelSelector, - ) - }) - - When("getting access rules succeeds with multiple rules", func() { - BeforeEach(func() { - // Mock GetAccessRules call with included routes - fakeCloudControllerClient.GetAccessRulesReturns( - []resources.AccessRule{ - { - GUID: "rule-guid-1", - Name: "rule-1", - Selector: "cf:app:app-guid-1", - RouteGUID: "route-guid-1", - }, - { - GUID: "rule-guid-2", - Name: "rule-2", - Selector: "cf:any", - RouteGUID: "route-guid-2", - }, - }, - ccv3.IncludedResources{ - Routes: []resources.Route{ - { - GUID: "route-guid-1", - SpaceGUID: "space-guid-1", - DomainGUID: "domain-guid-1", - Host: "app1", - Path: "/path1", - }, - { - GUID: "route-guid-2", - SpaceGUID: "space-guid-1", - DomainGUID: "domain-guid-2", - Host: "app2", - Path: "", - }, - }, - }, - ccv3.Warnings{"get-access-rules-warning"}, - nil, - ) - - // Mock GetDomain calls for domain name resolution - fakeCloudControllerClient.GetDomainStub = func(guid string) (resources.Domain, ccv3.Warnings, error) { - switch guid { - case "domain-guid-1": - return resources.Domain{GUID: "domain-guid-1", Name: "example.com"}, ccv3.Warnings{"get-domain-warning-1"}, nil - case "domain-guid-2": - return resources.Domain{GUID: "domain-guid-2", Name: "test.com"}, ccv3.Warnings{"get-domain-warning-2"}, nil - default: - return resources.Domain{}, nil, errors.New("domain not found") - } - } - - // Mock GetApplications for app name resolution - fakeCloudControllerClient.GetApplicationsReturns( - []resources.Application{ - {GUID: "app-guid-1", Name: "my-app"}, - }, - ccv3.Warnings{"get-app-warning"}, - nil, - ) - }) - - It("returns access rules with route and domain information", func() { - Expect(executeErr).ToNot(HaveOccurred()) - Expect(warnings).To(ConsistOf( - "get-access-rules-warning", - "get-domain-warning-1", - "get-domain-warning-2", - "get-app-warning", - )) - - Expect(results).To(HaveLen(2)) - - // First rule - Expect(results[0].GUID).To(Equal("rule-guid-1")) - Expect(results[0].Selector).To(Equal("cf:app:app-guid-1")) - Expect(results[0].Route.GUID).To(Equal("route-guid-1")) - Expect(results[0].Route.Host).To(Equal("app1")) - Expect(results[0].Route.Path).To(Equal("/path1")) - Expect(results[0].DomainName).To(Equal("example.com")) - Expect(results[0].ScopeType).To(Equal("app")) - Expect(results[0].SourceName).To(Equal("my-app")) - - // Second rule - Expect(results[1].GUID).To(Equal("rule-guid-2")) - Expect(results[1].Selector).To(Equal("cf:any")) - Expect(results[1].Route.GUID).To(Equal("route-guid-2")) - Expect(results[1].Route.Host).To(Equal("app2")) - Expect(results[1].DomainName).To(Equal("test.com")) - Expect(results[1].ScopeType).To(Equal("any")) - Expect(results[1].SourceName).To(Equal("")) - }) - - It("calls GetAccessRules with space GUID and include route filters", func() { - Expect(fakeCloudControllerClient.GetAccessRulesCallCount()).To(Equal(1)) - queries := fakeCloudControllerClient.GetAccessRulesArgsForCall(0) - Expect(queries).To(ContainElement(ccv3.Query{ - Key: ccv3.SpaceGUIDFilter, - Values: []string{"space-guid-1"}, - })) - Expect(queries).To(ContainElement(ccv3.Query{ - Key: ccv3.Include, - Values: []string{"route"}, - })) - }) - - It("does not call GetRoutes separately", func() { - Expect(fakeCloudControllerClient.GetRoutesCallCount()).To(Equal(0)) - }) - }) - - When("domain name filter is provided", func() { - BeforeEach(func() { - domainName = "example.com" - - fakeCloudControllerClient.GetDomainsReturns( - []resources.Domain{ - {GUID: "domain-guid-1", Name: "example.com"}, - }, - ccv3.Warnings{"get-domains-warning"}, - nil, - ) - - fakeCloudControllerClient.GetAccessRulesReturns( - []resources.AccessRule{ - { - GUID: "rule-guid-1", - Name: "rule-1", - Selector: "cf:any", - RouteGUID: "route-guid-1", - }, - }, - ccv3.IncludedResources{ - Routes: []resources.Route{ - { - GUID: "route-guid-1", - SpaceGUID: "space-guid-1", - DomainGUID: "domain-guid-1", - Host: "app1", - }, - }, - }, - ccv3.Warnings{"get-access-rules-warning"}, - nil, - ) - - fakeCloudControllerClient.GetDomainReturns( - resources.Domain{GUID: "domain-guid-1", Name: "example.com"}, - ccv3.Warnings{"get-domain-warning"}, - nil, - ) - }) - - It("filters routes by domain GUID", func() { - Expect(executeErr).ToNot(HaveOccurred()) - // Routes are filtered in-memory from included resources - Expect(fakeCloudControllerClient.GetRoutesCallCount()).To(Equal(0)) - }) - }) - - When("hostname filter is provided", func() { - BeforeEach(func() { - hostname = "myapp" - - fakeCloudControllerClient.GetAccessRulesReturns( - []resources.AccessRule{}, - ccv3.IncludedResources{}, - ccv3.Warnings{"get-access-rules-warning"}, - nil, - ) - }) - - It("adds hostname filter to route query", func() { - Expect(executeErr).ToNot(HaveOccurred()) - // GetRoutes should not be called since routes come from included resources - Expect(fakeCloudControllerClient.GetRoutesCallCount()).To(Equal(0)) - }) - }) - - When("path filter is provided", func() { - BeforeEach(func() { - path = "/api" - - fakeCloudControllerClient.GetAccessRulesReturns( - []resources.AccessRule{}, - ccv3.IncludedResources{}, - ccv3.Warnings{"get-access-rules-warning"}, - nil, - ) - }) - - It("adds path filter to route query", func() { - Expect(executeErr).ToNot(HaveOccurred()) - // GetRoutes should not be called if no access rules are found - Expect(fakeCloudControllerClient.GetRoutesCallCount()).To(Equal(0)) - }) - }) - - When("label selector filter is provided", func() { - BeforeEach(func() { - labelSelector = "env=production" - - fakeCloudControllerClient.GetAccessRulesReturns( - []resources.AccessRule{}, - ccv3.IncludedResources{}, - ccv3.Warnings{"get-access-rules-warning"}, - nil, - ) - }) - - It("adds label selector filter to access rules query", func() { - Expect(executeErr).ToNot(HaveOccurred()) - Expect(fakeCloudControllerClient.GetAccessRulesCallCount()).To(Equal(1)) - queries := fakeCloudControllerClient.GetAccessRulesArgsForCall(0) - - Expect(queries).To(ContainElement(ccv3.Query{ - Key: ccv3.LabelSelectorFilter, - Values: []string{"env=production"}, - })) - }) - }) - - When("no access rules are found in the space", func() { - BeforeEach(func() { - fakeCloudControllerClient.GetAccessRulesReturns( - []resources.AccessRule{}, - ccv3.IncludedResources{}, - ccv3.Warnings{"get-access-rules-warning"}, - nil, - ) - }) - - It("returns an empty list without error", func() { - Expect(executeErr).ToNot(HaveOccurred()) - Expect(results).To(BeEmpty()) - Expect(warnings).To(ConsistOf("get-access-rules-warning")) - }) - - It("does not call GetRoutes", func() { - Expect(fakeCloudControllerClient.GetRoutesCallCount()).To(Equal(0)) - }) - }) - - When("getting access rules fails", func() { - BeforeEach(func() { - fakeCloudControllerClient.GetAccessRulesReturns( - nil, - ccv3.IncludedResources{}, - ccv3.Warnings{"get-access-rules-warning"}, - errors.New("api error"), - ) - }) - - It("returns the error and warnings", func() { - Expect(executeErr).To(MatchError("api error")) - Expect(warnings).To(ConsistOf("get-access-rules-warning")) - Expect(results).To(BeNil()) - }) - }) - - When("getting domain by name fails", func() { - BeforeEach(func() { - domainName = "invalid-domain.com" - - // Mock GetAccessRules to return at least one access rule - fakeCloudControllerClient.GetAccessRulesReturns( - []resources.AccessRule{ - {GUID: "access-rule-guid-1", RouteGUID: "route-guid-1"}, - }, - ccv3.IncludedResources{ - Routes: []resources.Route{ - {GUID: "route-guid-1", DomainGUID: "domain-guid-1"}, - }, - }, - ccv3.Warnings{"get-access-rules-warning"}, - nil, - ) - - fakeCloudControllerClient.GetDomainsReturns( - nil, - ccv3.Warnings{"get-domains-warning"}, - actionerror.DomainNotFoundError{Name: "invalid-domain.com"}, - ) - }) - - It("returns the error and warnings", func() { - Expect(executeErr).To(MatchError(actionerror.DomainNotFoundError{Name: "invalid-domain.com"})) - Expect(warnings).To(ConsistOf("get-access-rules-warning", "get-domains-warning")) - Expect(results).To(BeNil()) - }) - }) - - When("resolving domain name fails", func() { - BeforeEach(func() { - fakeCloudControllerClient.GetAccessRulesReturns( - []resources.AccessRule{ - { - GUID: "rule-guid-1", - Name: "rule-1", - Selector: "cf:any", - RouteGUID: "route-guid-1", - }, - }, - ccv3.IncludedResources{ - Routes: []resources.Route{ - { - GUID: "route-guid-1", - SpaceGUID: "space-guid-1", - DomainGUID: "domain-guid-1", - Host: "app1", - }, - }, - }, - ccv3.Warnings{"get-access-rules-warning"}, - nil, - ) - - // Domain lookup fails - fakeCloudControllerClient.GetDomainReturns( - resources.Domain{}, - ccv3.Warnings{"get-domain-warning"}, - errors.New("domain lookup error"), - ) - }) - - It("uses the domain GUID as fallback and continues", func() { - Expect(executeErr).ToNot(HaveOccurred()) - Expect(results).To(HaveLen(1)) - Expect(results[0].DomainName).To(Equal("domain-guid-1")) - Expect(warnings).To(ContainElement("get-domain-warning")) - }) - }) - - When("resolving target name fails", func() { - BeforeEach(func() { - fakeCloudControllerClient.GetAccessRulesReturns( - []resources.AccessRule{ - { - GUID: "rule-guid-1", - Name: "rule-1", - Selector: "cf:app:app-guid-1", - RouteGUID: "route-guid-1", - }, - }, - ccv3.IncludedResources{ - Routes: []resources.Route{ - { - GUID: "route-guid-1", - SpaceGUID: "space-guid-1", - DomainGUID: "domain-guid-1", - Host: "app1", - }, - }, - }, - ccv3.Warnings{"get-access-rules-warning"}, - nil, - ) - - fakeCloudControllerClient.GetDomainReturns( - resources.Domain{GUID: "domain-guid-1", Name: "example.com"}, - ccv3.Warnings{"get-domain-warning"}, - nil, - ) - - // App lookup fails - fakeCloudControllerClient.GetApplicationsReturns( - nil, - ccv3.Warnings{"get-app-warning"}, - errors.New("app lookup error"), - ) - }) - - It("leaves source name blank and populates scope type", func() { - Expect(executeErr).ToNot(HaveOccurred()) - Expect(results).To(HaveLen(1)) - Expect(results[0].ScopeType).To(Equal("app")) - Expect(results[0].SourceName).To(Equal("")) - Expect(warnings).To(ContainElement("get-app-warning")) - }) - }) - }) - - // Note: resolveAccessRuleTarget and splitSelector are unexported methods - // and are tested indirectly through GetAccessRulesForSpace above. - - Describe("GetAccessRulesByRoute", func() { - var ( - domainName string - hostname string - path string - - rules []resources.AccessRule - warnings Warnings - executeErr error - ) - - BeforeEach(func() { - domainName = "example.com" - hostname = "myapp" - path = "" - }) - - JustBeforeEach(func() { - rules, warnings, executeErr = actor.GetAccessRulesByRoute(domainName, hostname, path) - }) - - When("the route exists with access rules", func() { - BeforeEach(func() { - fakeCloudControllerClient.GetDomainsReturns( - []resources.Domain{ - {GUID: "domain-guid-1", Name: "example.com"}, - }, - ccv3.Warnings{"get-domains-warning"}, - nil, - ) - - fakeCloudControllerClient.GetRoutesReturns( - []resources.Route{ - { - GUID: "route-guid-1", - SpaceGUID: "space-guid-1", - DomainGUID: "domain-guid-1", - Host: "myapp", - }, - }, - ccv3.Warnings{"get-routes-warning"}, - nil, - ) - - fakeCloudControllerClient.GetAccessRulesReturns( - []resources.AccessRule{ - {GUID: "rule-guid-1", Name: "rule-1", Selector: "cf:any"}, - {GUID: "rule-guid-2", Name: "rule-2", Selector: "cf:app:app-guid-1"}, - }, - ccv3.IncludedResources{}, - ccv3.Warnings{"get-access-rules-warning"}, - nil, - ) - }) - - It("returns the access rules", func() { - Expect(executeErr).ToNot(HaveOccurred()) - Expect(rules).To(HaveLen(2)) - Expect(rules[0].Selector).To(Equal("cf:app:app-guid-1")) - Expect(rules[1].Selector).To(Equal("cf:app:app-guid-2")) - Expect(warnings).To(ConsistOf( - "get-domains-warning", - "get-routes-warning", - "get-access-rules-warning", - )) - }) - }) - - When("the route does not exist", func() { - BeforeEach(func() { - fakeCloudControllerClient.GetDomainsReturns( - []resources.Domain{ - {GUID: "domain-guid-1", Name: "example.com"}, - }, - ccv3.Warnings{"get-domains-warning"}, - nil, - ) - - fakeCloudControllerClient.GetRoutesReturns( - []resources.Route{}, - ccv3.Warnings{"get-routes-warning"}, - nil, - ) - }) - - It("returns a RouteNotFoundError", func() { - Expect(executeErr).To(MatchError(actionerror.RouteNotFoundError{ - Host: "myapp", - DomainName: "example.com", - Path: "", - })) - Expect(warnings).To(ConsistOf("get-domains-warning", "get-routes-warning")) - }) - }) - }) - - Describe("AddAccessRule", func() { - var ( - domainName string - selector string - hostname string - path string - - warnings Warnings - executeErr error - ) - - BeforeEach(func() { - domainName = "example.com" - selector = "cf:app:app-guid-1" - hostname = "myapp" - path = "" - }) - - JustBeforeEach(func() { - warnings, executeErr = actor.AddAccessRule(domainName, selector, hostname, path) - }) - - When("creating the access rule succeeds", func() { - BeforeEach(func() { - fakeCloudControllerClient.GetDomainsReturns( - []resources.Domain{ - {GUID: "domain-guid-1", Name: "example.com"}, - }, - ccv3.Warnings{"get-domains-warning"}, - nil, - ) - - fakeCloudControllerClient.GetRoutesReturns( - []resources.Route{ - { - GUID: "route-guid-1", - SpaceGUID: "space-guid-1", - DomainGUID: "domain-guid-1", - Host: "myapp", - }, - }, - ccv3.Warnings{"get-routes-warning"}, - nil, - ) - - fakeCloudControllerClient.CreateAccessRuleReturns( - resources.AccessRule{GUID: "rule-guid-1", Name: "my-rule"}, - ccv3.Warnings{"create-rule-warning"}, - nil, - ) - }) - - It("creates the access rule and returns warnings", func() { - Expect(executeErr).ToNot(HaveOccurred()) - Expect(warnings).To(ConsistOf( - "get-domains-warning", - "get-routes-warning", - "create-rule-warning", - )) - - Expect(fakeCloudControllerClient.CreateAccessRuleCallCount()).To(Equal(1)) - rule := fakeCloudControllerClient.CreateAccessRuleArgsForCall(0) - Expect(rule.Selector).To(Equal("cf:app:app-guid-1")) - Expect(rule.RouteGUID).To(Equal("route-guid-1")) - }) - }) - - When("the route does not exist", func() { - BeforeEach(func() { - fakeCloudControllerClient.GetDomainsReturns( - []resources.Domain{ - {GUID: "domain-guid-1", Name: "example.com"}, - }, - ccv3.Warnings{"get-domains-warning"}, - nil, - ) - - fakeCloudControllerClient.GetRoutesReturns( - []resources.Route{}, - ccv3.Warnings{"get-routes-warning"}, - nil, - ) - }) - - It("returns a RouteNotFoundError", func() { - Expect(executeErr).To(MatchError(actionerror.RouteNotFoundError{ - Host: "myapp", - DomainName: "example.com", - Path: "", - })) - }) - }) - }) - - Describe("DeleteAccessRuleBySelector", func() { - var ( - selector string - domainName string - hostname string - path string - - warnings Warnings - executeErr error - ) - - BeforeEach(func() { - selector = "cf:any" - domainName = "example.com" - hostname = "myapp" - path = "" - }) - - JustBeforeEach(func() { - warnings, executeErr = actor.DeleteAccessRuleBySelector(domainName, selector, hostname, path) - }) - - When("the access rule exists", func() { - BeforeEach(func() { - fakeCloudControllerClient.GetDomainsReturns( - []resources.Domain{ - {GUID: "domain-guid-1", Name: "example.com"}, - }, - ccv3.Warnings{"get-domains-warning"}, - nil, - ) - - fakeCloudControllerClient.GetRoutesReturns( - []resources.Route{ - { - GUID: "route-guid-1", - SpaceGUID: "space-guid-1", - DomainGUID: "domain-guid-1", - Host: "myapp", - }, - }, - ccv3.Warnings{"get-routes-warning"}, - nil, - ) - - fakeCloudControllerClient.GetAccessRulesReturns( - []resources.AccessRule{ - {GUID: "rule-guid-1", Selector: "cf:any"}, - }, - ccv3.IncludedResources{}, - ccv3.Warnings{"get-access-rules-warning"}, - nil, - ) - - fakeCloudControllerClient.DeleteAccessRuleReturns( - ccv3.JobURL(""), - ccv3.Warnings{"delete-rule-warning"}, - nil, - ) - }) - - It("deletes the access rule and returns warnings", func() { - Expect(executeErr).ToNot(HaveOccurred()) - Expect(warnings).To(ConsistOf( - "get-domains-warning", - "get-routes-warning", - "get-access-rules-warning", - "delete-rule-warning", - )) - - Expect(fakeCloudControllerClient.DeleteAccessRuleCallCount()).To(Equal(1)) - guid := fakeCloudControllerClient.DeleteAccessRuleArgsForCall(0) - Expect(guid).To(Equal("rule-guid-1")) - }) - }) - - When("the access rule does not exist", func() { - BeforeEach(func() { - fakeCloudControllerClient.GetDomainsReturns( - []resources.Domain{ - {GUID: "domain-guid-1", Name: "example.com"}, - }, - ccv3.Warnings{"get-domains-warning"}, - nil, - ) - - fakeCloudControllerClient.GetRoutesReturns( - []resources.Route{ - { - GUID: "route-guid-1", - SpaceGUID: "space-guid-1", - DomainGUID: "domain-guid-1", - Host: "myapp", - }, - }, - ccv3.Warnings{"get-routes-warning"}, - nil, - ) - - fakeCloudControllerClient.GetAccessRulesReturns( - []resources.AccessRule{ - {GUID: "rule-guid-other", Selector: "cf:app:other-guid"}, - }, - ccv3.IncludedResources{}, - ccv3.Warnings{"get-access-rules-warning"}, - nil, - ) - }) - - It("returns an AccessRuleNotFoundError", func() { - Expect(executeErr).To(MatchError(actionerror.AccessRuleNotFoundError{Selector: "cf:any"})) - Expect(warnings).To(ConsistOf( - "get-domains-warning", - "get-routes-warning", - "get-access-rules-warning", - )) - }) - }) -}) -}) diff --git a/actor/v7action/cloud_controller_client.go b/actor/v7action/cloud_controller_client.go index 223f7344a2f..eeced084370 100644 --- a/actor/v7action/cloud_controller_client.go +++ b/actor/v7action/cloud_controller_client.go @@ -20,7 +20,7 @@ type CloudControllerClient interface { CancelDeployment(deploymentGUID string) (ccv3.Warnings, error) ContinueDeployment(deploymentGUID string) (ccv3.Warnings, error) CopyPackage(sourcePackageGUID string, targetAppGUID string) (resources.Package, ccv3.Warnings, error) - CreateAccessRule(accessRule resources.AccessRule) (resources.AccessRule, ccv3.Warnings, error) + CreateRoutePolicy(routePolicy resources.RoutePolicy) (resources.RoutePolicy, ccv3.Warnings, error) CreateApplication(app resources.Application) (resources.Application, ccv3.Warnings, error) CreateApplicationDeployment(dep resources.Deployment) (string, ccv3.Warnings, error) CreateApplicationProcessScale(appGUID string, process resources.Process) (resources.Process, ccv3.Warnings, error) @@ -43,7 +43,7 @@ type CloudControllerClient interface { CreateSpace(space resources.Space) (resources.Space, ccv3.Warnings, error) CreateSpaceQuota(spaceQuota resources.SpaceQuota) (resources.SpaceQuota, ccv3.Warnings, error) CreateUser(userGUID string) (resources.User, ccv3.Warnings, error) - DeleteAccessRule(guid string) (ccv3.JobURL, ccv3.Warnings, error) + DeleteRoutePolicy(guid string) (ccv3.JobURL, ccv3.Warnings, error) DeleteApplication(guid string) (ccv3.JobURL, ccv3.Warnings, error) DeleteApplicationProcessInstance(appGUID string, processType string, instanceIndex int) (ccv3.Warnings, error) DeleteBuildpack(buildpackGUID string) (ccv3.JobURL, ccv3.Warnings, error) @@ -65,7 +65,7 @@ type CloudControllerClient interface { DeleteUser(userGUID string) (ccv3.JobURL, ccv3.Warnings, error) DownloadDroplet(dropletGUID string) ([]byte, ccv3.Warnings, error) EntitleIsolationSegmentToOrganizations(isoGUID string, orgGUIDs []string) (resources.RelationshipList, ccv3.Warnings, error) - GetAccessRules(query ...ccv3.Query) ([]resources.AccessRule, ccv3.IncludedResources, ccv3.Warnings, error) + GetRoutePolicies(query ...ccv3.Query) ([]resources.RoutePolicy, ccv3.IncludedResources, ccv3.Warnings, error) GetApplicationByNameAndSpace(appName string, spaceGUID string) (resources.Application, ccv3.Warnings, error) GetApplicationDropletCurrent(appGUID string) (resources.Droplet, ccv3.Warnings, error) GetApplicationEnvironment(appGUID string) (ccv3.Environment, ccv3.Warnings, error) diff --git a/actor/v7action/domain.go b/actor/v7action/domain.go index cf65ca2bfa3..f7307da5ade 100644 --- a/actor/v7action/domain.go +++ b/actor/v7action/domain.go @@ -43,10 +43,10 @@ func (actor Actor) CreateSharedDomain(domainName string, internal bool, routerGr RouterGroup: routerGroupGUID, } - // Set enforce_access_rules if specified + // Set enforce_route_policies if specified if enforceAccessRules { - domain.EnforceAccessRules = types.NullBool{IsSet: true, Value: true} - domain.AccessRulesScope = accessRulesScope + domain.EnforceRoutePolicies = types.NullBool{IsSet: true, Value: true} + domain.RoutePoliciesScope = accessRulesScope } _, warnings, err := actor.CloudControllerClient.CreateDomain(domain) @@ -63,16 +63,16 @@ func (actor Actor) CreatePrivateDomain(domainName string, orgName string, enforc if err != nil { return allWarnings, err } - + domain := resources.Domain{ Name: domainName, OrganizationGUID: organization.GUID, } - // Set enforce_access_rules if specified + // Set enforce_route_policies if specified if enforceAccessRules { - domain.EnforceAccessRules = types.NullBool{IsSet: true, Value: true} - domain.AccessRulesScope = accessRulesScope + domain.EnforceRoutePolicies = types.NullBool{IsSet: true, Value: true} + domain.RoutePoliciesScope = accessRulesScope } _, apiWarnings, err := actor.CloudControllerClient.CreateDomain(domain) diff --git a/actor/v7action/access_rule.go b/actor/v7action/route_policy.go similarity index 69% rename from actor/v7action/access_rule.go rename to actor/v7action/route_policy.go index 909fc8dffdc..07068fb9745 100644 --- a/actor/v7action/access_rule.go +++ b/actor/v7action/route_policy.go @@ -6,10 +6,10 @@ import ( "code.cloudfoundry.org/cli/v9/resources" ) -func (actor Actor) AddAccessRule(domainName, selector, hostname, path string) (Warnings, error) { +func (actor Actor) AddRoutePolicy(domainName, source, hostname, path string) (Warnings, error) { allWarnings := Warnings{} - // Get the domain to ensure it exists and supports access rules + // Get the domain to ensure it exists and supports route policies domain, warnings, err := actor.GetDomainByName(domainName) allWarnings = append(allWarnings, warnings...) if err != nil { @@ -33,19 +33,19 @@ func (actor Actor) AddAccessRule(domainName, selector, hostname, path string) (W route := routes[0] - // Create the access rule - accessRule := resources.AccessRule{ - Selector: selector, + // Create the route policy + routePolicy := resources.RoutePolicy{ + Source: source, RouteGUID: route.GUID, } - _, apiWarnings, err := actor.CloudControllerClient.CreateAccessRule(accessRule) + _, apiWarnings, err := actor.CloudControllerClient.CreateRoutePolicy(routePolicy) allWarnings = append(allWarnings, Warnings(apiWarnings)...) return allWarnings, err } -func (actor Actor) GetAccessRulesByRoute(domainName, hostname, path string) ([]resources.AccessRule, Warnings, error) { +func (actor Actor) GetRoutePoliciesByRoute(domainName, hostname, path string) ([]resources.RoutePolicy, Warnings, error) { allWarnings := Warnings{} // Get the domain @@ -72,21 +72,21 @@ func (actor Actor) GetAccessRulesByRoute(domainName, hostname, path string) ([]r route := routes[0] - // Get access rules for this route - accessRules, _, apiWarnings, err := actor.CloudControllerClient.GetAccessRules( + // Get route policies for this route + routePolicies, _, apiWarnings, err := actor.CloudControllerClient.GetRoutePolicies( ccv3.Query{Key: ccv3.RouteGUIDFilter, Values: []string{route.GUID}}, ) allWarnings = append(allWarnings, Warnings(apiWarnings)...) - var rules []resources.AccessRule - for _, rule := range accessRules { - rules = append(rules, resources.AccessRule(rule)) + var policies []resources.RoutePolicy + for _, policy := range routePolicies { + policies = append(policies, resources.RoutePolicy(policy)) } - return rules, allWarnings, err + return policies, allWarnings, err } -func (actor Actor) DeleteAccessRuleBySelector(domainName, selector, hostname, path string) (Warnings, error) { +func (actor Actor) DeleteRoutePolicyBySource(domainName, source, hostname, path string) (Warnings, error) { allWarnings := Warnings{} // Get the domain @@ -113,8 +113,8 @@ func (actor Actor) DeleteAccessRuleBySelector(domainName, selector, hostname, pa route := routes[0] - // Get access rules for this route to find the one with matching selector - accessRules, _, apiWarnings, err := actor.CloudControllerClient.GetAccessRules( + // Get route policies for this route to find the one with matching source + routePolicies, _, apiWarnings, err := actor.CloudControllerClient.GetRoutePolicies( ccv3.Query{Key: ccv3.RouteGUIDFilter, Values: []string{route.GUID}}, ) allWarnings = append(allWarnings, Warnings(apiWarnings)...) @@ -122,27 +122,26 @@ func (actor Actor) DeleteAccessRuleBySelector(domainName, selector, hostname, pa return allWarnings, err } - // Find the rule with matching selector - var ruleGUID string - for _, rule := range accessRules { - if rule.Selector == selector { - ruleGUID = rule.GUID + // Find the policy with matching source + var policyGUID string + for _, policy := range routePolicies { + if policy.Source == source { + policyGUID = policy.GUID break } } - if ruleGUID == "" { - return allWarnings, actionerror.AccessRuleNotFoundError{Selector: selector} + if policyGUID == "" { + return allWarnings, actionerror.RoutePolicyNotFoundError{Source: source} } - // Delete the access rule - _, deleteWarnings, err := actor.CloudControllerClient.DeleteAccessRule(ruleGUID) + // Delete the route policy + _, deleteWarnings, err := actor.CloudControllerClient.DeleteRoutePolicy(policyGUID) allWarnings = append(allWarnings, Warnings(deleteWarnings)...) return allWarnings, err } - // GetRoutesByDomain gets routes for a domain with optional hostname and path filters func (actor Actor) GetRoutesByDomain(domainGUID, hostname, path string) ([]resources.Route, Warnings, error) { queries := []ccv3.Query{ @@ -170,26 +169,26 @@ func (actor Actor) GetRoutesByDomain(domainGUID, hostname, path string) ([]resou return routes, Warnings(warnings), nil } -// AccessRuleWithRoute combines an access rule with its associated route information -type AccessRuleWithRoute struct { - resources.AccessRule +// RoutePolicyWithRoute combines a route policy with its associated route information +type RoutePolicyWithRoute struct { + resources.RoutePolicy Route resources.Route DomainName string ScopeType string // "app", "space", "org", or "any" SourceName string // Resolved source name (app/space/org) or empty string } -// GetAccessRulesForSpace gets all access rules for routes in a space with optional filters -func (actor Actor) GetAccessRulesForSpace( +// GetRoutePoliciesForSpace gets all route policies for routes in a space with optional filters +func (actor Actor) GetRoutePoliciesForSpace( spaceGUID string, domainName string, hostname string, path string, labelSelector string, -) ([]AccessRuleWithRoute, Warnings, error) { +) ([]RoutePolicyWithRoute, Warnings, error) { allWarnings := Warnings{} - // Build query for access rules filtered by space, with included routes + // Build query for route policies filtered by space, with included routes queries := []ccv3.Query{ {Key: ccv3.SpaceGUIDFilter, Values: []string{spaceGUID}}, {Key: ccv3.Include, Values: []string{"route"}}, @@ -200,16 +199,16 @@ func (actor Actor) GetAccessRulesForSpace( queries = append(queries, ccv3.Query{Key: ccv3.LabelSelectorFilter, Values: []string{labelSelector}}) } - // Fetch access rules directly by space GUID with included routes (single API call) - accessRules, includedResources, apiWarnings, err := actor.CloudControllerClient.GetAccessRules(queries...) + // Fetch route policies directly by space GUID with included routes (single API call) + routePolicies, includedResources, apiWarnings, err := actor.CloudControllerClient.GetRoutePolicies(queries...) allWarnings = append(allWarnings, Warnings(apiWarnings)...) if err != nil { return nil, allWarnings, err } - if len(accessRules) == 0 { - // No access rules found - return empty list, not an error - return []AccessRuleWithRoute{}, allWarnings, nil + if len(routePolicies) == 0 { + // No route policies found - return empty list, not an error + return []RoutePolicyWithRoute{}, allWarnings, nil } // Build route lookup map from included resources @@ -273,60 +272,60 @@ func (actor Actor) GetAccessRulesForSpace( } // Build results with route information and resolved sources - // Only include access rules whose routes match the filters - var results []AccessRuleWithRoute - for _, rule := range accessRules { - route, exists := routeByGUID[rule.RouteGUID] + // Only include route policies whose routes match the filters + var results []RoutePolicyWithRoute + for _, policy := range routePolicies { + route, exists := routeByGUID[policy.RouteGUID] if !exists { - // Skip rules for routes that don't match the optional filters + // Skip policies for routes that don't match the optional filters continue } - scopeType, sourceName, warnings, err := actor.resolveAccessRuleSource(rule.Selector) + scopeType, sourceName, warnings, err := actor.resolveRoutePolicySource(policy.Source) allWarnings = append(allWarnings, warnings...) if err != nil { // If we can't resolve the source, sourceName is already empty string // scopeType is still set correctly } - results = append(results, AccessRuleWithRoute{ - AccessRule: resources.AccessRule(rule), - Route: route, - DomainName: domainCache[route.DomainGUID], - ScopeType: scopeType, - SourceName: sourceName, + results = append(results, RoutePolicyWithRoute{ + RoutePolicy: resources.RoutePolicy(policy), + Route: route, + DomainName: domainCache[route.DomainGUID], + ScopeType: scopeType, + SourceName: sourceName, }) } return results, allWarnings, nil } -// resolveAccessRuleSource resolves a selector to scope type and human-readable source name -func (actor Actor) resolveAccessRuleSource(selector string) (scopeType string, sourceName string, warnings Warnings, err error) { +// resolveRoutePolicySource resolves a source to scope type and human-readable source name +func (actor Actor) resolveRoutePolicySource(source string) (scopeType string, sourceName string, warnings Warnings, err error) { allWarnings := Warnings{} - // Parse selector format: cf:app:, cf:space:, cf:org:, or cf:any - if selector == "cf:any" { + // Parse source format: cf:app:, cf:space:, cf:org:, or cf:any + if source == "cf:any" { return "any", "", nil, nil } - // Split selector into parts + // Split source into parts // Expected format: cf:type:guid const prefix = "cf:" - if len(selector) < len(prefix) { + if len(source) < len(prefix) { return "unknown", "", nil, nil } - selectorBody := selector[len(prefix):] - parts := splitSelector(selectorBody) + sourceBody := source[len(prefix):] + parts := splitSource(sourceBody) if len(parts) < 2 { return "unknown", "", nil, nil } - selectorType := parts[0] + sourceType := parts[0] guid := parts[1] - switch selectorType { + switch sourceType { case "app": apps, apiWarnings, err := actor.CloudControllerClient.GetApplications( ccv3.Query{Key: ccv3.GUIDFilter, Values: []string{guid}}, @@ -362,9 +361,9 @@ func (actor Actor) resolveAccessRuleSource(selector string) (scopeType string, s } } -// splitSelector splits a selector body by colon, handling the case where -// the selector might be "type:guid" format -func splitSelector(s string) []string { +// splitSource splits a source body by colon, handling the case where +// the source might be "type:guid" format +func splitSource(s string) []string { var parts []string current := "" for _, char := range s { diff --git a/actor/v7action/v7actionfakes/fake_cloud_controller_client.go b/actor/v7action/v7actionfakes/fake_cloud_controller_client.go index 27c4b830379..f8e3eaa7fd0 100644 --- a/actor/v7action/v7actionfakes/fake_cloud_controller_client.go +++ b/actor/v7action/v7actionfakes/fake_cloud_controller_client.go @@ -106,21 +106,6 @@ type FakeCloudControllerClient struct { result2 ccv3.Warnings result3 error } - CreateAccessRuleStub func(resources.AccessRule) (resources.AccessRule, ccv3.Warnings, error) - createAccessRuleMutex sync.RWMutex - createAccessRuleArgsForCall []struct { - arg1 resources.AccessRule - } - createAccessRuleReturns struct { - result1 resources.AccessRule - result2 ccv3.Warnings - result3 error - } - createAccessRuleReturnsOnCall map[int]struct { - result1 resources.AccessRule - result2 ccv3.Warnings - result3 error - } CreateApplicationStub func(resources.Application) (resources.Application, ccv3.Warnings, error) createApplicationMutex sync.RWMutex createApplicationArgsForCall []struct { @@ -348,6 +333,21 @@ type FakeCloudControllerClient struct { result2 ccv3.Warnings result3 error } + CreateRoutePolicyStub func(resources.RoutePolicy) (resources.RoutePolicy, ccv3.Warnings, error) + createRoutePolicyMutex sync.RWMutex + createRoutePolicyArgsForCall []struct { + arg1 resources.RoutePolicy + } + createRoutePolicyReturns struct { + result1 resources.RoutePolicy + result2 ccv3.Warnings + result3 error + } + createRoutePolicyReturnsOnCall map[int]struct { + result1 resources.RoutePolicy + result2 ccv3.Warnings + result3 error + } CreateSecurityGroupStub func(resources.SecurityGroup) (resources.SecurityGroup, ccv3.Warnings, error) createSecurityGroupMutex sync.RWMutex createSecurityGroupArgsForCall []struct { @@ -453,21 +453,6 @@ type FakeCloudControllerClient struct { result2 ccv3.Warnings result3 error } - DeleteAccessRuleStub func(string) (ccv3.JobURL, ccv3.Warnings, error) - deleteAccessRuleMutex sync.RWMutex - deleteAccessRuleArgsForCall []struct { - arg1 string - } - deleteAccessRuleReturns struct { - result1 ccv3.JobURL - result2 ccv3.Warnings - result3 error - } - deleteAccessRuleReturnsOnCall map[int]struct { - result1 ccv3.JobURL - result2 ccv3.Warnings - result3 error - } DeleteApplicationStub func(string) (ccv3.JobURL, ccv3.Warnings, error) deleteApplicationMutex sync.RWMutex deleteApplicationArgsForCall []struct { @@ -645,6 +630,21 @@ type FakeCloudControllerClient struct { result2 ccv3.Warnings result3 error } + DeleteRoutePolicyStub func(string) (ccv3.JobURL, ccv3.Warnings, error) + deleteRoutePolicyMutex sync.RWMutex + deleteRoutePolicyArgsForCall []struct { + arg1 string + } + deleteRoutePolicyReturns struct { + result1 ccv3.JobURL + result2 ccv3.Warnings + result3 error + } + deleteRoutePolicyReturnsOnCall map[int]struct { + result1 ccv3.JobURL + result2 ccv3.Warnings + result3 error + } DeleteSecurityGroupStub func(string) (ccv3.JobURL, ccv3.Warnings, error) deleteSecurityGroupMutex sync.RWMutex deleteSecurityGroupArgsForCall []struct { @@ -796,23 +796,6 @@ type FakeCloudControllerClient struct { result2 ccv3.Warnings result3 error } - GetAccessRulesStub func(...ccv3.Query) ([]resources.AccessRule, ccv3.IncludedResources, ccv3.Warnings, error) - getAccessRulesMutex sync.RWMutex - getAccessRulesArgsForCall []struct { - arg1 []ccv3.Query - } - getAccessRulesReturns struct { - result1 []resources.AccessRule - result2 ccv3.IncludedResources - result3 ccv3.Warnings - result4 error - } - getAccessRulesReturnsOnCall map[int]struct { - result1 []resources.AccessRule - result2 ccv3.IncludedResources - result3 ccv3.Warnings - result4 error - } GetAppFeatureStub func(string, string) (resources.ApplicationFeature, ccv3.Warnings, error) getAppFeatureMutex sync.RWMutex getAppFeatureArgsForCall []struct { @@ -1542,6 +1525,23 @@ type FakeCloudControllerClient struct { result2 ccv3.Warnings result3 error } + GetRoutePoliciesStub func(...ccv3.Query) ([]resources.RoutePolicy, ccv3.IncludedResources, ccv3.Warnings, error) + getRoutePoliciesMutex sync.RWMutex + getRoutePoliciesArgsForCall []struct { + arg1 []ccv3.Query + } + getRoutePoliciesReturns struct { + result1 []resources.RoutePolicy + result2 ccv3.IncludedResources + result3 ccv3.Warnings + result4 error + } + getRoutePoliciesReturnsOnCall map[int]struct { + result1 []resources.RoutePolicy + result2 ccv3.IncludedResources + result3 ccv3.Warnings + result4 error + } GetRoutesStub func(...ccv3.Query) ([]resources.Route, ccv3.Warnings, error) getRoutesMutex sync.RWMutex getRoutesArgsForCall []struct { @@ -3294,73 +3294,6 @@ func (fake *FakeCloudControllerClient) CopyPackageReturnsOnCall(i int, result1 r }{result1, result2, result3} } -func (fake *FakeCloudControllerClient) CreateAccessRule(arg1 resources.AccessRule) (resources.AccessRule, ccv3.Warnings, error) { - fake.createAccessRuleMutex.Lock() - ret, specificReturn := fake.createAccessRuleReturnsOnCall[len(fake.createAccessRuleArgsForCall)] - fake.createAccessRuleArgsForCall = append(fake.createAccessRuleArgsForCall, struct { - arg1 resources.AccessRule - }{arg1}) - stub := fake.CreateAccessRuleStub - fakeReturns := fake.createAccessRuleReturns - fake.recordInvocation("CreateAccessRule", []interface{}{arg1}) - fake.createAccessRuleMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2, ret.result3 - } - return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 -} - -func (fake *FakeCloudControllerClient) CreateAccessRuleCallCount() int { - fake.createAccessRuleMutex.RLock() - defer fake.createAccessRuleMutex.RUnlock() - return len(fake.createAccessRuleArgsForCall) -} - -func (fake *FakeCloudControllerClient) CreateAccessRuleCalls(stub func(resources.AccessRule) (resources.AccessRule, ccv3.Warnings, error)) { - fake.createAccessRuleMutex.Lock() - defer fake.createAccessRuleMutex.Unlock() - fake.CreateAccessRuleStub = stub -} - -func (fake *FakeCloudControllerClient) CreateAccessRuleArgsForCall(i int) resources.AccessRule { - fake.createAccessRuleMutex.RLock() - defer fake.createAccessRuleMutex.RUnlock() - argsForCall := fake.createAccessRuleArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeCloudControllerClient) CreateAccessRuleReturns(result1 resources.AccessRule, result2 ccv3.Warnings, result3 error) { - fake.createAccessRuleMutex.Lock() - defer fake.createAccessRuleMutex.Unlock() - fake.CreateAccessRuleStub = nil - fake.createAccessRuleReturns = struct { - result1 resources.AccessRule - result2 ccv3.Warnings - result3 error - }{result1, result2, result3} -} - -func (fake *FakeCloudControllerClient) CreateAccessRuleReturnsOnCall(i int, result1 resources.AccessRule, result2 ccv3.Warnings, result3 error) { - fake.createAccessRuleMutex.Lock() - defer fake.createAccessRuleMutex.Unlock() - fake.CreateAccessRuleStub = nil - if fake.createAccessRuleReturnsOnCall == nil { - fake.createAccessRuleReturnsOnCall = make(map[int]struct { - result1 resources.AccessRule - result2 ccv3.Warnings - result3 error - }) - } - fake.createAccessRuleReturnsOnCall[i] = struct { - result1 resources.AccessRule - result2 ccv3.Warnings - result3 error - }{result1, result2, result3} -} - func (fake *FakeCloudControllerClient) CreateApplication(arg1 resources.Application) (resources.Application, ccv3.Warnings, error) { fake.createApplicationMutex.Lock() ret, specificReturn := fake.createApplicationReturnsOnCall[len(fake.createApplicationArgsForCall)] @@ -4368,6 +4301,73 @@ func (fake *FakeCloudControllerClient) CreateRouteBindingReturnsOnCall(i int, re }{result1, result2, result3} } +func (fake *FakeCloudControllerClient) CreateRoutePolicy(arg1 resources.RoutePolicy) (resources.RoutePolicy, ccv3.Warnings, error) { + fake.createRoutePolicyMutex.Lock() + ret, specificReturn := fake.createRoutePolicyReturnsOnCall[len(fake.createRoutePolicyArgsForCall)] + fake.createRoutePolicyArgsForCall = append(fake.createRoutePolicyArgsForCall, struct { + arg1 resources.RoutePolicy + }{arg1}) + stub := fake.CreateRoutePolicyStub + fakeReturns := fake.createRoutePolicyReturns + fake.recordInvocation("CreateRoutePolicy", []interface{}{arg1}) + fake.createRoutePolicyMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2, ret.result3 + } + return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 +} + +func (fake *FakeCloudControllerClient) CreateRoutePolicyCallCount() int { + fake.createRoutePolicyMutex.RLock() + defer fake.createRoutePolicyMutex.RUnlock() + return len(fake.createRoutePolicyArgsForCall) +} + +func (fake *FakeCloudControllerClient) CreateRoutePolicyCalls(stub func(resources.RoutePolicy) (resources.RoutePolicy, ccv3.Warnings, error)) { + fake.createRoutePolicyMutex.Lock() + defer fake.createRoutePolicyMutex.Unlock() + fake.CreateRoutePolicyStub = stub +} + +func (fake *FakeCloudControllerClient) CreateRoutePolicyArgsForCall(i int) resources.RoutePolicy { + fake.createRoutePolicyMutex.RLock() + defer fake.createRoutePolicyMutex.RUnlock() + argsForCall := fake.createRoutePolicyArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeCloudControllerClient) CreateRoutePolicyReturns(result1 resources.RoutePolicy, result2 ccv3.Warnings, result3 error) { + fake.createRoutePolicyMutex.Lock() + defer fake.createRoutePolicyMutex.Unlock() + fake.CreateRoutePolicyStub = nil + fake.createRoutePolicyReturns = struct { + result1 resources.RoutePolicy + result2 ccv3.Warnings + result3 error + }{result1, result2, result3} +} + +func (fake *FakeCloudControllerClient) CreateRoutePolicyReturnsOnCall(i int, result1 resources.RoutePolicy, result2 ccv3.Warnings, result3 error) { + fake.createRoutePolicyMutex.Lock() + defer fake.createRoutePolicyMutex.Unlock() + fake.CreateRoutePolicyStub = nil + if fake.createRoutePolicyReturnsOnCall == nil { + fake.createRoutePolicyReturnsOnCall = make(map[int]struct { + result1 resources.RoutePolicy + result2 ccv3.Warnings + result3 error + }) + } + fake.createRoutePolicyReturnsOnCall[i] = struct { + result1 resources.RoutePolicy + result2 ccv3.Warnings + result3 error + }{result1, result2, result3} +} + func (fake *FakeCloudControllerClient) CreateSecurityGroup(arg1 resources.SecurityGroup) (resources.SecurityGroup, ccv3.Warnings, error) { fake.createSecurityGroupMutex.Lock() ret, specificReturn := fake.createSecurityGroupReturnsOnCall[len(fake.createSecurityGroupArgsForCall)] @@ -4837,73 +4837,6 @@ func (fake *FakeCloudControllerClient) CreateUserReturnsOnCall(i int, result1 re }{result1, result2, result3} } -func (fake *FakeCloudControllerClient) DeleteAccessRule(arg1 string) (ccv3.JobURL, ccv3.Warnings, error) { - fake.deleteAccessRuleMutex.Lock() - ret, specificReturn := fake.deleteAccessRuleReturnsOnCall[len(fake.deleteAccessRuleArgsForCall)] - fake.deleteAccessRuleArgsForCall = append(fake.deleteAccessRuleArgsForCall, struct { - arg1 string - }{arg1}) - stub := fake.DeleteAccessRuleStub - fakeReturns := fake.deleteAccessRuleReturns - fake.recordInvocation("DeleteAccessRule", []interface{}{arg1}) - fake.deleteAccessRuleMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2, ret.result3 - } - return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 -} - -func (fake *FakeCloudControllerClient) DeleteAccessRuleCallCount() int { - fake.deleteAccessRuleMutex.RLock() - defer fake.deleteAccessRuleMutex.RUnlock() - return len(fake.deleteAccessRuleArgsForCall) -} - -func (fake *FakeCloudControllerClient) DeleteAccessRuleCalls(stub func(string) (ccv3.JobURL, ccv3.Warnings, error)) { - fake.deleteAccessRuleMutex.Lock() - defer fake.deleteAccessRuleMutex.Unlock() - fake.DeleteAccessRuleStub = stub -} - -func (fake *FakeCloudControllerClient) DeleteAccessRuleArgsForCall(i int) string { - fake.deleteAccessRuleMutex.RLock() - defer fake.deleteAccessRuleMutex.RUnlock() - argsForCall := fake.deleteAccessRuleArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeCloudControllerClient) DeleteAccessRuleReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) { - fake.deleteAccessRuleMutex.Lock() - defer fake.deleteAccessRuleMutex.Unlock() - fake.DeleteAccessRuleStub = nil - fake.deleteAccessRuleReturns = struct { - result1 ccv3.JobURL - result2 ccv3.Warnings - result3 error - }{result1, result2, result3} -} - -func (fake *FakeCloudControllerClient) DeleteAccessRuleReturnsOnCall(i int, result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) { - fake.deleteAccessRuleMutex.Lock() - defer fake.deleteAccessRuleMutex.Unlock() - fake.DeleteAccessRuleStub = nil - if fake.deleteAccessRuleReturnsOnCall == nil { - fake.deleteAccessRuleReturnsOnCall = make(map[int]struct { - result1 ccv3.JobURL - result2 ccv3.Warnings - result3 error - }) - } - fake.deleteAccessRuleReturnsOnCall[i] = struct { - result1 ccv3.JobURL - result2 ccv3.Warnings - result3 error - }{result1, result2, result3} -} - func (fake *FakeCloudControllerClient) DeleteApplication(arg1 string) (ccv3.JobURL, ccv3.Warnings, error) { fake.deleteApplicationMutex.Lock() ret, specificReturn := fake.deleteApplicationReturnsOnCall[len(fake.deleteApplicationArgsForCall)] @@ -5702,6 +5635,73 @@ func (fake *FakeCloudControllerClient) DeleteRouteBindingReturnsOnCall(i int, re }{result1, result2, result3} } +func (fake *FakeCloudControllerClient) DeleteRoutePolicy(arg1 string) (ccv3.JobURL, ccv3.Warnings, error) { + fake.deleteRoutePolicyMutex.Lock() + ret, specificReturn := fake.deleteRoutePolicyReturnsOnCall[len(fake.deleteRoutePolicyArgsForCall)] + fake.deleteRoutePolicyArgsForCall = append(fake.deleteRoutePolicyArgsForCall, struct { + arg1 string + }{arg1}) + stub := fake.DeleteRoutePolicyStub + fakeReturns := fake.deleteRoutePolicyReturns + fake.recordInvocation("DeleteRoutePolicy", []interface{}{arg1}) + fake.deleteRoutePolicyMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2, ret.result3 + } + return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 +} + +func (fake *FakeCloudControllerClient) DeleteRoutePolicyCallCount() int { + fake.deleteRoutePolicyMutex.RLock() + defer fake.deleteRoutePolicyMutex.RUnlock() + return len(fake.deleteRoutePolicyArgsForCall) +} + +func (fake *FakeCloudControllerClient) DeleteRoutePolicyCalls(stub func(string) (ccv3.JobURL, ccv3.Warnings, error)) { + fake.deleteRoutePolicyMutex.Lock() + defer fake.deleteRoutePolicyMutex.Unlock() + fake.DeleteRoutePolicyStub = stub +} + +func (fake *FakeCloudControllerClient) DeleteRoutePolicyArgsForCall(i int) string { + fake.deleteRoutePolicyMutex.RLock() + defer fake.deleteRoutePolicyMutex.RUnlock() + argsForCall := fake.deleteRoutePolicyArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeCloudControllerClient) DeleteRoutePolicyReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) { + fake.deleteRoutePolicyMutex.Lock() + defer fake.deleteRoutePolicyMutex.Unlock() + fake.DeleteRoutePolicyStub = nil + fake.deleteRoutePolicyReturns = struct { + result1 ccv3.JobURL + result2 ccv3.Warnings + result3 error + }{result1, result2, result3} +} + +func (fake *FakeCloudControllerClient) DeleteRoutePolicyReturnsOnCall(i int, result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) { + fake.deleteRoutePolicyMutex.Lock() + defer fake.deleteRoutePolicyMutex.Unlock() + fake.DeleteRoutePolicyStub = nil + if fake.deleteRoutePolicyReturnsOnCall == nil { + fake.deleteRoutePolicyReturnsOnCall = make(map[int]struct { + result1 ccv3.JobURL + result2 ccv3.Warnings + result3 error + }) + } + fake.deleteRoutePolicyReturnsOnCall[i] = struct { + result1 ccv3.JobURL + result2 ccv3.Warnings + result3 error + }{result1, result2, result3} +} + func (fake *FakeCloudControllerClient) DeleteSecurityGroup(arg1 string) (ccv3.JobURL, ccv3.Warnings, error) { fake.deleteSecurityGroupMutex.Lock() ret, specificReturn := fake.deleteSecurityGroupReturnsOnCall[len(fake.deleteSecurityGroupArgsForCall)] @@ -6377,76 +6377,6 @@ func (fake *FakeCloudControllerClient) EntitleIsolationSegmentToOrganizationsRet }{result1, result2, result3} } -func (fake *FakeCloudControllerClient) GetAccessRules(arg1 ...ccv3.Query) ([]resources.AccessRule, ccv3.IncludedResources, ccv3.Warnings, error) { - fake.getAccessRulesMutex.Lock() - ret, specificReturn := fake.getAccessRulesReturnsOnCall[len(fake.getAccessRulesArgsForCall)] - fake.getAccessRulesArgsForCall = append(fake.getAccessRulesArgsForCall, struct { - arg1 []ccv3.Query - }{arg1}) - stub := fake.GetAccessRulesStub - fakeReturns := fake.getAccessRulesReturns - fake.recordInvocation("GetAccessRules", []interface{}{arg1}) - fake.getAccessRulesMutex.Unlock() - if stub != nil { - return stub(arg1...) - } - if specificReturn { - return ret.result1, ret.result2, ret.result3, ret.result4 - } - return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3, fakeReturns.result4 -} - -func (fake *FakeCloudControllerClient) GetAccessRulesCallCount() int { - fake.getAccessRulesMutex.RLock() - defer fake.getAccessRulesMutex.RUnlock() - return len(fake.getAccessRulesArgsForCall) -} - -func (fake *FakeCloudControllerClient) GetAccessRulesCalls(stub func(...ccv3.Query) ([]resources.AccessRule, ccv3.IncludedResources, ccv3.Warnings, error)) { - fake.getAccessRulesMutex.Lock() - defer fake.getAccessRulesMutex.Unlock() - fake.GetAccessRulesStub = stub -} - -func (fake *FakeCloudControllerClient) GetAccessRulesArgsForCall(i int) []ccv3.Query { - fake.getAccessRulesMutex.RLock() - defer fake.getAccessRulesMutex.RUnlock() - argsForCall := fake.getAccessRulesArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeCloudControllerClient) GetAccessRulesReturns(result1 []resources.AccessRule, result2 ccv3.IncludedResources, result3 ccv3.Warnings, result4 error) { - fake.getAccessRulesMutex.Lock() - defer fake.getAccessRulesMutex.Unlock() - fake.GetAccessRulesStub = nil - fake.getAccessRulesReturns = struct { - result1 []resources.AccessRule - result2 ccv3.IncludedResources - result3 ccv3.Warnings - result4 error - }{result1, result2, result3, result4} -} - -func (fake *FakeCloudControllerClient) GetAccessRulesReturnsOnCall(i int, result1 []resources.AccessRule, result2 ccv3.IncludedResources, result3 ccv3.Warnings, result4 error) { - fake.getAccessRulesMutex.Lock() - defer fake.getAccessRulesMutex.Unlock() - fake.GetAccessRulesStub = nil - if fake.getAccessRulesReturnsOnCall == nil { - fake.getAccessRulesReturnsOnCall = make(map[int]struct { - result1 []resources.AccessRule - result2 ccv3.IncludedResources - result3 ccv3.Warnings - result4 error - }) - } - fake.getAccessRulesReturnsOnCall[i] = struct { - result1 []resources.AccessRule - result2 ccv3.IncludedResources - result3 ccv3.Warnings - result4 error - }{result1, result2, result3, result4} -} - func (fake *FakeCloudControllerClient) GetAppFeature(arg1 string, arg2 string) (resources.ApplicationFeature, ccv3.Warnings, error) { fake.getAppFeatureMutex.Lock() ret, specificReturn := fake.getAppFeatureReturnsOnCall[len(fake.getAppFeatureArgsForCall)] @@ -9653,6 +9583,76 @@ func (fake *FakeCloudControllerClient) GetRouteDestinationsReturnsOnCall(i int, }{result1, result2, result3} } +func (fake *FakeCloudControllerClient) GetRoutePolicies(arg1 ...ccv3.Query) ([]resources.RoutePolicy, ccv3.IncludedResources, ccv3.Warnings, error) { + fake.getRoutePoliciesMutex.Lock() + ret, specificReturn := fake.getRoutePoliciesReturnsOnCall[len(fake.getRoutePoliciesArgsForCall)] + fake.getRoutePoliciesArgsForCall = append(fake.getRoutePoliciesArgsForCall, struct { + arg1 []ccv3.Query + }{arg1}) + stub := fake.GetRoutePoliciesStub + fakeReturns := fake.getRoutePoliciesReturns + fake.recordInvocation("GetRoutePolicies", []interface{}{arg1}) + fake.getRoutePoliciesMutex.Unlock() + if stub != nil { + return stub(arg1...) + } + if specificReturn { + return ret.result1, ret.result2, ret.result3, ret.result4 + } + return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3, fakeReturns.result4 +} + +func (fake *FakeCloudControllerClient) GetRoutePoliciesCallCount() int { + fake.getRoutePoliciesMutex.RLock() + defer fake.getRoutePoliciesMutex.RUnlock() + return len(fake.getRoutePoliciesArgsForCall) +} + +func (fake *FakeCloudControllerClient) GetRoutePoliciesCalls(stub func(...ccv3.Query) ([]resources.RoutePolicy, ccv3.IncludedResources, ccv3.Warnings, error)) { + fake.getRoutePoliciesMutex.Lock() + defer fake.getRoutePoliciesMutex.Unlock() + fake.GetRoutePoliciesStub = stub +} + +func (fake *FakeCloudControllerClient) GetRoutePoliciesArgsForCall(i int) []ccv3.Query { + fake.getRoutePoliciesMutex.RLock() + defer fake.getRoutePoliciesMutex.RUnlock() + argsForCall := fake.getRoutePoliciesArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeCloudControllerClient) GetRoutePoliciesReturns(result1 []resources.RoutePolicy, result2 ccv3.IncludedResources, result3 ccv3.Warnings, result4 error) { + fake.getRoutePoliciesMutex.Lock() + defer fake.getRoutePoliciesMutex.Unlock() + fake.GetRoutePoliciesStub = nil + fake.getRoutePoliciesReturns = struct { + result1 []resources.RoutePolicy + result2 ccv3.IncludedResources + result3 ccv3.Warnings + result4 error + }{result1, result2, result3, result4} +} + +func (fake *FakeCloudControllerClient) GetRoutePoliciesReturnsOnCall(i int, result1 []resources.RoutePolicy, result2 ccv3.IncludedResources, result3 ccv3.Warnings, result4 error) { + fake.getRoutePoliciesMutex.Lock() + defer fake.getRoutePoliciesMutex.Unlock() + fake.GetRoutePoliciesStub = nil + if fake.getRoutePoliciesReturnsOnCall == nil { + fake.getRoutePoliciesReturnsOnCall = make(map[int]struct { + result1 []resources.RoutePolicy + result2 ccv3.IncludedResources + result3 ccv3.Warnings + result4 error + }) + } + fake.getRoutePoliciesReturnsOnCall[i] = struct { + result1 []resources.RoutePolicy + result2 ccv3.IncludedResources + result3 ccv3.Warnings + result4 error + }{result1, result2, result3, result4} +} + func (fake *FakeCloudControllerClient) GetRoutes(arg1 ...ccv3.Query) ([]resources.Route, ccv3.Warnings, error) { fake.getRoutesMutex.Lock() ret, specificReturn := fake.getRoutesReturnsOnCall[len(fake.getRoutesArgsForCall)] diff --git a/actor/v7action/v7actionfakes/fake_config.go b/actor/v7action/v7actionfakes/fake_config.go index cd46ebbbfc5..73a32a8baeb 100644 --- a/actor/v7action/v7actionfakes/fake_config.go +++ b/actor/v7action/v7actionfakes/fake_config.go @@ -1134,48 +1134,6 @@ func (fake *FakeConfig) UnsetOrganizationAndSpaceInformationCalls(stub func()) { func (fake *FakeConfig) Invocations() map[string][][]interface{} { fake.invocationsMutex.RLock() defer fake.invocationsMutex.RUnlock() - fake.aPIVersionMutex.RLock() - defer fake.aPIVersionMutex.RUnlock() - fake.accessTokenMutex.RLock() - defer fake.accessTokenMutex.RUnlock() - fake.currentUserMutex.RLock() - defer fake.currentUserMutex.RUnlock() - fake.dialTimeoutMutex.RLock() - defer fake.dialTimeoutMutex.RUnlock() - fake.isCFOnK8sMutex.RLock() - defer fake.isCFOnK8sMutex.RUnlock() - fake.pollingIntervalMutex.RLock() - defer fake.pollingIntervalMutex.RUnlock() - fake.refreshTokenMutex.RLock() - defer fake.refreshTokenMutex.RUnlock() - fake.sSHOAuthClientMutex.RLock() - defer fake.sSHOAuthClientMutex.RUnlock() - fake.setAccessTokenMutex.RLock() - defer fake.setAccessTokenMutex.RUnlock() - fake.setKubernetesAuthInfoMutex.RLock() - defer fake.setKubernetesAuthInfoMutex.RUnlock() - fake.setRefreshTokenMutex.RLock() - defer fake.setRefreshTokenMutex.RUnlock() - fake.setTargetInformationMutex.RLock() - defer fake.setTargetInformationMutex.RUnlock() - fake.setTokenInformationMutex.RLock() - defer fake.setTokenInformationMutex.RUnlock() - fake.setUAAClientCredentialsMutex.RLock() - defer fake.setUAAClientCredentialsMutex.RUnlock() - fake.setUAAGrantTypeMutex.RLock() - defer fake.setUAAGrantTypeMutex.RUnlock() - fake.skipSSLValidationMutex.RLock() - defer fake.skipSSLValidationMutex.RUnlock() - fake.stagingTimeoutMutex.RLock() - defer fake.stagingTimeoutMutex.RUnlock() - fake.startupTimeoutMutex.RLock() - defer fake.startupTimeoutMutex.RUnlock() - fake.targetMutex.RLock() - defer fake.targetMutex.RUnlock() - fake.uAAGrantTypeMutex.RLock() - defer fake.uAAGrantTypeMutex.RUnlock() - fake.unsetOrganizationAndSpaceInformationMutex.RLock() - defer fake.unsetOrganizationAndSpaceInformationMutex.RUnlock() copiedInvocations := map[string][][]interface{}{} for key, value := range fake.invocations { copiedInvocations[key] = value diff --git a/actor/v7action/v7actionfakes/fake_downloader.go b/actor/v7action/v7actionfakes/fake_downloader.go index 4545618272a..d77a875d875 100644 --- a/actor/v7action/v7actionfakes/fake_downloader.go +++ b/actor/v7action/v7actionfakes/fake_downloader.go @@ -94,8 +94,6 @@ func (fake *FakeDownloader) DownloadReturnsOnCall(i int, result1 string, result2 func (fake *FakeDownloader) Invocations() map[string][][]interface{} { fake.invocationsMutex.RLock() defer fake.invocationsMutex.RUnlock() - fake.downloadMutex.RLock() - defer fake.downloadMutex.RUnlock() copiedInvocations := map[string][][]interface{}{} for key, value := range fake.invocations { copiedInvocations[key] = value diff --git a/actor/v7action/v7actionfakes/fake_kubernetes_config_getter.go b/actor/v7action/v7actionfakes/fake_kubernetes_config_getter.go index 7102e140b63..4336bf2e2e8 100644 --- a/actor/v7action/v7actionfakes/fake_kubernetes_config_getter.go +++ b/actor/v7action/v7actionfakes/fake_kubernetes_config_getter.go @@ -84,8 +84,6 @@ func (fake *FakeKubernetesConfigGetter) GetReturnsOnCall(i int, result1 *api.Con func (fake *FakeKubernetesConfigGetter) Invocations() map[string][][]interface{} { fake.invocationsMutex.RLock() defer fake.invocationsMutex.RUnlock() - fake.getMutex.RLock() - defer fake.getMutex.RUnlock() copiedInvocations := map[string][][]interface{}{} for key, value := range fake.invocations { copiedInvocations[key] = value diff --git a/actor/v7action/v7actionfakes/fake_manifest_parser.go b/actor/v7action/v7actionfakes/fake_manifest_parser.go index 6d93fd4df35..73bf7ac4f52 100644 --- a/actor/v7action/v7actionfakes/fake_manifest_parser.go +++ b/actor/v7action/v7actionfakes/fake_manifest_parser.go @@ -155,10 +155,6 @@ func (fake *FakeManifestParser) RawAppManifestReturnsOnCall(i int, result1 []byt func (fake *FakeManifestParser) Invocations() map[string][][]interface{} { fake.invocationsMutex.RLock() defer fake.invocationsMutex.RUnlock() - fake.appNamesMutex.RLock() - defer fake.appNamesMutex.RUnlock() - fake.rawAppManifestMutex.RLock() - defer fake.rawAppManifestMutex.RUnlock() copiedInvocations := map[string][][]interface{}{} for key, value := range fake.invocations { copiedInvocations[key] = value diff --git a/actor/v7action/v7actionfakes/fake_routing_client.go b/actor/v7action/v7actionfakes/fake_routing_client.go index d7be3997593..73b5f6fafb3 100644 --- a/actor/v7action/v7actionfakes/fake_routing_client.go +++ b/actor/v7action/v7actionfakes/fake_routing_client.go @@ -161,10 +161,6 @@ func (fake *FakeRoutingClient) GetRouterGroupsReturnsOnCall(i int, result1 []rou func (fake *FakeRoutingClient) Invocations() map[string][][]interface{} { fake.invocationsMutex.RLock() defer fake.invocationsMutex.RUnlock() - fake.getRouterGroupByNameMutex.RLock() - defer fake.getRouterGroupByNameMutex.RUnlock() - fake.getRouterGroupsMutex.RLock() - defer fake.getRouterGroupsMutex.RUnlock() copiedInvocations := map[string][][]interface{}{} for key, value := range fake.invocations { copiedInvocations[key] = value diff --git a/actor/v7action/v7actionfakes/fake_shared_actor.go b/actor/v7action/v7actionfakes/fake_shared_actor.go index 1601a0e3e99..1c60d5b4bec 100644 --- a/actor/v7action/v7actionfakes/fake_shared_actor.go +++ b/actor/v7action/v7actionfakes/fake_shared_actor.go @@ -338,14 +338,6 @@ func (fake *FakeSharedActor) ZipDirectoryResourcesReturnsOnCall(i int, result1 s func (fake *FakeSharedActor) Invocations() map[string][][]interface{} { fake.invocationsMutex.RLock() defer fake.invocationsMutex.RUnlock() - fake.gatherArchiveResourcesMutex.RLock() - defer fake.gatherArchiveResourcesMutex.RUnlock() - fake.gatherDirectoryResourcesMutex.RLock() - defer fake.gatherDirectoryResourcesMutex.RUnlock() - fake.zipArchiveResourcesMutex.RLock() - defer fake.zipArchiveResourcesMutex.RUnlock() - fake.zipDirectoryResourcesMutex.RLock() - defer fake.zipDirectoryResourcesMutex.RUnlock() copiedInvocations := map[string][][]interface{}{} for key, value := range fake.invocations { copiedInvocations[key] = value diff --git a/actor/v7action/v7actionfakes/fake_simple_progress_bar.go b/actor/v7action/v7actionfakes/fake_simple_progress_bar.go index 0e2b05b6486..19d9442f101 100644 --- a/actor/v7action/v7actionfakes/fake_simple_progress_bar.go +++ b/actor/v7action/v7actionfakes/fake_simple_progress_bar.go @@ -126,10 +126,6 @@ func (fake *FakeSimpleProgressBar) TerminateCalls(stub func()) { func (fake *FakeSimpleProgressBar) Invocations() map[string][][]interface{} { fake.invocationsMutex.RLock() defer fake.invocationsMutex.RUnlock() - fake.initializeMutex.RLock() - defer fake.initializeMutex.RUnlock() - fake.terminateMutex.RLock() - defer fake.terminateMutex.RUnlock() copiedInvocations := map[string][][]interface{}{} for key, value := range fake.invocations { copiedInvocations[key] = value diff --git a/actor/v7action/v7actionfakes/fake_sshactor.go b/actor/v7action/v7actionfakes/fake_sshactor.go index f849722dd78..24cf1c167be 100644 --- a/actor/v7action/v7actionfakes/fake_sshactor.go +++ b/actor/v7action/v7actionfakes/fake_sshactor.go @@ -88,8 +88,6 @@ func (fake *FakeSSHActor) ExecuteSecureShellReturnsOnCall(i int, result1 error) func (fake *FakeSSHActor) Invocations() map[string][][]interface{} { fake.invocationsMutex.RLock() defer fake.invocationsMutex.RUnlock() - fake.executeSecureShellMutex.RLock() - defer fake.executeSecureShellMutex.RUnlock() copiedInvocations := map[string][][]interface{}{} for key, value := range fake.invocations { copiedInvocations[key] = value diff --git a/actor/v7action/v7actionfakes/fake_uaaclient.go b/actor/v7action/v7actionfakes/fake_uaaclient.go index 517b7ec9afa..ae1e07303ac 100644 --- a/actor/v7action/v7actionfakes/fake_uaaclient.go +++ b/actor/v7action/v7actionfakes/fake_uaaclient.go @@ -852,28 +852,6 @@ func (fake *FakeUAAClient) ValidateClientUserReturnsOnCall(i int, result1 error) func (fake *FakeUAAClient) Invocations() map[string][][]interface{} { fake.invocationsMutex.RLock() defer fake.invocationsMutex.RUnlock() - fake.authenticateMutex.RLock() - defer fake.authenticateMutex.RUnlock() - fake.createUserMutex.RLock() - defer fake.createUserMutex.RUnlock() - fake.deleteUserMutex.RLock() - defer fake.deleteUserMutex.RUnlock() - fake.getAPIVersionMutex.RLock() - defer fake.getAPIVersionMutex.RUnlock() - fake.getLoginPromptsMutex.RLock() - defer fake.getLoginPromptsMutex.RUnlock() - fake.getSSHPasscodeMutex.RLock() - defer fake.getSSHPasscodeMutex.RUnlock() - fake.listUsersMutex.RLock() - defer fake.listUsersMutex.RUnlock() - fake.refreshAccessTokenMutex.RLock() - defer fake.refreshAccessTokenMutex.RUnlock() - fake.revokeMutex.RLock() - defer fake.revokeMutex.RUnlock() - fake.updatePasswordMutex.RLock() - defer fake.updatePasswordMutex.RUnlock() - fake.validateClientUserMutex.RLock() - defer fake.validateClientUserMutex.RUnlock() copiedInvocations := map[string][][]interface{}{} for key, value := range fake.invocations { copiedInvocations[key] = value diff --git a/actor/v7action/v7actionfakes/fake_who_am_ier.go b/actor/v7action/v7actionfakes/fake_who_am_ier.go index 78dfee83e99..46640859a22 100644 --- a/actor/v7action/v7actionfakes/fake_who_am_ier.go +++ b/actor/v7action/v7actionfakes/fake_who_am_ier.go @@ -90,8 +90,6 @@ func (fake *FakeWhoAmIer) WhoAmIReturnsOnCall(i int, result1 resources.K8sUser, func (fake *FakeWhoAmIer) Invocations() map[string][][]interface{} { fake.invocationsMutex.RLock() defer fake.invocationsMutex.RUnlock() - fake.whoAmIMutex.RLock() - defer fake.whoAmIMutex.RUnlock() copiedInvocations := map[string][][]interface{}{} for key, value := range fake.invocations { copiedInvocations[key] = value diff --git a/actor/v7pushaction/create_deployment_for_push_plan_test.go b/actor/v7pushaction/create_deployment_for_push_plan_test.go index beded0358b5..04bdbd5ddb6 100644 --- a/actor/v7pushaction/create_deployment_for_push_plan_test.go +++ b/actor/v7pushaction/create_deployment_for_push_plan_test.go @@ -8,7 +8,7 @@ import ( "code.cloudfoundry.org/cli/v9/actor/v7pushaction/v7pushactionfakes" "code.cloudfoundry.org/cli/v9/api/cloudcontroller/ccv3/constant" "code.cloudfoundry.org/cli/v9/resources" - "code.cloudfoundry.org/cli/v9/types" + "code.cloudfoundry.org/cli/v9/types" . "github.com/onsi/ginkgo/v2" . "github.com/onsi/gomega" ) diff --git a/actor/v7pushaction/handle_disk_override.go b/actor/v7pushaction/handle_disk_override.go index 33b46727511..e4dd2088450 100644 --- a/actor/v7pushaction/handle_disk_override.go +++ b/actor/v7pushaction/handle_disk_override.go @@ -1,7 +1,7 @@ package v7pushaction import ( - "code.cloudfoundry.org/cli/v9/api/cloudcontroller/ccv3/constant" + "code.cloudfoundry.org/cli/v9/api/cloudcontroller/ccv3/constant" "code.cloudfoundry.org/cli/v9/command/translatableerror" "code.cloudfoundry.org/cli/v9/util/manifestparser" ) diff --git a/actor/v7pushaction/handle_disk_override_test.go b/actor/v7pushaction/handle_disk_override_test.go index 3781e44e0e4..ab552bcae8e 100644 --- a/actor/v7pushaction/handle_disk_override_test.go +++ b/actor/v7pushaction/handle_disk_override_test.go @@ -1,7 +1,7 @@ package v7pushaction_test import ( - "code.cloudfoundry.org/cli/v9/api/cloudcontroller/ccv3/constant" + "code.cloudfoundry.org/cli/v9/api/cloudcontroller/ccv3/constant" "code.cloudfoundry.org/cli/v9/command/translatableerror" "code.cloudfoundry.org/cli/v9/util/manifestparser" diff --git a/actor/v7pushaction/handle_instances_override.go b/actor/v7pushaction/handle_instances_override.go index a6322a9882a..60cc4f104fe 100644 --- a/actor/v7pushaction/handle_instances_override.go +++ b/actor/v7pushaction/handle_instances_override.go @@ -1,7 +1,7 @@ package v7pushaction import ( - "code.cloudfoundry.org/cli/v9/api/cloudcontroller/ccv3/constant" + "code.cloudfoundry.org/cli/v9/api/cloudcontroller/ccv3/constant" "code.cloudfoundry.org/cli/v9/command/translatableerror" "code.cloudfoundry.org/cli/v9/util/manifestparser" ) diff --git a/actor/v7pushaction/handle_instances_override_test.go b/actor/v7pushaction/handle_instances_override_test.go index 4808558af41..40b7f3c5d56 100644 --- a/actor/v7pushaction/handle_instances_override_test.go +++ b/actor/v7pushaction/handle_instances_override_test.go @@ -1,7 +1,7 @@ package v7pushaction_test import ( - "code.cloudfoundry.org/cli/v9/api/cloudcontroller/ccv3/constant" + "code.cloudfoundry.org/cli/v9/api/cloudcontroller/ccv3/constant" "code.cloudfoundry.org/cli/v9/command/translatableerror" "code.cloudfoundry.org/cli/v9/types" "code.cloudfoundry.org/cli/v9/util/manifestparser" diff --git a/actor/v7pushaction/handle_log_rate_limit_override.go b/actor/v7pushaction/handle_log_rate_limit_override.go index 13b1e9dbf8e..218db034cc2 100644 --- a/actor/v7pushaction/handle_log_rate_limit_override.go +++ b/actor/v7pushaction/handle_log_rate_limit_override.go @@ -1,7 +1,7 @@ package v7pushaction import ( - "code.cloudfoundry.org/cli/v9/api/cloudcontroller/ccv3/constant" + "code.cloudfoundry.org/cli/v9/api/cloudcontroller/ccv3/constant" "code.cloudfoundry.org/cli/v9/command/translatableerror" "code.cloudfoundry.org/cli/v9/util/manifestparser" ) diff --git a/actor/v7pushaction/handle_log_rate_limit_override_test.go b/actor/v7pushaction/handle_log_rate_limit_override_test.go index 679d740a90e..0281b7648bc 100644 --- a/actor/v7pushaction/handle_log_rate_limit_override_test.go +++ b/actor/v7pushaction/handle_log_rate_limit_override_test.go @@ -1,7 +1,7 @@ package v7pushaction_test import ( - "code.cloudfoundry.org/cli/v9/api/cloudcontroller/ccv3/constant" + "code.cloudfoundry.org/cli/v9/api/cloudcontroller/ccv3/constant" "code.cloudfoundry.org/cli/v9/command/translatableerror" "code.cloudfoundry.org/cli/v9/util/manifestparser" diff --git a/actor/v7pushaction/handle_memory_override.go b/actor/v7pushaction/handle_memory_override.go index e5ab16ca549..4460687c66c 100644 --- a/actor/v7pushaction/handle_memory_override.go +++ b/actor/v7pushaction/handle_memory_override.go @@ -1,7 +1,7 @@ package v7pushaction import ( - "code.cloudfoundry.org/cli/v9/api/cloudcontroller/ccv3/constant" + "code.cloudfoundry.org/cli/v9/api/cloudcontroller/ccv3/constant" "code.cloudfoundry.org/cli/v9/command/translatableerror" "code.cloudfoundry.org/cli/v9/util/manifestparser" ) diff --git a/actor/v7pushaction/handle_memory_override_test.go b/actor/v7pushaction/handle_memory_override_test.go index 1ef70722757..602396fbae9 100644 --- a/actor/v7pushaction/handle_memory_override_test.go +++ b/actor/v7pushaction/handle_memory_override_test.go @@ -1,7 +1,7 @@ package v7pushaction_test import ( - "code.cloudfoundry.org/cli/v9/api/cloudcontroller/ccv3/constant" + "code.cloudfoundry.org/cli/v9/api/cloudcontroller/ccv3/constant" "code.cloudfoundry.org/cli/v9/command/translatableerror" "code.cloudfoundry.org/cli/v9/util/manifestparser" diff --git a/actor/v7pushaction/setup_deployment_information_for_push_plan.go b/actor/v7pushaction/setup_deployment_information_for_push_plan.go index 82900aa99a1..328b0dd28c0 100644 --- a/actor/v7pushaction/setup_deployment_information_for_push_plan.go +++ b/actor/v7pushaction/setup_deployment_information_for_push_plan.go @@ -1,7 +1,7 @@ package v7pushaction import ( - "code.cloudfoundry.org/cli/v9/api/cloudcontroller/ccv3/constant" + "code.cloudfoundry.org/cli/v9/api/cloudcontroller/ccv3/constant" "code.cloudfoundry.org/cli/v9/cf/errors" "code.cloudfoundry.org/cli/v9/command/flag" "code.cloudfoundry.org/cli/v9/types" diff --git a/actor/v7pushaction/setup_deployment_information_for_push_plan_test.go b/actor/v7pushaction/setup_deployment_information_for_push_plan_test.go index b07bdade816..c170366535c 100644 --- a/actor/v7pushaction/setup_deployment_information_for_push_plan_test.go +++ b/actor/v7pushaction/setup_deployment_information_for_push_plan_test.go @@ -2,8 +2,8 @@ package v7pushaction_test import ( "code.cloudfoundry.org/cli/v9/api/cloudcontroller/ccv3/constant" - "code.cloudfoundry.org/cli/v9/cf/errors" - "code.cloudfoundry.org/cli/v9/types" + "code.cloudfoundry.org/cli/v9/cf/errors" + "code.cloudfoundry.org/cli/v9/types" . "code.cloudfoundry.org/cli/v9/actor/v7pushaction" diff --git a/api/cfnetworking/cfnetv1/client.go b/api/cfnetworking/cfnetv1/client.go index 1c301716184..5068b41e75d 100644 --- a/api/cfnetworking/cfnetv1/client.go +++ b/api/cfnetworking/cfnetv1/client.go @@ -6,7 +6,7 @@ // For more information on the CF Networking API see // https://github.com/cloudfoundry-incubator/cf-networking-release/blob/develop/docs/API.md // -// Method Naming Conventions +// # Method Naming Conventions // // The client takes a '' // approach to method names. If the and @@ -15,38 +15,40 @@ // method name. // // For Example: -// Method Name: GetApplication -// Endpoint: /v2/applications/:guid -// Action Name: Get -// Top Level Endpoint: applications -// Return Value: Application -// -// Method Name: GetServiceInstances -// Endpoint: /v2/service_instances -// Action Name: Get -// Top Level Endpoint: service_instances -// Return Value: []ServiceInstance -// -// Method Name: GetSpaceServiceInstances -// Endpoint: /v2/spaces/:guid/service_instances -// Action Name: Get -// Top Level Endpoint: spaces -// Return Value: []ServiceInstance +// +// Method Name: GetApplication +// Endpoint: /v2/applications/:guid +// Action Name: Get +// Top Level Endpoint: applications +// Return Value: Application +// +// Method Name: GetServiceInstances +// Endpoint: /v2/service_instances +// Action Name: Get +// Top Level Endpoint: service_instances +// Return Value: []ServiceInstance +// +// Method Name: GetSpaceServiceInstances +// Endpoint: /v2/spaces/:guid/service_instances +// Action Name: Get +// Top Level Endpoint: spaces +// Return Value: []ServiceInstance // // Use the following table to determine which HTTP Command equates to which // Action Name: -// HTTP Command -> Action Name -// POST -> Create -// GET -> Get -// PUT -> Update -// DELETE -> Delete // -// Method Locations +// HTTP Command -> Action Name +// POST -> Create +// GET -> Get +// PUT -> Update +// DELETE -> Delete +// +// # Method Locations // // Methods exist in the same file as their return type, regardless of which // endpoint they use. // -// Error Handling +// # Error Handling // // All error handling that requires parsing the error_code/code returned back // from the Cloud Controller should be placed in the errorWrapper. Everything @@ -55,7 +57,7 @@ // exist in the cloudcontroller's errors.go. Errors related to the individaul // operation should exist at the top of that operation's file. // -// No inline-relations-depth And summary Endpoints +// # No inline-relations-depth And summary Endpoints // // This package will not use ever use 'inline-relations-depth' or the // '/summary' endpoints for any operations. These requests can be extremely @@ -65,72 +67,72 @@ package cfnetv1 import ( - "fmt" - "runtime" - "time" + "fmt" + "runtime" + "time" - "code.cloudfoundry.org/cli/v9/api/cfnetworking" - "code.cloudfoundry.org/cli/v9/api/cfnetworking/cfnetv1/internal" + "code.cloudfoundry.org/cli/v9/api/cfnetworking" + "code.cloudfoundry.org/cli/v9/api/cfnetworking/cfnetv1/internal" - "github.com/tedsuo/rata" + "github.com/tedsuo/rata" ) // Client is a client that can be used to talk to a CF Networking API. type Client struct { - connection cfnetworking.Connection - router *rata.RequestGenerator - url string - userAgent string + connection cfnetworking.Connection + router *rata.RequestGenerator + url string + userAgent string } // Config allows the Client to be configured type Config struct { - // AppName is the name of the application/process using the client. - AppName string + // AppName is the name of the application/process using the client. + AppName string - // AppVersion is the version of the application/process using the client. - AppVersion string + // AppVersion is the version of the application/process using the client. + AppVersion string - // DialTimeout is the DNS timeout used to make all requests to the Cloud - // Controller. - DialTimeout time.Duration + // DialTimeout is the DNS timeout used to make all requests to the Cloud + // Controller. + DialTimeout time.Duration - // SkipSSLValidation controls whether a client verifies the server's - // certificate chain and host name. If SkipSSLValidation is true, TLS accepts - // any certificate presented by the server and any host name in that - // certificate for *all* client requests going forward. - // - // In this mode, TLS is susceptible to man-in-the-middle attacks. This should - // be used only for testing. - SkipSSLValidation bool + // SkipSSLValidation controls whether a client verifies the server's + // certificate chain and host name. If SkipSSLValidation is true, TLS accepts + // any certificate presented by the server and any host name in that + // certificate for *all* client requests going forward. + // + // In this mode, TLS is susceptible to man-in-the-middle attacks. This should + // be used only for testing. + SkipSSLValidation bool - // URL is a fully qualified URL to the CF Networking API. - URL string + // URL is a fully qualified URL to the CF Networking API. + URL string - // Wrappers that apply to the client connection. - Wrappers []ConnectionWrapper + // Wrappers that apply to the client connection. + Wrappers []ConnectionWrapper } // NewClient returns a new CF Networking client. func NewClient(config Config) *Client { - userAgent := fmt.Sprintf("%s/%s (%s; %s %s)", config.AppName, config.AppVersion, runtime.Version(), runtime.GOARCH, runtime.GOOS) + userAgent := fmt.Sprintf("%s/%s (%s; %s %s)", config.AppName, config.AppVersion, runtime.Version(), runtime.GOARCH, runtime.GOOS) - connection := cfnetworking.NewConnection(cfnetworking.Config{ - DialTimeout: config.DialTimeout, - SkipSSLValidation: config.SkipSSLValidation, - }) + connection := cfnetworking.NewConnection(cfnetworking.Config{ + DialTimeout: config.DialTimeout, + SkipSSLValidation: config.SkipSSLValidation, + }) - wrappedConnection := cfnetworking.NewErrorWrapper().Wrap(connection) - for _, wrapper := range config.Wrappers { - wrappedConnection = wrapper.Wrap(wrappedConnection) - } + wrappedConnection := cfnetworking.NewErrorWrapper().Wrap(connection) + for _, wrapper := range config.Wrappers { + wrappedConnection = wrapper.Wrap(wrappedConnection) + } - client := &Client{ - connection: wrappedConnection, - router: rata.NewRequestGenerator(config.URL, internal.Routes), - url: config.URL, - userAgent: userAgent, - } + client := &Client{ + connection: wrappedConnection, + router: rata.NewRequestGenerator(config.URL, internal.Routes), + url: config.URL, + userAgent: userAgent, + } - return client + return client } diff --git a/api/cfnetworking/errors.go b/api/cfnetworking/errors.go index 7abd7877c64..fd5fcaacc56 100644 --- a/api/cfnetworking/errors.go +++ b/api/cfnetworking/errors.go @@ -1,64 +1,64 @@ package cfnetworking import ( - "encoding/json" - "net/http" + "encoding/json" + "net/http" - "code.cloudfoundry.org/cli/v9/api/cfnetworking/networkerror" + "code.cloudfoundry.org/cli/v9/api/cfnetworking/networkerror" ) // errorWrapper is the wrapper that converts responses with 4xx and 5xx status // codes to an error. type errorWrapper struct { - connection Connection + connection Connection } func NewErrorWrapper() *errorWrapper { - return new(errorWrapper) + return new(errorWrapper) } // Wrap wraps a Cloud Controller connection in this error handling wrapper. func (e *errorWrapper) Wrap(innerconnection Connection) Connection { - e.connection = innerconnection - return e + e.connection = innerconnection + return e } // Make converts RawHTTPStatusError, which represents responses with 4xx and // 5xx status codes, to specific errors. func (e *errorWrapper) Make(request *Request, passedResponse *Response) error { - err := e.connection.Make(request, passedResponse) + err := e.connection.Make(request, passedResponse) - if rawHTTPStatusErr, ok := err.(networkerror.RawHTTPStatusError); ok { - return convert(rawHTTPStatusErr) - } - return err + if rawHTTPStatusErr, ok := err.(networkerror.RawHTTPStatusError); ok { + return convert(rawHTTPStatusErr) + } + return err } func convert(rawHTTPStatusErr networkerror.RawHTTPStatusError) error { - // Try to unmarshal the raw error into a CC error. If unmarshaling fails, - // return the raw error. - var errorResponse networkerror.ErrorResponse - err := json.Unmarshal(rawHTTPStatusErr.RawResponse, &errorResponse) - if err != nil { - return rawHTTPStatusErr - } + // Try to unmarshal the raw error into a CC error. If unmarshaling fails, + // return the raw error. + var errorResponse networkerror.ErrorResponse + err := json.Unmarshal(rawHTTPStatusErr.RawResponse, &errorResponse) + if err != nil { + return rawHTTPStatusErr + } - switch rawHTTPStatusErr.StatusCode { - case http.StatusBadRequest: // 400 - return networkerror.BadRequestError(errorResponse) - case http.StatusUnauthorized: // 401 - return networkerror.UnauthorizedError(errorResponse) - case http.StatusForbidden: // 403 - return networkerror.ForbiddenError(errorResponse) - case http.StatusNotAcceptable: // 406 - return networkerror.NotAcceptableError(errorResponse) - case http.StatusConflict: // 409 - return networkerror.ConflictError(errorResponse) - default: - return networkerror.UnexpectedResponseError{ - ErrorResponse: errorResponse, - RequestIDs: rawHTTPStatusErr.RequestIDs, - ResponseCode: rawHTTPStatusErr.StatusCode, - } - } + switch rawHTTPStatusErr.StatusCode { + case http.StatusBadRequest: // 400 + return networkerror.BadRequestError(errorResponse) + case http.StatusUnauthorized: // 401 + return networkerror.UnauthorizedError(errorResponse) + case http.StatusForbidden: // 403 + return networkerror.ForbiddenError(errorResponse) + case http.StatusNotAcceptable: // 406 + return networkerror.NotAcceptableError(errorResponse) + case http.StatusConflict: // 409 + return networkerror.ConflictError(errorResponse) + default: + return networkerror.UnexpectedResponseError{ + ErrorResponse: errorResponse, + RequestIDs: rawHTTPStatusErr.RequestIDs, + ResponseCode: rawHTTPStatusErr.StatusCode, + } + } } diff --git a/api/cfnetworking/wrapper/retry_request.go b/api/cfnetworking/wrapper/retry_request.go index 600a79825d5..eb4300ecf09 100644 --- a/api/cfnetworking/wrapper/retry_request.go +++ b/api/cfnetworking/wrapper/retry_request.go @@ -1,54 +1,54 @@ package wrapper import ( - "net/http" + "net/http" - "code.cloudfoundry.org/cli/v9/api/cfnetworking" + "code.cloudfoundry.org/cli/v9/api/cfnetworking" ) // RetryRequest is a wrapper that retries failed requests if they contain a 5XX // status code. type RetryRequest struct { - maxRetries int - connection cfnetworking.Connection + maxRetries int + connection cfnetworking.Connection } // NewRetryRequest returns a pointer to a RetryRequest wrapper. func NewRetryRequest(maxRetries int) *RetryRequest { - return &RetryRequest{ - maxRetries: maxRetries, - } + return &RetryRequest{ + maxRetries: maxRetries, + } } // Wrap sets the connection in the RetryRequest and returns itself. func (retry *RetryRequest) Wrap(innerconnection cfnetworking.Connection) cfnetworking.Connection { - retry.connection = innerconnection - return retry + retry.connection = innerconnection + return retry } // Make retries the request if it comes back with certain status codes. func (retry *RetryRequest) Make(request *cfnetworking.Request, passedResponse *cfnetworking.Response) error { - var err error - - for i := 0; i < retry.maxRetries+1; i += 1 { - err = retry.connection.Make(request, passedResponse) - if err == nil { - return nil - } - - if passedResponse.HTTPResponse != nil && - (passedResponse.HTTPResponse.StatusCode == http.StatusBadGateway || - passedResponse.HTTPResponse.StatusCode == http.StatusServiceUnavailable || - passedResponse.HTTPResponse.StatusCode == http.StatusGatewayTimeout || - (passedResponse.HTTPResponse.StatusCode >= 400 && passedResponse.HTTPResponse.StatusCode < 500)) { - break - } - - // Reset the request body prior to the next retry - resetErr := request.ResetBody() - if resetErr != nil { - return resetErr - } - } - return err + var err error + + for i := 0; i < retry.maxRetries+1; i += 1 { + err = retry.connection.Make(request, passedResponse) + if err == nil { + return nil + } + + if passedResponse.HTTPResponse != nil && + (passedResponse.HTTPResponse.StatusCode == http.StatusBadGateway || + passedResponse.HTTPResponse.StatusCode == http.StatusServiceUnavailable || + passedResponse.HTTPResponse.StatusCode == http.StatusGatewayTimeout || + (passedResponse.HTTPResponse.StatusCode >= 400 && passedResponse.HTTPResponse.StatusCode < 500)) { + break + } + + // Reset the request body prior to the next retry + resetErr := request.ResetBody() + if resetErr != nil { + return resetErr + } + } + return err } diff --git a/api/cloudcontroller/ccv3/access_rule.go b/api/cloudcontroller/ccv3/access_rule.go deleted file mode 100644 index 2c391af8d18..00000000000 --- a/api/cloudcontroller/ccv3/access_rule.go +++ /dev/null @@ -1,59 +0,0 @@ -package ccv3 - -import ( - "code.cloudfoundry.org/cli/v9/api/cloudcontroller/ccv3/internal" - "code.cloudfoundry.org/cli/v9/resources" -) - -// CreateAccessRule creates an access rule for a route -func (client *Client) CreateAccessRule(accessRule resources.AccessRule) (resources.AccessRule, Warnings, error) { - var responseBody resources.AccessRule - - _, warnings, err := client.MakeRequest(RequestParams{ - RequestName: internal.PostAccessRuleRequest, - RequestBody: accessRule, - ResponseBody: &responseBody, - }) - - return responseBody, warnings, err -} - -// GetAccessRules lists access rules -func (client *Client) GetAccessRules(query ...Query) ([]resources.AccessRule, IncludedResources, Warnings, error) { - var accessRules []resources.AccessRule - - includedResources, warnings, err := client.MakeListRequest(RequestParams{ - RequestName: internal.GetAccessRulesRequest, - Query: query, - ResponseBody: resources.AccessRule{}, - AppendToList: func(item interface{}) error { - accessRules = append(accessRules, item.(resources.AccessRule)) - return nil - }, - }) - - return accessRules, includedResources, warnings, err -} - -// GetAccessRule gets a single access rule by GUID -func (client *Client) GetAccessRule(guid string) (resources.AccessRule, Warnings, error) { - var responseBody resources.AccessRule - - _, warnings, err := client.MakeRequest(RequestParams{ - RequestName: internal.GetAccessRuleRequest, - URIParams: internal.Params{"access_rule_guid": guid}, - ResponseBody: &responseBody, - }) - - return responseBody, warnings, err -} - -// DeleteAccessRule deletes an access rule -func (client *Client) DeleteAccessRule(guid string) (JobURL, Warnings, error) { - jobURLString, warnings, err := client.MakeRequest(RequestParams{ - RequestName: internal.DeleteAccessRuleRequest, - URIParams: internal.Params{"access_rule_guid": guid}, - }) - - return JobURL(jobURLString), warnings, err -} diff --git a/api/cloudcontroller/ccv3/deployment_test.go b/api/cloudcontroller/ccv3/deployment_test.go index 3dea39c59a3..f725d62763f 100644 --- a/api/cloudcontroller/ccv3/deployment_test.go +++ b/api/cloudcontroller/ccv3/deployment_test.go @@ -7,7 +7,7 @@ import ( "code.cloudfoundry.org/cli/v9/api/cloudcontroller/ccerror" "code.cloudfoundry.org/cli/v9/api/cloudcontroller/ccv3/constant" "code.cloudfoundry.org/cli/v9/resources" - "code.cloudfoundry.org/cli/v9/types" + "code.cloudfoundry.org/cli/v9/types" . "code.cloudfoundry.org/cli/v9/api/cloudcontroller/ccv3" . "github.com/onsi/ginkgo/v2" diff --git a/api/cloudcontroller/ccv3/info.go b/api/cloudcontroller/ccv3/info.go index d1db6b3eafa..380acc1817d 100644 --- a/api/cloudcontroller/ccv3/info.go +++ b/api/cloudcontroller/ccv3/info.go @@ -4,7 +4,7 @@ import ( "net/http" "code.cloudfoundry.org/cli/v9/api/cloudcontroller/ccerror" - "code.cloudfoundry.org/cli/v9/api/cloudcontroller/ccv3/internal" + "code.cloudfoundry.org/cli/v9/api/cloudcontroller/ccv3/internal" ) type Info struct { diff --git a/api/cloudcontroller/ccv3/internal/api_routes.go b/api/cloudcontroller/ccv3/internal/api_routes.go index 40605b74a50..8700d9e6088 100644 --- a/api/cloudcontroller/ccv3/internal/api_routes.go +++ b/api/cloudcontroller/ccv3/internal/api_routes.go @@ -9,7 +9,7 @@ import "net/http" // If the request returns a single entity by GUID, use the singular (for example // /v3/organizations/:organization_guid is GetOrganization). const ( - DeleteAccessRuleRequest = "DeleteAccessRuleRequest" + DeleteRoutePolicyRequest = "DeleteRoutePolicyRequest" DeleteApplicationProcessInstanceRequest = "DeleteApplicationProcessInstance" DeleteApplicationRequest = "DeleteApplication" DeleteBuildpackRequest = "DeleteBuildpack" @@ -36,8 +36,8 @@ const ( DeleteSpaceRequest = "DeleteSpace" DeleteSpaceQuotaFromSpaceRequest = "DeleteSpaceQuotaFromSpace" DeleteUserRequest = "DeleteUser" - GetAccessRuleRequest = "GetAccessRuleRequest" - GetAccessRulesRequest = "GetAccessRulesRequest" + GetRoutePolicyRequest = "GetRoutePolicyRequest" + GetRoutePoliciesRequest = "GetRoutePoliciesRequest" GetApplicationDropletCurrentRequest = "GetApplicationDropletCurrent" GetApplicationEnvRequest = "GetApplicationEnv" GetApplicationFeaturesRequest = "GetApplicationFeatures" @@ -137,7 +137,7 @@ const ( PatchSpaceQuotaRequest = "PatchSpaceQuota" PatchStackRequest = "PatchStack" PatchMoveRouteRequest = "PatchMoveRouteRequest" - PostAccessRuleRequest = "PostAccessRuleRequest" + PostRoutePolicyRequest = "PostRoutePolicyRequest" PostApplicationActionApplyManifest = "PostApplicationActionApplyM" PostApplicationActionRestartRequest = "PostApplicationActionRestart" PostApplicationActionStartRequest = "PostApplicationActionStart" @@ -190,10 +190,10 @@ const ( // APIRoutes is a list of routes used by the router to construct request URLs. var APIRoutes = map[string]Route{ - GetAccessRulesRequest: {Path: "/v3/access_rules", Method: http.MethodGet}, - PostAccessRuleRequest: {Path: "/v3/access_rules", Method: http.MethodPost}, - GetAccessRuleRequest: {Path: "/v3/access_rules/:access_rule_guid", Method: http.MethodGet}, - DeleteAccessRuleRequest: {Path: "/v3/access_rules/:access_rule_guid", Method: http.MethodDelete}, + GetRoutePoliciesRequest: {Path: "/v3/route_policies", Method: http.MethodGet}, + PostRoutePolicyRequest: {Path: "/v3/route_policies", Method: http.MethodPost}, + GetRoutePolicyRequest: {Path: "/v3/route_policies/:route_policy_guid", Method: http.MethodGet}, + DeleteRoutePolicyRequest: {Path: "/v3/route_policies/:route_policy_guid", Method: http.MethodDelete}, GetApplicationsRequest: {Path: "/v3/apps", Method: http.MethodGet}, PostApplicationRequest: {Path: "/v3/apps", Method: http.MethodPost}, DeleteApplicationRequest: {Path: "/v3/apps/:app_guid", Method: http.MethodDelete}, diff --git a/api/cloudcontroller/ccv3/query.go b/api/cloudcontroller/ccv3/query.go index 27bcf995712..fdc7a43f1ff 100644 --- a/api/cloudcontroller/ccv3/query.go +++ b/api/cloudcontroller/ccv3/query.go @@ -29,8 +29,10 @@ const ( SequenceIDFilter QueryKey = "sequence_ids" // RouteGUIDFilter is a query parameter for listing objects by Route GUID. RouteGUIDFilter QueryKey = "route_guids" - // SelectorsFilter is a query parameter for listing access rules by selector. - SelectorsFilter QueryKey = "selectors" + // SourcesFilter is a query parameter for listing route policies by source. + SourcesFilter QueryKey = "sources" + // SourceGuidsFilter is a query parameter for listing route policies by source GUID. + SourceGuidsFilter QueryKey = "source_guids" // ServiceInstanceGUIDFilter is a query parameter for listing objects by Service Instance GUID. ServiceInstanceGUIDFilter QueryKey = "service_instance_guids" // SpaceGUIDFilter is a query parameter for listing objects by Space GUID. diff --git a/api/cloudcontroller/ccv3/route_policy.go b/api/cloudcontroller/ccv3/route_policy.go new file mode 100644 index 00000000000..1b0b555a0ab --- /dev/null +++ b/api/cloudcontroller/ccv3/route_policy.go @@ -0,0 +1,59 @@ +package ccv3 + +import ( + "code.cloudfoundry.org/cli/v9/api/cloudcontroller/ccv3/internal" + "code.cloudfoundry.org/cli/v9/resources" +) + +// CreateRoutePolicy creates a route policy for a route +func (client *Client) CreateRoutePolicy(routePolicy resources.RoutePolicy) (resources.RoutePolicy, Warnings, error) { + var responseBody resources.RoutePolicy + + _, warnings, err := client.MakeRequest(RequestParams{ + RequestName: internal.PostRoutePolicyRequest, + RequestBody: routePolicy, + ResponseBody: &responseBody, + }) + + return responseBody, warnings, err +} + +// GetRoutePolicies lists route policies +func (client *Client) GetRoutePolicies(query ...Query) ([]resources.RoutePolicy, IncludedResources, Warnings, error) { + var routePolicies []resources.RoutePolicy + + includedResources, warnings, err := client.MakeListRequest(RequestParams{ + RequestName: internal.GetRoutePoliciesRequest, + Query: query, + ResponseBody: resources.RoutePolicy{}, + AppendToList: func(item interface{}) error { + routePolicies = append(routePolicies, item.(resources.RoutePolicy)) + return nil + }, + }) + + return routePolicies, includedResources, warnings, err +} + +// GetRoutePolicy gets a single route policy by GUID +func (client *Client) GetRoutePolicy(guid string) (resources.RoutePolicy, Warnings, error) { + var responseBody resources.RoutePolicy + + _, warnings, err := client.MakeRequest(RequestParams{ + RequestName: internal.GetRoutePolicyRequest, + URIParams: internal.Params{"route_policy_guid": guid}, + ResponseBody: &responseBody, + }) + + return responseBody, warnings, err +} + +// DeleteRoutePolicy deletes a route policy +func (client *Client) DeleteRoutePolicy(guid string) (JobURL, Warnings, error) { + jobURLString, warnings, err := client.MakeRequest(RequestParams{ + RequestName: internal.DeleteRoutePolicyRequest, + URIParams: internal.Params{"route_policy_guid": guid}, + }) + + return JobURL(jobURLString), warnings, err +} diff --git a/cf/actors/push.go b/cf/actors/push.go index b51322b084f..36a093e2ce5 100644 --- a/cf/actors/push.go +++ b/cf/actors/push.go @@ -7,9 +7,9 @@ import ( "path/filepath" "runtime" - "errors" + "errors" - "code.cloudfoundry.org/cli/v9/cf/api/applicationbits" + "code.cloudfoundry.org/cli/v9/cf/api/applicationbits" "code.cloudfoundry.org/cli/v9/cf/api/resources" "code.cloudfoundry.org/cli/v9/cf/appfiles" . "code.cloudfoundry.org/cli/v9/cf/i18n" diff --git a/cf/cli b/cf/cli new file mode 100755 index 0000000000000000000000000000000000000000..0a804bcceee51336ed83775e51e6052522fd391f GIT binary patch literal 39064693 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

bER`x~#n_)$y@#*eT#W}=ecQel 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

5*p#Sq7%hD@#=$aW2sru#xy;Mc2n(X?dyJ5z$ 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�w)H2&}te>j4_xWJ!oGXBAB zn$8FZ{?{S%Vd0PUZ94qjCjM}VKR@I6<3oLjas+>TB;n7f{r}VW!%zI-2>#*%f4a%| zzxyAJKf;0kUy%8*@W=W&9sWKOf4Ib-pK<*0p>i$!@sWf-qb@M24E$WF`KD zMEvOze}YOHM}k{T{Ii7rk@@iG-zh!**(Uzk8h?By@XrSSqa2NYb_)K8+K)A-&>vZe zKOqr+y2PKLlJI|bi-~`>@INvi9{yd@<8L?dw`=_InZVx;{*U8tPr)Bi7g+csEAb~J z;!l_O6I2rZ-7Wm>!vDJt7k@{3{GBHLPK`f46Zqq1$dy1+)8CnbKcemg3POKmCH{m& z{OJ;Zf=a^w(yvYWJB9xb8-J*TrQ?5>iN8zZkIw}DF7Q9f(fGSk@JH0rohJUsO8g0l z_|ql+1eJt;@GBF4m+(I_A0Gc)m>z$(iN9OpkIw}DZty?K(fGSl@JH1C9VY(BO8g0l z_|ql+1eJvUyPHk?-NOIKe0ccRrN`fA;_uV=<1>N35Bwj;-G99NRwd@)5X-{L_)OrRk*Tf(lA8V*P(IbmH%x(%T-^y2 z%shfWArXJN#Gjy&@W1p+ll~c*l>dj1e`Z?#&&V?I&(gSLCF7r^9z;1N{#hybXQ`!F zUYdC{{(vO-!xj7iDhdDK7Z(0m!2ddAK0N-3bxMzawuyhX#w9x$|7`Uk*T6t0FC!y6 z1^;ZdAIn2CkH#O61b?`KKR_kn|L*4&{@K9)FUWkD_;*Q zcc}-tM%VbeQt)@FrC4~Hc{KijB>2M>`~fNn|KKJIe;4^5nGcix7pBMGZQ}3NxVV$? zcdHM%I@b8RQ}B1I{aBcqc{KijB>2M>`~fNn|93yN@OP8{k@;uw$2P1T$2?tjhy5zE zc3+1b+ztWl)^B)~;80s?8}e8b8Uucf)+hi!gdwZutU?NP+C2*v0<|40w)$e@Pi z34s4V1}~V5!WJ8jaiV8XSFwD+9_%u{G!45OYpD~7F(Ww(6XX0LfLg){UW7eG9#io1 z~P}D zPA3AkCS?QLj7;c~0~`;Y0yB#f713Csnn{fy$0xuKWur9?WYqS-nch=la8d}u)WGyi zG2XL5adQi#IJwmrr(}8$VcFxv?8t5Jb&4KLpHqhdVe^EkWQ={9O|4-|4s^k{9KMz{ zzS46GalBdUbY$+sy%QHqNy#~2i{rVSj^~tPKs54m;F16FT&m97B1djSSIWuQmwHg+ zE1fOzxV>$F2QwnkkCE);d)v%pzS8j$fBFQiD0sn%8Cg^sv;D5W*1oe{VtFp7M|AWe z6Edx0e5L&*{~0>J;Q#>9EVN}=`MO#jX9B=@3jkWp0_{8bWH?tesI62pUUJCBnIvsY--1FRB-fG>~o#RgSQ^j)S>QJZ&#xybuGZ%a~c5fyC`VV9|=KM$dvK@1_YM|W{w^*8ZSby;>v^+0Zo@UFl*79t&JUihr>Z3%{sBhKI0YTb- zJ4V3BS2*)|d*6;`A`M&ZQ>xxRSl0!A7rXf5=Fb@9_X(I*?Fa>?e1y0m{Wi;Qv-~cU zU*Fqp(^`C`Z=WEUz4ZKE%`e%_>6u&4J53ch1z*R zJI&f@U(O+VC*Ds4|HJMk9v@>D=uIw=E|9H#*^XH`!oXSj8y%q=zZ+Dc%E?sGMi5WS@-d4^pYO|lnsy+D$ z7`5vUjR&j4%sB$xD6q3@+mldD;Dj;o$?ip*pC8|5ghuqk&!w=C80oazc-#nNp#gUp znV-OT-PDDIvWn|{@jG`r>bl_1 zOGeUx!>GAE;&@(W7#)wl41skcz*>&F(e096HYXrcIQ~*~a zY26J-S~m{-=ct?54@v841gtP@5(Wvd6WoAzdj)=`j=|5&YH(E5kmJd8r~#P{=#uGx zFPTp8fI~#!5ED3uMCE3Hud4$1x@iDkS4Z#=69f;k5IibQ@TfV#3+`};JRD*V2k1j> zXh*EY6kR}+6c%FsLRIEaMgd0EA5DQ-^{0hq$fKsftolc@8SFU)8W?{9LsVKiB(=`tNn6 z>Mq{Q#%g9`Eo5UMY6qjt%+r=7HCF*DQ|-jhbfQ=1F5<62yy_|{_&bs~)s3lUw{(tYSw&Cp5569`P8`}MNj;1 zxE(#iLYSWOn@OLZ3#BXfe8Np0?D>LEoF;N440rgr$bsAF)^30cvLJ}R=r8QDpkG1=l&+Qg~uEY9>UH%&q|w_O~gt2hV+cH(^L#k6z8W{zNoaGI>*l*VIrG8A%) zqqz)uW|@P?j}p+` zO_oA_{cW-w@}o?|n=DyH{;bM~kY_-iuuz2_i%wySa$$>>VT-z9i{4?Y1ppL8WgAsZ z?QQnPkL5kZ5mxqC-cv+jwU6aJ#1?k|u+vLXhFEO!a7!1l*lmQw!@ae?bXYVe zNzBNC_YSc$rV~MQ7IB*i7x4KL=#x*mXs29sa<3{+cCF%aQKl=%1KEn{F>JT3Q`gqX z12jMkc~J>FtAj%%=9Nted}8N(MN!&yJW|-3wvmHvY2&$XVQ)n|%!=`+X%K!Kw)nR2 zTaR$V7lqkLmm&D+)kF&-4x3S$i9_kBwk9N?p~Sqj@TGi6+cX)R%wV1^)Z{w>ITd$1#8?=B8kO$r6WR0+Ugr+(X;%-wX7fYAED zD8GprrNsD_Y*OnY{uGHX3#_nGt{f8B23+k;-%3o{S|>o5`2(#aVH0E)3QNvn#tV+g z;TD7heaM)39SV)pM@N5Q)h3yKC>q=6Xg+d&UelM!X{3F=wnC&ytfIwjUw&^Zsab%v z|3&pexknRh1ksJ){Tym>>j-lO&gvN@!o-Q08KV9hFseGK8!?Tp#{R>3>k!PsId z{m9?0CTPT?l}!HbjvH3H5Wv4Q4b+Z4q_C?AYWJF_3R*1sFdZm>okUguLdTYMF<&d& z!c#ZYEbtk)6a?VITFDI{`N7vt*VA?Fqp~uOzKK2F9BH^5erWQkHXs2rJtSC?&Qz!u6j&*1L8O0cD6mP(0Ff@W5X( zca}L`>|TrKRC2~iM%$InN131c=fJX`N3-UUfBNugU)KZKBwr2?)`G@QS;ODTIVitpY54OjL z#F>d>47*A`y2KFd8+Tx-lzJraM<>B0lLWfI!1yMVj`)#&X|YL*NTPhw4>;h`qV79d zz(_pUp7Ot!$S)4sLf(R=cdWGO$3CK%=->K+rN?rbkr#7>i5x}o941HB0+0WvjG8=H znaij-vOF}~hZG(^-v6zCKLb;yreb`fH7SfZM6vDuD_KsKEG~0|@C1gs%LBI*;S!y` zbXgwww|WI?d$_dnRuy2FV{G&X;FqXB>h9MC=z;aH=np}MtvPH1x3*?E!CI}&j~)sZ z7y^g(X7jCS%9C{QZ!6q#lkj5$HLa24sC@_dzY~UYXd(xjrL7nZzy>4H)8uYpP((Ax zfeDNVY%Ue?j0WkhC3tzz(+01M9U>4R;n^;b^g071d^|o`Mq2#$|JC>dLT=qDGa(}c zu0t(;KrN)rN5s}94@{pToc#>4nM8tc#vpXdY8ib%Dm_MF&^H1v>oJPz4=+m%@px3` zx^_cT0(5+^dJK&q*OGG0TIMxmsHe|`h?0|kc5gtZt^mlHr+UH=yiDgfj|EN$gZ;W+ zxWAtSdEF^{O~_W`!?oy(l6RdWC8rKhN$~@8{wy{mk+KIjQ_4{CoaF{Vvz|AF_Tu)74MlW4OB22;!u8b**Cwx8`x_`>qY!Gos!w zE*)}~T6@HjY#lyk5yHmMYD(V=v+fBi;Ep$z~~3bV9oP^uWGo}s=+ zO#Cim2`2z*_!^l8{Xguz3wTu3)i<8ozyJwnfCR!#f<_G$F+tFTOPxs2Gi1Y;N8@-Lz{R!}$gP)E_g^R-%V!2L8Nc+Vm zeQ+&SvuC*6J3q^=HR%qmX-PlC7dH;PffM~Al#I$)w6ckNsEZ#&pN1TDG; z%Y(kxWkUvX;3V&hRL9Km+km+2(7rd zHF~xrN}|Y?PBcq=mHLO9^n*~I2DnjGtC9JEkPLk;6&tTKTm6(++>*aQnrb2hdoe*O zO$yOxyz_O7{7Gf`Vzvy5VTGPt>Ps)76lZeESXvO0C9|sP0_D?Rl~%hd6$isC574>1 z0sKzFuXDz%;&NtIGE85cB)y4IW>%5(IsD+G=Q_C|C4cYxV(0H{-x!3`Ye^Yn)xVXL z9R9^8U6scgsw?`H)Dk`LqHunG=OD$7O2{?|M4Fj$ZACzHWR zc{A(B+-=rx?B3t0B9IQ=ro15|rF2YwB*>ps@pI+}VgTe)Go=!df7Y>j)Z);~26%6w z*eN2qkY<$_8L&(Y4tUpEX0KEz3DToYAC8osbwunJ>37w3#*VK7VX7UlW%!!0 z1ld-wi6#QhZ_5h1LG|(^7{fI%c68By$?%C2ZCRz=dpiS#s`jh$z2#`X0PPoeZ%pi& zq0kqNb64>0H_v6J*=jcCFxsC2H{)SiKE@Zmci9yWZ%(9Pckl)5Wqo)x6P$Yi7cNQJ zR??ivhXQ|uVSJE3<({4p3h(eGo@?}d?F(62hVh9vsAx`6)%lYVnhSwpjzBO2cF6db;0Q8bFt z`K6l{u=8*1s=?zMl0g1W4CJH-Dw`MLP%KMI`;cvuO2uEy@_81Ad;3stF0FJZR==qH zHp}RweglJHw3OjVNr3Bcxn5Ceb&>ZfJd6sJ zR*&K-gc;<>VsC$NWGOhZ)Vj?mgyEXPkZYR~DI314YssW&Bs)Ic5f51u{@oK;`0FkU zcagu)XJfMqt#`g{_D$2scf})OtOAM4JhoX#R|Bqo8=p6Qzc(`WM8*`XUj9`gR*}^T z{!aYOomHdtvM!3(Bp0{%+w5PMyOjjw6e0YF|Q5@oM2o*J zN&ZyE>4Tv)z>8C6N&3kZq?S+$7m4eTvlz=7I0jrgC*Sz)kglnw>?aeG;p$31(N;Gm z@UO_guMvWne)**s|6&#}`4^Wh7DK>4-8*iT3PJP#zRSIWeGT+^H*15 zGX|lO51ZojEr1@@TMtglH1$v4*0az7~2weAiI^+jV%= z8nJ~cJKja+vR_S^u%G7%deq-cYdcg~s@J6_r*N%uOvu=?LSGxBz$M5VP%O&rN5dH6Hmlp2cIU` zSN;{KGcF_x9_-((EHL^fLwrx7{Cd1A`j*Dz*O-|6Dg@k0e&J5;YF);^{x4D8b|LtG z(XV^>?|31J;!_ggzu@>tnt%QukB=S~8XtQd7aJcB;`}xR3uZ%1$Cony^1AbVhQ9eu z^FMv$ULDss2D1@W20BMLL*H_}`JX=WkUnxhPjtzbEczI1*3AD{2=@cG{N2uE$$+C2 z=2HRg9qZ>ix~dCJNX;K_Ch*UN^&hA{f#v7~%>TD_J^$aBF#kg%3V5I!iT;CGKlCIT z!j!>3{}R{rz7W@yYTa@j^w;MTyCj_5X`nMKYKXBOwbl37Od(Z&!XTKqEAfo{MQnJ^ zkJy`>!o-7S;!*y^sbhJ^)q|I5O^XKU{?mH>o;rNO#dbI6hRWMv@71QBj`YQaeQmgi zu?PMhDQUymJm0$`LLq0}`9WIab8rsO&D-O2+^xs;Dvzwo>;%jCcZ#HatziN)`f%HH zLjj*~_L)s#V_s{xP7+iQXXAOeC}O&whb{f+K5p4VL8PekEwSV9Vm{EZ?w|LawQCJ) zP)XgALHSza4LDiBY6XJ83=|X3PM9t6P=u|2g82g5#2s>9`91b$^X1ONaXpZPsPj-oOPMSpw-_in<6K^2TRjH};ZpQu+{$%y>$!P-uuQ|U`?9EyNy9O6tG ze@QjI4UJPjIxYzht44C7KjT>5Sy7jX#4(spwC1TKK72Hk8Z)YK*48^!^eVvucrwgUsK@g zL?5Ts_&l@mjVOf1f4D%=XUjmL&tu}QEB)iN+MlP|Uwb4*AC^V?YksZh!`GDdeP^?@ z1}c!Ueg##)Kaa6Z42>u8*Kl2q(s=nk6N9!1Lyx5y;}sNR$X$NBZ*s1*i8;vXY!zr& z4?Hc!B1Og&69zIOVZcCR?JnLUZRW!Dn_x@uj;s^d>3%5e{#gaxGSe)JSW8S|?NunK-3j15%u{L{aKL4wF*Zgqj5-{jvWzM|PxCLJF;7=&6BJWi`LhY`#@B zfBIfD-(NLu!zibn!l$7>^w!%koWo~S2;U48q z@1NdrD9v~x7ntvK+HtEcdMxLPKmLQgw8P2JguG&V(BZezj75{#t*;i=DVVpRAlsi~ zmQ`*~IUoM~1j`aeW?aioVHLkSgetB>6`{Bi#`)2h_>+EjGn{M34T0a# zs~8T(i}>l}z>`=W(4+i@aW}JkUu{G7?D_ueo9Fw-%|-<^tl+_v3KGjhslCG<822!X z_X%V_<URyNJ`{FBrGh_)UZ*@N^<9 zq42Tlp|KvH7mc~L0^zi%`&Wk~haS?ZIhV)PS)(n#(6X1iNi&`*nvx|Wr z{LMjsy==FqXCS*6!XXy|AlJAChD_r}=Vh?x^ZrjoLCqb^a@`ip!dAbhM+OckEH5sn z3P&osL7x5Zl8Vy@H@ipf(9=(qx3|=Jx1*&YKm}Kq*JeiQjD=5}iyHUiNAp>22Y^SuxtdPUZ;ADl(?tLGFQmVr<#g4*3b660OOV+uoAl8G*1A>5E3_ zQS|O1b{lSn=at3j*3Po>te}}lqZB8qTEpX)^yM9c!GPw z)(>=Fhkfxx%p>#K+S8(i`}AOy9>J=h${E3JNL8hgYw%kYxe~t%Lk#zWq=PGw)!b+{NaET zjL+zYEYGSC;cssd%IKg>3n+6|D3kZ2eWVPQdAc6C9=}dr`=pmfuEuXwWF&qUMusva z1Q%F-07K&g&ROZj^b(*aZeCz8<;TP-@M}{Gm_VE)&7lN$sQ8mYqwPtH(GvHU)c8!; zU!dQoz~5i-*Rp@27~+b6@Hu9cpcC(HgbVYPn62zs!i@3Sc=`H3JkG&mba&)Wc>IF* zpdQ^C*{=s@r0Zq-7Y)-#y_v+8T(sgKm!fV}sDs0|2H#IJhI}74Xa8O!+fX&=^U#ho;}*D@o4Cw*!Xo>O zt}qe)9BuKZaV^;o0unnAIVGb`r-dTmR4WpmO9l<_ z^ekyM`M=o%hbDG;x~JzR9T_9GO{Mq)Pn+WTq4~J(9YYaACM%?;x1bxTreq%?2QpOQ zx}wu*fUy}oiRnc7>Dsv!9<-$|6ea01y*`2df4xNzwNWwkJ0?}cP;#OBo2VbSO!^4y zc^*23fkuEs$Eh*}M^-8v0Ac0V1cVKCfbjBI3j|~5<7VqPKk;8ly zhz%#j23>rEwgIZCxoqmzSW{RZSZ#IfpPgF&;I8X`K z8!vV40L8zrU5J0x<?r}-g*qXGl@V;a{?=&Qq+GA8 zWUvHs&Ew*#G`dfkGp>aqhTec1CqSL|fb_;)A7B;p*mVN^bd_`ilj@PAgqT3iX7i18 z-%13Zibwthl|N;7xJ+ z;6^|}U1EMnw24eA$h5&76zIP0gpG}7%xDFXB|c1gVrc;83$>=|L3JIuD&U>gRFms$ z-;wUAOw^plzq^b20mAfDi+)fo`a!km2i2kagWVj60YOAs(~vD1xXwrdjv_=%ahUz|+H{|fV?bTL-T-ti_*ENl!GoIE4>wMrZgW+wK} zG^h6HHCTE;6UTlj8b_}15H5h?uYK^^EjJkX*rGND;D<+dOI_9^~wLlz*`kenoeN219eHwT98GNw%>XcU2{ zy#R|+&G%FyXNX?_f@cPX^~R~WEYvY96zjPh7B-ng^dDncQ+J&5C4NCeF;2mViF3-f z_I9q{#Wi(TWUAEy#Mdz6y$aQe#UFZ?{L#W(;Pi{~#{#42B(f&+$F^T7xQi$@m#}$Z zj&){Ec#hz9xd8r{JUalb8IQ0KJ`|BjFp&Tq6gEzOLawJmMS{~M1&m<%XOKUxNahbc z+&_^&^l;_{`Qr?Bjg61+lQ5eYQ`QmtnBDKOPIf;_50LpI?jK&Z%|jo1%;{O4UXY}G z@ZzCrP-*obj~yaRCO3%%p!yfFz|0v>F|eBaKr<`>=`yn=kO)VY{^8ncjw5ppD{9!~ zh5Q72vb@vS!qJGQe5Mr;Bd76Wrh%3?p9?ADEinmQU_A1%5L&Vk4}>;A9RS^%Q?kpb zQlMhBA$Z`gUbYQROu&iHF__nKBF;>LTWjJ(e0zLeOQfH++6(Kf3I9CS+3+J6x!FGE zpFtsK=>e^A9a0+FJiY2VuodRPi~k+p?u<}f#}KXIUNMPRKsW%=C2N&wSMi6lE;>M4 zQ;z|Nr+!*PwR-CBxjx~0<1jY2p=vBV_s4qs$;yI`X+2BY!aXpn3cB-vqHkGgrWda2 z&`S|NUG%4AV6BE`t?>gA2h_#j zoV#p?)=0t2FN?1rq=>T~SXf-w(Ldsn?6KDgOe;oOo@6QI>s5Fi7%#yF2E||P$nrWW zPg^{&u0vLvn1sh5k&d)@yrQlnj{stt&adl`#U@g7>N;exX-?QY+q>U*1dDCc*$(8e z7?zX?RACaVcFM^XN1Q;gzjJ-=+m1YhSzE(ErFhE4p%dQ{XBu3(earBtPeNrea+`EE z2B8knxPe&6*ym2B)qm&vFCK!$ydZW*abz5x`+MOVg=hE=;Z2acqcp-?f*ro}#j~J? zXX+!6{phQe(lv_*1HOJ-f7cd=BBglg4_Snl$Y`R#{gv9%2>kqL-$IJiiLa;=WCtPf zjGk8ZAB!7|YOK%Wq+`~_;~<}{@~|jj{;opDDi~|zy#_LHFRVyL9!kfkIM@sKN~kSt zA6_X=c)Ed7#*CMg#D(6%DB~F45WARp%b1QgbkHI1mF8HVWjuSbJvu)Gu_~T^3q_Zq z)&obVX;u$({@X<-B_xsk;W60E#!w&XqI|*h`EAaBfx7^}LCyCad66L4HBNj#srgni z2|(v7Ws7P+Fc)a>;)B2(5oDO6vi2DdzNk0THwDaknvpAJH^4j6+(ZgeX@N z$SkAj1Ijh6L89cM07{8!S8>43CzPLi0EQ(sa1GucYUzh8wH<6{eQem}na4(?-70DK z>lXkD>+3jFZ(0k6{#GZ<4;e!Nn(t&f=IL2h8$=29&!yhx+3%n>t3!2p$KfhF>HUlz z7`9&z55_ zmTg!F(w@?SKB31Fn5Ug-&i0*Hy}qF%DPnu06n|ib*~x68^>F>52PVBEYlxn&t8A|` z8NM97jsgkV*SC9~r<>deo#n8x2{r zb?RSb|47*X6zNmNiFg(wUn1xfrg3ON1)f3L=3_l;V3dMC1vEUm8{@bvOdw3I#IK#w z&eU6qjUQ$J6p;xW#2nRttJL^eF9o5D59l;JIgVT)3!i-3otTTT|2cOD_dlb5#=?8{ zh$K9fnc&`s6A@+o`C-_5QV~`7{Tdx?>L(bbRSqa3OWlDhKR^3P+$MIdjz6xl->n>g z3rMo22fmz#P?0n9>=8IvAym{~YnM+C+>4|;A!`8kLIj?<_Qs_r(%k;hg$%r8hcSUF zMsWD;)rh9hkIWXdJvZ+}TDb(}nC?IB!rc3|*r9k3U3D#Qj}zwu!$BdDangSh-@uTi`I9&mLk8Z{i0ex%gVW!t4NwMJNyy zZ{O;&BNY9g1zaZo7O)G^2^dVA-?@K*FYE~PgZCzWfc+D4g5ww_8C0zY`q7{VvVmlQ zyFfPXnH5k_$yb~ZL87D>Z($-gKL%|ht^=~0Pby>?*%7-+FJAXPq(Fjm&x9s$+v9^% zu~g%G{qj^)uZ|Ban{>2XGD0Y`9h0Fm_RU2sIdUx82$OTp={t3-04o4BAR0qrRli zmhWM_`OHnIF~nup`$-*s=-N&l?s^q?JU6Hd2wz;90^z0kpBw|(Oc)ms#wB!Ots^aQ zWlc!_zAE-9!j4ekoJ8<5OId(njMm8|r8MLA!Qy~aavCGa%HZ%)Fj3vv+;TdJW0~Vd z1zH6xh!wJ~pc2oyCOG-pqJN~l&R9;A3|N2RiNb8rwZ6&Ezsy+)E6$3-dGIyhA3Y%F z=Zr1bdvf`Q(q~Bb=QHw_z;%ctd)|Ebx1<3I-}VLI8bFLZmJpx~9ev?}*BL$(8;ic4 zLOiZ4pgA!MYAp`Go!ZyjUpT7v7e0?cFGQ?A@gy;Yneqks`?T1W-FT-R)eU3lK{H*E zR{8wu@Xc$L^w$cT%EW~1qZQtwMBy-kZC?Xqi;&lvokTK&tS0ETR-9NWH- zYo_gRvCNV1M2~v$)(zEocb2& zk9U{HM11B<(Ld1^HrCZD!ph{;YAZ1>N2C$7S*}^Jq;A z2kEC<<^dvM%r^?~1W)g`IZyWbFotWq7KOC&nLj9mF-E{)7Iek{Nj8JHKqmu8&8*RM z_5^=>$AZ5dNFy^XVf4g#?qJ@`k!H6@eqiY%^;Oj0whTxe=$%-XcJ@-^ zWhjYceoQgeoYskd*<@*W+CLK&4v|j5A=%EiV#BOf;j{~E52DiyByOZMIB~$s7UZ%KMwe1Rx(aDTJg=|QpOmX zgdh1gKk+FyZ<&1ix{rZEFZ7(c@kFnPXGFnNCuFgb*%&?%Vw z^`TTus=B}g{V(or-MIir|I@KDtLq%ne-|3x6aNH2)cAHhY;k(R_@0;wXyW*m`mOOJ z@exI8TzOb(g@`mZ*C*9#{C!~}<`;_(Oa9I6mOEwqUoeMBzk;r*Bk^67V`?`!1i!d` z3;9q1l7}F(@;sR(yU0J>mvj~LfevRwGgAC-kovew_+ig+@WU>g@iLyPv#4Sm`kG0Q z$hT4%nB#xYMaO^lIRyTxG2RFKSnvw`{bKOLCMW)-YC`+FE}&iyP-T5XXxmrCpuHvr z?Q?{d{gZdm{^>qP68|K~-vh!wl)p>kZNK=SMX6-@+a-R3yTPxw!tb7A3crbcfZxD) z8yt+uP65Jc(Z@w@HqgVa&!yD)Rrs-<%*+V$WnqhAl{4~YsQR^W5E|6-?l>nAIJCM z6&7wHHH_X?X_3(v8{ggZ|I`HhWAz&^K48%KEdA4j2BiM`%<+d)0=A)_wx=~F7&thfh!7|?F!aMA<4d(hD#vlLi@kmp%G1e%~8Gom-=dQLtA%5U9 zK+O2Xe`1-kE}?m)zs`w`f9UT;1iS!kr~k1H>#I3`gtY})Ig-Wx&F1MFfWu}H4f^Rs zv@dURI1ez;v_3x%_ZxGCgYzYEG8Cir_zEo2KsaQ4NHFBC#|Z5QCzbtRmt};jKf%?t z^aWyF;Q*^=9%fH%^|M_4o6b*q0JGA~7<;aK_=e)3h#v-B<>6+hy7*W z`E>2!dr;CH$bcT_fO9_;QfQyP;|_QFR(J50XapC0Bvx0yodB?lm(yp28_4477tGaE zQ?Otf4}XK$nid7$R-E91RmK%JJkAf8Md9caCP!>i3OxKAQIy@D&J9&8SU)?4cz{{bdja| zQ!p1!Q{25SJFo~y0fX>3D2^-ydzJWFNgZ$*{xjl~uP?`RgzcjNXh(KeaOiCh!C#`P zqtzk&5ez?A*47TTPEx(OxEIVKib}?;^-yg0H)4|5!=GLFQTnXt2ltUoSeA$TrCN{3 zA28D}@;eV&?oH(pjvsCHqoAM3!{AfPcZmy8^b8|4V}v`YVNHaa0%l400Rgp_&a~6F z9|re^9@sMa0bb!r;~k^>mgc89wa2lE3;Q^#1}hh#x64|@J;e^AyHPO^!@~4iI*GCN zyXi94{;>yRt@XQ>#E$F1Vv;b%;NVz%1dxCbDX^i1$9JK+%P>{=xh>O~?*tGM10HNE z&b9D5F?kRsoCy4g@dpRE*f+wN=8jg8v!UHHUcuiMxq|RFjfhkn}ZffrX5+>LB?{hv&q9U8XidjA4B^I2qb`?ne2`JRbQ91-1rSQ?6e|10)6u%o(|_z?U=Z*dq4aFg*eLlMY^*v)?%Q zRID#$6Dp}g!?V%A?SYC6jGwKrm4>I`onV2DlT5wjrXpkAJzaAs;VlY3m}DCxgC@x5 zuUSlL%4bUw!&Lr#a)1?B0Vea8@UHxy&?PwEKxU$Uc|NM(s9i{|1{2d?7lRdH5f@?8 z>|{Lh#I)F^*-31sMS9@};~0myz>w`)1081TmJS*?ANw!2;Mpb7C`3q$MR)Pwis0wo z=loq>*O6X(4XwPMe&I35N(ZW1x_S*lNC)3dA_pP`cpsuQ_QiMQZvb`S#z-bFtZ8hg zq`&~v8vYm2?A>%2m=+1F$DE9+zHle`ye#4dxtvCAPm* z729$Ak7Y*Y?13|=jM}G@Yyl!pqQZ>y<^q~v-n9V3nOrwpAu9cks&S zhnTQzQ%n9@(pKJ(RR}+je;{Rg*$J)jE*UvAxC0n)(q1=2r~eT2x8JI*k=@cb83+Rk z5`8x2)bV?=AwdG4tw30T@LOPRl*4BV^ybJIXhWEtWGg9|ucB>~>MCX$XIM)0R;_{a z1?Or`)q%Wir&#q^o;w=(Ar2e4fb4F_u!CqkcsnF`vq;jyg%8|j#faKC26fg>VvBm^E;@}T?Qna=AuoERT}v5p4#PSnL_20l_uC;qi& zh8W0^o-!$@`2YjkLDHY#D2F7#2sY!!$5}&hg|JBXtYNso#&Gw88>!TR+9FSwvqvI0 z)BP>3k!Rp-2A86l#i0CQPvP`nIVj&IlyB?(WIFWs^^alvsaanSM^Uv45se&V1pg_> zhwup`x&23>;(S;kDo*bmP;vei>PE$hZy3t1OZ+-zW9%2Y9+pH`?H|hi3#AiuS!l2# zAHs7!P27$Vohb1~)=!gT>zAPIr={>x`O)4pQQzc8AAbf*CEU!I^S<#!y79}!Tq#NP z1gxfxAW4=e+l(jYV)}1NtTp~DHKVi8cSjI|2xA0?TCh0Ye#Js70by<3PO>hJuWPH{#}iKPm4Y3e>E)$o z7Gay_hVs&rwS71KGn$sR1r1?=!SzW;#>y4gjLQhFtb?=fO^d&bq|B8!pR7~$W0dhf{A`s0MZ*ItD|NY%tp z4aPofASbP@N#*Y7`{k(@q3;zR{4ageu)da_68b*0qzn40^#lEu%`s9y(Nhd=_FStq z&CHDYI##V5s0XV*)q^$AX4-hJ5Bt3CcOt|6suM9v3QUfWFcx^xqkFJ?TrTH7KGIe{ zgCbhfq+;KD&0x_w&rxVaD{MHd!1xm%Em}^I2c<@wp$_Y#PFd$s|4ctvgyq0E!G>X* zrynZm$r@_RlaWK9uu{XVg%F^e$miMggQC}CO2GjN)c>Z(5$9F~D;E3kup-!@ZN_X2 zd*e?0ggR*pO8;0tD@81YcVe0`MS!9o2e?VUeAa@MjL^>w`kfW}Rf2xipx-VzDFOQJ z0sUHK5C9OEgUo(XFElcg?N;>LudU{GJR%J^eD8vO=Y@W4pdS=G;J1HK4NVLX$+Dg} zq>q9`LR1nqD7EeY6nYGnyx4-Z0ld5nyJ671gujTJOVl`OFnH!bF zWb3v4cBFkUf2TA3jbEzD;S7=%7{8sF$emnn=Zk&C8z0f}xt&i^36<Gyiinp3xfRXiBj9H0FHh2(@;OUmwn!J+cDTV%d+l z(tVcO9g_DeObTWrAMQvAR=*csg@ky0;c4|#tTGV!A`HK1aMRgL?>r6@ zZJk^!ZWX68F2$e211d%Ep$0r*l?_TgO!Hga**CN`tMP!!|0$Ip(Ob^l7+3>wn+5tmSu_U@mf_jm5XJe$>0@v!EZUU3>!)GMR8K--^({r-=<9 zP-sE}W6=O&qR0Lh%@{W6$*0~8(OSaTO2ItaWRR8PFPtF&wG`ld`cZUN!Ah)+2J3y` za2j|hU+?pfL+|yGtMQ-*5qS1QHYPLA{}1?Q*rcxc=dXYJU;Z%}^b+~!<-aEI&u=FD zU*aD%KR{!)^b6Czi$#KWG@^*rb=Crs-Go-XtJdKQ17{`H)k1;P7<`Zr9`Tg()d@&$UxOHv1d%H50zwI&&qFT% zZbes2YO{|Pj*=H2}Fl2V{b3Pc!X4ey&nF{H&6r^pR~fj3ygIR z`GsVWB}Tb8g3zX?d<4O&OZ2jLv^4`nmMrJ)3S*~0!i0|?{?+T&E{JSYf6E8s59Axn zWN;*=ZO|DRX#D(Mk`f8rt!A3?q=uy72| zhGCYX1(-&Bt#Lw(fP=oI2>8xfMZm*}1nfxyTJ-xBmaLuWmoDBeUC@t8E+qmm@L*jY zwB2Zcev5vcM87*8?o7W@(C@2XPNrXJ0{u{3jDCOHF7$hse}sOStPb?cMg>Xq8~RBX z^jqEWZ_|$#Tao!9UsSYPe@1B6NPBxi4;6OP!UcK;M{=a*8S_-l<)|6w-@U`#ox0HN zZ-w<;m;(L}iU*|og%QZbU<3{=&L8U`Ulb?x`#4Ss;hU5)btq%}w@7}n-qDY&0>&o@ zBVnAxPbe-o;*!5Bqpb1lt%*{FTnbY=W`nNmvEkpJ>qdgPgU=PhAv3DBP<{>05;;-635AR+X$AlL1xpfK$XE>l!lyAHol!DST)xX>55CY3g z8RR*ZZ+s3uAf{|nws?#@Lg^072J$x-xp4JG6grL?k1?nSS^!s8XYxzT<$q3X(4k~A-qE8hIq))7k{e8{bT9s@ zO0Qfhl|HBToC06QCLXFd%3^`%Oey`GI@p48Cy_2yqB#T4Jgg)U{(unt*qzE%83W@1YP zUOU!?CufPXtjQc`WR)sYUhvEhp#c4ooY z{@2A9k_E=|Q!X(0!?(u!{Qp}24QT1Q|K`Yy{O|YQ7F=2)XWkR~FBd1wjk_y5^%60scDmUt#S9 z`|oe%m)L&^{uw{Fl)PmBjEc2N2vw|ISJ;AaP_g#0!mTnMUM&oMxD zcg0$G%|!<2qxQJ`AGuB+alwq`#@#gOZ;Nlq)ex?D(3+C_4%AdQ$6`YeU zXf{W(U}!u7Z-nPNPNczBH*6Rw|GA2_b7=&Kk^devD(i1MF~5X%Q9Eitz0*;zxQPJ* z)Cv=HbelBo`-{f*u3&ra&h34a46iS^{!V<;x;o zR5|1?EUrMrm68gWUd9^lOum3LKts&UU@Rs0MgH)6acxe?_aB0p%=y{LR;%a?_5i>~ ze5FG*ZSR32s=tK}2H3(=SVY`yBU1hvA zDTNeNY6&4dL70z}xGMR6#19ap&BVWojm$&UOPpHMfeO|Z7)&I74zUy*>D4yNgK43ljL$rY zK13Ej7NRp))mvE!h^o`*kcp%w%NoD^E4t5IO((6LebHXpqb~vlU$m#E))%#VusZ<$ zVS3{Rq86;i2HL)wVbEE)mJ^-IC23){t{e5+^pjoCQxK)>2B-OZ4FEbbp7l`GYJBxt;D{j^|^UFtWs_ z{b~-{DHd;xXEiUenwf=5WSmYxfhj0}Y%&A*j%zp5;f8`@2&7)DXh(k(^`a;T#}o>S zFb6Dw?V^9*V(wd!I|<1}VU8{fzeE;#n)wHH&Obl$1z)tc7nd5OGTm2L;&17lT6mDR zLZoJ%%*-1*XRg&v^8u`Yha;yT2{Ldf^sY}UxJ3C7Cd=jj!I)+60-&OBX8#Ai_i%ql zPVPr1(l9q?m%%rq2G`}u{OK;7!rJ^FTBP2MJ#1qtnyi3jqC%u0awxBU&iVc~Bafg& zq~TJVedg4qG+WJP_h2)g&9aLHu#{%QP}ksZM)!!7qg|L1NA1@4b-07Mz1?MdYb$Qm zHVmtpUye(WaDzZL{<+d4`=(zN+y9a`f{NDfcK zk1_pD{OI`UJh^r;mzeX@4d_XLj766fHUO;N#f0)QoD5RTtEPRG&X?x=g29977_Nc1 z1;&3SB)iTW_G;I;rl;)FAXYJE7zeZF8;5un)_)l88vp|~8h$7{ytqamg>L<*3*&Eq589&YCYG(%(9{1(g*G?GzaYinmksP5IJ&~E zE<|D3qxbNF&BmjJ^x3Wm`sFaTOyG7fWf?sX>ShNRG)-kuv-U1TTY9qij_#5V}1qW@zC5qV&ON{7LSE&3#mRA4}!)fdD580Pq({cn}HP zO+!MPBrHM#?JP)W!5`3U?=Ph4efX1HHNL&7zWploTW}c+$Yc3*aUz9ArZc{lrzPB%zAH_+kY^NeT=` zj~US@BhTz|``?i=FboT0;9Up;^KZd~)oW^S_TF;exn7HViUf{ahlKAT z!M3;$o_?Ydhv4yzSmG{~Xe)_MEji+BhB5E(kxGDE_^sN08N`L$_f%X&pNro1nei{e0+;=1wTEHlAYQIfS%%TH{cpVais(O=XyW4su#>2px1{?cqN_e1*8dA_!SP?WibplvRAgBZpNm4h2=guxupCDHI#5FnGr7no1?CCCl#xG`g8Fbii7#0dME!Uwh& z|K4x}i$YqI6^id@4-aBJP)Pz$OF5CR;onHE@mc>Z{BFY^@;gZ*gs{rjZ)b;dlTgtt zHvf@!%TY(yw3}-zL!hYS9#ypCh4VKi7Yfjv&apwN_cqGAE{TBa+>E^&;Bc&{?*B2U z&faen`#V$&=z)i0=U_216iwa1Y&ybw@-W_U{JDa25v*RXqpq~b2<&?qqj6SQs)cI8 zg|EpEtkE63Ekh2e;uZw&2vh&4?-2dORC~TC$8jIu8u=Vn(|077Mh7lH>Le;afG+Xs zH?t#kbfj@Vv?T?Aw8>I&IIwhHMY|!#7@i9;iqhR>ZQ7cXne19%Z2AO2fyjom*cXcQ zLQ`&k8{9-}Zoijan zM-LY^#%{+vG(G6*;o5iB#eFdhh{p<>)qt3Q0l}>?6*ep4@% zIP6rb6>d#RE}9b+C_F&4iyR7@94DA&jsuF6$bUlUPWrL%@nrnD2p^B{r?U3PA0GSl z|5*xj#vJEppr6BerGjgfk8xzK!vCHaQn?KsDlhGg0NHrragilFR#hM`as*jzp1~$k zI0Xlo8OQwRpHSATOm!1_<9uJkT;ykcjSS6i;Z0*pCO?2m4*9#haF*}Ps+IPJBUlR zI#h!Fzlr#_%u&9%0IzBs+(Js{qfs}nPK+5u@5sUe=(jj2ZNW&TWEPxEu=@-0NTV3R z2oIw`E?-+Q82kI57eFbWmS8F}Yc`%oe2Y%?z-oI)DiNO`RR{bla0LRep_;SM!cQ<3 zl*%FB&tcTxE;Ft(2?a zOYw)(L~PtbIkcG5n2ODBkzd9{JQ+9OM=yJO(e?T$O!pkymV)UXxr<|nvfQ1Hb8ZJy zAT`e79vtIi{J?eweb9|Hsk`h=E%<$K1efFa5V0`%`0?rvexCBC1`B)~)uV;)W*RW3 zVBJx$>S`P!^6WD74eGB4jbuJxjRr}$21OZU}Crj&_>CP8q)ID>%XaL?1Rr7*Rf$yDxE-Z+^CtQ818khAJ{RJQUK;ty(k6N`<{Nr&eA zNPT!B_8}CxI;bD@o&As6yvaX6Ez5gP{yF|2UJKW$=5ai3Tc3s5edRcwHpE?L`_AG- zNs08Y8@GY1=7#t!f$WFN%UWnRkn2;^BfFv7g(BPavOleuqxp6s4~;9nchBR@injV? zya&d;T()B|eDinV_|}`+>hCfw`x|8~i#`KnGSXIHk($$A!JLUd!6)e@50qNrXxVoo zaKemFFirU6G-PM^nrof6;4b5vVbwU40Nq=FF0vE$_Z=(x*5o0>qWQR%;IS4)!Sj8X z?r;6VHqn2URiJNb`STEe9^lV?{J9%HX1m2nbP{yI&EGB8_EDs>3%?EJ?f-0}INf-Yde^eJouvm@}VsvMKYA1CC%sv7G z%g&$TBxp${0ru~w0M}anJj9;|_;VkB?#55Zw7)b0y4V`Pis5p*$zGw!8-&G)AEfUsn4UV)B?_?#d_H-1ri|wM-FEr^KH04 z#2EU!(_IIJxx6rO;DoC&8sp1`*psrKw8r5tz_owi;c1y_{f1q^9xJeOwOf~ap*-mr zhsy`U!g}5dMSoGcjuk0VdLY?z8In)qww~ak3^Vz9CKof=^E1Ycty+LfSQa3*HRe7r z4Nh&LwPBV)i1GpVb3mZ-D~3DnpF#UQSKv|*eh~yR`DNtnScXe`=AMDSfGOgCJ3 zHL?H=_yh2p48meT+dn=LVjfrp%8lG4#5}B$USU#SB&85@@UT>3{>CDvqTkoz^pj~> zC-7Bt2$@BPka<`%n9c=IQ*<7s?r+*x^fGuyX^q@=AaQ{L3^;8b4M%u-RX&pr{qmG2 z5}C+O(BVb26`f$%>5LClokHp3)4+?r|AtW6V`N+3P(drcM1Enmz&!>vj%JdWb4gY{ zp?%#ukO|;^0eUa^k3QKr0zh+pv7)zA(OZ1=k=M8fEv9_M8phb|Cv=E9CLkJH@M_e; z{aw@xRU%ez&^GsD=@9QqP(QRmI>e=t?m!asvt=rAoJzcw`4%9lb1%i6Z;byOlG0yX z$^%~nvItjNJ*R}k|8#!5$n^Wx#pdULy)0F!NswO``_935p&I_D<;mZ*V@=rrA>2~Z zEIXi7XSBz*hG3;*taLk<4z0$6WHR#&5{c{2Be;r!oM7+ze(-?(bPKGjY2M3lSqIiC zaYYZe)p~je)0l@v6Q~k@RO9b{Y>$~RLT1uK%TKq!j*qw9Q?-iLsljr4W7|}1YAYkW^+9Z^<7qWn<-T26Ku%|< zs`N#ZD9pN4@cpzcm!Yun-bOXR5%aSJIC@yl=oG8sCKLRD>)|}Z*$=xjV8X5NH=it5oP}m>Qkvan{C*o@ z2KnXIXX#*IE#xt~2Jp+Ru<%+L0g+o|%Gc97U^zxWO#g>1=QD8^_2nS+A8{Fz5Ssi+ z`9i<55ugYpAh3YPnAUPOlW{A1ZiLf7G-BHbvt|^Eeg>G^Nmd6x8|ed0&JHhzH({J5 zlb&S!Txn@JTTl(_$&bG2>8?LYidtoQKW=}{zJ&JooKX0){fv0~gSv13V*35Xz6<=;{Tl`B(NgM8PVg*jg)qJc zhu`)3=``cxNis|d%wfWe=yr6pu@skb$OJ<{4f7AuB0q`sk<@>a*+1Z`x!jvd(#_CP zFz=IJpH5={Lj(*|%_6AHu`$vl^&gJ+c$0Bm1NzCiekskzwGHt9vWxS7?J$df2+Q#Q z1T01tCW1t<@R-$10_#pUM_xp8&UlL-$;k{V@U&mb(Ia5Aa4adp*FXMON{{8xE zfaiBtb=SX7IZ_DRxqq)S>6gqu!MqWuIo_WSb=$;^T{Q6{Mdp8lzCYOle4ZP9iS*qf zC*{arG4}nJ>3h40zmq(Q6^ES5gS$7^9t$PcT;C02wbBVkj9NxYeApf#R zK(^+$uK1mG6-(eaBlALVQ>`eLaB<-|m%#u38vnWo>|YBmk-l?qJ4Yw+@GsMMgh}6g zN+pV<9h(3`I$U=XWi#;Q;0*;GCn ztac*5PN_37!P2kA?mZ$!#|}XcHDh_fxvUFeE%3$kmr$Yt(@W;BIoL}|6jTvdh=tyf znEp~b*phFw7JF^R)!@X0GKz99TLonxM0O}F*uJ(pf&yk8x~%F;;XCj6} z!oZ8zMg@gmv2un#8Z+YwD{z95sRuH#TN>RfA*Wu*@C@-C{U_AWzW9ed>zQ2CXGHf> z$?W?=x~HG-=y~f4Y$^BxQt0sA{H5a@DTzl`t>zoVf9zw@Q^*oNk-U7x`Ocf|q9%7^ zWtaXNWznCx<9*2fgCc4(o>0sM9mH4%|K7;%I0q^EGo+_A21r&+G;#Zx=YDyUbmIin zL)?s*=DnT-M?M^-{P7g?5FgG^^0GADZv5s-Vug2{HCI>PA(SdiO;(I%l!bW?>lfpQ z9Y5_^ip=;ov_xdNbhU zVrQY<$O3@4$c>S2`4LMcFG^D11dPU2@SJ3j1avPgQQ)e4V-d5_&jS0hSeOwo=)cB9 zQy+&}2OPz$1rcmv0Y8K~F9^Zd<26$evsf_$O;tot#@Bi|7lyYB-CyjA+n*GE1Ql$D z+Ym?}8kGnWc0I8p>cKdO?l2*juLKu>Ik`t$!bt;uEV$Mw=)`(_zy4kQ^jX||+!JX7 zkmfMf!jqNQyoxR%tO0}-C_7a9MGzD1{7G;53ox2AB!pRD2n@PW&yD)dtRW<$Z}R$b z(wK)bhnV$`-%6%7&ojj9zyxLKnonh9gf#r5G(IkIN4Rv6aIq~(l^ui3Hjg<8wlcLl~3ud0;> zD2s^pWqWI|=?Gt?ZFg^%k^EKPC$Jy9=Oz*FP6q0DPyXB~%}c z4^4SWI6vyLj3Da#===)pz-xtdLQ-`U6vFCO99+k_9VE(w&IjYkSI|%hM!8_ly`|5j zC)jtIY2VI<{F{z+BlJF?fPWu{IB;Bu=kZAAGY*r8M^Hmy9cpAl>BdM@OJ@*lx~K69 z*|KuGw&qsT&^gPpf5JA=$oPuzHz=ONP};*s@(=GP_S-Mw0yl-i`Z4lBcXlvb&IE!2zQInFc!2@Xb=PkCg0(@bd@H7}rU; zK8%^+^1Bb7DQSlP{Kts+0t~Czcbxofu4xC;jO}|=_f|nNXsdYymYEhX6Z|}gveDwP zvcMrqh=2njYoYULzrDsOB(ND&>6?@1Nqb&vyRj&`C{S4QKi`LhT?1)zuUv#?8?e< zN%PB%AD|9labt8=>ikkW)Eqw;vbLYT_feWLAD0=UfSvI{pJIuFo!CD1s^t66Kqjd} zBs2&C!ODv%7CM5H#v-IeK?ui88kUoo!IjaG9XNnf>y>NP5xgG(I^hv<6CHc*f`tr9 z#7_8hBO+bh#+|%T^Uu0}*uX6)%a=EOlMhZJv-JmE2imdzyG-O4PX1HYB1MIB|b{61o`jy$cGb<}=Uq*BX!@I4qe0djf* zF0IcAZP zkPv<+A-+W;A<{e)0;Fp(umBUd$as@ywS=FL7B%tvt%)B3b{C}JNECSjC%6*c62}Yl zUL7ge{Z?VOG&&N_L8oe$!R%vKE)=;X(DqA!o$ci&Vz(7{r1>JT1Q{rmm+{9Q^i>0}ECDMlif4Iy>B6vN|z=Mn1QJ}-hKARE+I+r%jc z)3y*o2q$BVY(#P^XXg}$B<`G&&%eIOmlHXv8rbi_)l7j($RX}U1;!dnu)$@DO9rrT z`D;KGURQ*>qo6MuXTGKc*(~A>fM!xt#!mxGgnNyppQ-@%2M7Z=w+O^{5Pqo1wqHL7 za5s7sxW)Wjpwmr{Q?{?UD8w3zj3>+n^7VQ~1#xcXkFHIZGjg!-**}!R^^|BD6}O;P|%lm+Z?f z5#;g_gf4Z=j_ITwnD&`lWBNhB5y=749@G^09BkCkL)ttz&xrE@q-9^ya+l|i7H>gC zi1C)F3mifIsA5BVx%=2z&6jU4WXcxyPDscpl^iqvs7K7qII}j+pxSSIrpszC?@YaKS=r5{gdvDmD3z#fhMLvQ^lwn^0)IJ^sd zvGudHe4gcqzS($WMNiI-D|Mypp2@LKKhj24snBfT0Q?nUooAB!y>Oa85++glNaA=MmEC*zW9+byj zUXi6T%#7zhHK}kZ_ET+j!ur$^vv?qC5$rElrr12tWeEOrQ0NhgV4gczvI}Wb6lx0Y zU(P`PZe{QR@Q`+hhYw6@Wfmwxa7#JA3n!mBz$@4hJKIgXV25tWD zolM(uGr8gC-zD8pN^REO0RPW38MsVM)s2f8gSMt(WG+Ky#h=Tp5;(6U+5uqT1f{dd zmUjzaDW)Df)}6iso4X@w#?s@7Hi7~ev4*0)>{#Q)sESrDm^T0cD}kP|oX5IO>MidV z;0(yRSJ5ua&*k+;F&I{XzqtRK2aRlHcG+pI;bDAkY>)K7zl_HARo7#G9p6VoNugdk zGgQ*9uK@s_n`nqG693ip2ThD=b1sS?emy-_D)4<6wHJ{t8?cqfefweM(N=*CwR-=c zasq>c`+kFU!SHY1g++JvjV z@Q>pwCE-tNedEw~Zli2ARwIKjrFs9N@hhu>$etweYwE`d_D`s0#8ajvI)Bi!I9z}k z`>Sv|=JW)rkV)WGV$M&$$9D0EMLdsIXym*jenJRa2ED7K8S)V!{zy3E+xQ}>da%;Y zT3Su{1=>-hL#>16yvut#;FhD8`|6Lg4`II=4?l(xHSnB(#mlIa7Ca+at3wKwv?Z)V zdVy@M#=8elDeD3LLEEgoLjRGoK-qQQwkT`-pxq>D7{uwMHpGY|^sO;vr-QVCQUly% zw_D^F$A8e4`#fw0*L?+wXfS61xJ(R_eXrxF#mJ+?1kV;Bg61`{--QG-xLc8mph-(w zmBR=g6C16ii>cl}^N9(l>V4dz8HZNjyVsgOX_LX41IzoKX{NI}*1W?%F96YGMH1>k zw|bI%FkK*dYjmGkh(24Uoe(Pz_(yegkd$~f_I?ai>5&*|fFJBlQ}X36j}+}*0dJaNdmA!+ll|9Hq8`!%H4ftuY%0O(8hI1fr}kGB4Umc= zgLKBgm0Gx-L8Kha&ae-&s;R6>4_xn?JXz`j+bwe#cdNQw{$)V925B|?i^W2|WO@+= zgg?wCzlSD&tPAWf$e+A#@{iy4vi!+;1%G^#|1g@sUWUBimP|Ph;Eyp#>VP483hYK) zljM1kjExFhe1tl7+HS@lLXA#(^P}?!fD&V9rCP4Ysc*q&Cu~XIlM^KVR&y^#`mZ|P ze}N}aQNV#w2d#@TFfiCyG6HnqAl8Gtg%d0k0>^Lt<1zZrO}tNTf)ZP)!?^ZtbKqfs z$D~&&K#EJR)ca?()yDyx2}3apI?4Dto2ud>dKS)oX7Z>QE>l=BvmqTvcyR4WE!gb_ z-hA>mF+SIQHqAR<53H{P0yxNHJd0s6ANEBLrVG}HL0H8>h>`ezn0puasH&@NJb^?4 zB%XjoP>2SNEhuV;XcGgP5YQ8uSU{>E#L{XhwN@b{fP_nM5@9-wM#W17T3XSUsPRPgaBSZyda2zqMkTtAt)eG@;%Sm=gdBHk^r{<@BRM#eq_#^+0Wi#Tpw$!WX0>ogC33+J4IfJ#O8q$Z$0P5DCbE7qu+r#9%ns6W zRy3Hwv#mE$RZV3uAF#~dIA|VRM3_ufZ?mvq(za+1LDu~TThMZ9@o^q($F9He%ybgT zn$Gh)xh#|?NppOXyE~W5r+pV5_V~@mcW%-w$0tuc+2IT9CEeHx`W1Jy2@V65#8r`( zyy{#g?Sgbnf;%nkRE1n=y$pd?MY{rj-FF26?4ZJ->ED>!zv3>H+`_Y(eZ6tB2~Nrx z*jN~v)1wge78=k{#hhg8_T$d>fdQ4~)WhT^Sx??OYPxBw9zF0vdhR7P#_QdJndIyg8Etx)Ge z%oP19ul(wm(w|rT3&zVXY;i*K8@PWI;S$Ql{^Bopuw*%c+!2_Pl`6$6F08-dZG13r z-fnVGj;9&Vp`5Mig)cx$!|EusMsW|y!O+n4b$XWdWeYRa zOAc7WYH0+w`R1O={dvZ{#Y!(=x=W!SG-c6Dn5r^a`^4p7klU-J!MK2J zh3_n?F>?s29C-GoGGaR?|MWDh_J12DVumUtGwabrDmRY>4vv8L!?AG%aG@VUhE>h) zk{*-uE9Imk_y^g}jjuum_5jPmbDY`OzlH}s<8lg?Zrz5_H5GqgW&A!MQSU~@FqVq^ zVA8Z7Xoq#@aM-HY~6JP*NlQglYu4OWgJYo7I z7wh|wR2mqhW3R1eWDH1tk7RjB%uX0L2l)3mFgsIyKD=o%!$E}5B#IO4$qltaB9|Q`YYlI&SIv=}e>x7*_t#=ogtSoX2*N?j zfj9HY;^?T&vzkqD)EG5~ch2nralSLAg|O8A$L1|Y#l>uiDYi@B!8u>&;+vL%<{!Vg zM2Y|=Z@n1cntT{w={)pXa0z(ajzSbz7)1P62Unhlt%umcUE_+%wEe<# zl~vJ%m2KElq-brI!Vu7q?ZJn25AN!v1=2XJl#aAO$Eaw8nPzYd_OB}YL+fW>{t)~F z!Tc)j0QR?(-=pkLm2d6E${nmffc<@dBw~MKZ2NmhSzczL?Z?mU2v07OQlk%PBAHUJt<&qS)pkXyH z)`%hX%Y`9*?*F0I_>Qv1J5?s{U5!lsf=pU9JZt%9t(#lJ-&-0P<8R~MhoHB1d^<_? zv7y0gEdtGqO%a3JRr0yOKI6Ya0z$T&OYt7v>z|_ToI6z3iv8eaA&eK-vqv+kS~`^tquu35&FJTO`BcS1nb@pufa1`osZeTsB`024b~)a(XkNv>BWC}H z8cE|=x+2kO8hpXQX)tpq>T=>;&MF<{@;5X+KgQwByhYjem#p;yg$A*iZT`FI>A^WlnJEKPq2Aj zill8x$-4MVoUt`7y$~n4^cCTAi^uhcYhz0cRY8cEU|jZcxPiqT+DZJu#}Q_c>M`Wp#Hxs`rm61^}k#ilBMcZHebDsS5?+m)-f3YwF#pu zNT5fAFK{}PtwxM1(OS{)5@>kI{}Lo^whl2kBEiK@W<;!%0OLhiDF2(Lz> z1?hX_4{qL2%Nh zvDolw(j9xhij(}+xqOqT-pBzyA7jmiQE?$!*ot;IFX%h8COB%T0DYwGmff-38RjT|!m4D0`fArSf(uJtD>a}|Q!T9JDH05nqEb}`xcv??o-RQ>mrzI6NI`y!aJCWU zm&+vM`Gj;h=Z2aSt27J6uaa^)sjWQYY1db&=5p@(8vLX>aMEx)TFB-Vo>K^PIz?Px z_fd@1XVlT=4KWy{WSW4P>>m_=))EW^WBr(NXmp`gK zFl5{A9A9-XC2bJGZ3Rln~{DhL!>^~1u+)+a~F zvid3)W^w$Lmy>a8DEg#49uI*a)Ezw^>gsswd7qLJf;?vzVFvXN4Hpnt=aPsZ4!6y! z{^vcC+TN6y#>_IXs>7(@6dEo=g`dNS5|`?3$3PrZzhJwihSA>g^?nz_XobCT+UFjl zAo~E8b-<$1C=O(fd^kM(#71(6^{v8RoWmd1Y&YBrk7KnL{_qv^APtAS4|u(ovuy>F3=40z%Oj#vcx7=q_fAZ ztPOrd#vssB>w}lD#V3a#2gg6*s;f9+?LhV% zfh5yxOxOze;Qc8Kj=&CY_y*0d^xngm1*zdZqaYA-Itzto&YyF01WQ0m%WhF6| zwyXQtu1-L^x(|h{A6l`mG%K>A;}#6+7!^1%0&@jNt^1^_rHH0cx$|w9AT4Urg$R?l zooWxtCau!Kgw{sBQ=Ou3zRt+QJ(=n$IYg~AYy)sWtQ0p}Olu)%4e{l6AY{dCpR;e{2%cg78>Ag7b%Sfd)c5PMT5iBc(WdyTY8ZifeU z$87HU7?fI6msb(XJKkg(VjUobm?WG~Rha#G>8A|-YVfKcIJSq6`wtqdA@h#N_$20s zMv$BXQivVqdDT!=B-DlN`c|YAMWhumS0CwOHk85{(boA3hH%ng;e8MuktG5(hIT57XHJiSON+Pf_cfl?4zZhQJd@K#TW>)!8%qchlyaWLQXGK z#^o@9DKD`z3XUKOF5-S@4?EER$Z*h4wLqZa4mQ@B>6L{8nW zf(AhJ2tll2yBOs-dZiFftfLg=#Jx7F6W1<4ccoEB5Ye)))-X?BHE`1Sre_W6P4&-` zF-qd?pQ-q!2=v?W4H{foAIz1wbf=t#7>~B6hfF#qvF(w$L{Mm|V8`xTA?$44h6Y6f zLKnWB8Jr_~h4Rhd zwYWdwKm#8=hNG+jTY8h?Th zguvP384rEz4u5Q7NPV4aEKqhUR&l#xcRM_*w=O~FJ;LN@tPB~1jF}1IMD7?1$(A~} zd*+GZ4xHat{Q}PS!1Y5i^a%Mt7v|Og<*d)GKJ-nq^~hlaARq`LqslP&MSfT+9ExA` z^4=Kh%xm=`fj(BkV6rTFJ;L-4vO2T9z#KXl;`TlAg*j3y_N(Jqtbz8PJ0BQT7i8f- z7FfJQ0QYzePph(aVKNLMq`itJ%^JqB6QLrI$M9Pg>R2h@Ldgl0nd>ZYF|j_VwYPOv z<$JQ~#dI&rwkBZ$Q(I=kFIYh*wZBDcBlcIdt#$jGdWCI!klGOFFzTaEMU0jA4~(B< zRtYVsMCmwK5x-hr&=HG4Gc`nm5gqFtWUWba?O(@Xmi9`INXQ!Xp!92&)-T8m!8KsmtB(ZP|Kr(Ee7{-M~s8DOg0fwkD zxCVd0bqUdv*JuaNB?Df(85*7dr!pxajIn;%)R>nbRSFSs8ENQ7{yY_?eOOIY`LGnj zmt9+mMIoFqhI@eK+=7;(242W|eU6YSOG2EYWMVl&@81-?aUOcpTGESEI-1_7Od5WL zMp#@Se8w0O2-C2-T&?OT%SAs<*iw8%s*>`CU^zGk2C&M2gL8P7WgUFeUB{FLIBPkG z*U(oShh596e!qpQvUN<=ud8b93O&zNq5m^mq$JmOIZ~o3MCzh1s}jF(vzclnWdhGr zCu;oZaLHXKu9Iw48cyMBDbA|!KU&Cf(;&)0Jar!B3*QX!xCnqyv5H*Hic&{fk*&4t zjn;+Pu*EGs$Nz3_7m;5Uv%?AyJNiS-zzd^^T-Toyl$r%|JV=_I;Nr8-}ZnU14 zTHaw|={e5Wv(2mFArwM?9ee{LSQGLhK|Q!*P@jJqoiu!|v;g)fMNf>cjkQ#5jF3VL)WRBBk?g9Y6K33yC$=AoAN=}9GXIJA^GrGR@cwl5+p}vT1bi2PZY{%i5r#{s z;%q3~Rt&=9Y}kp;^`U7otr@Tg=9IvUlUXF{wWZr(WS#3n60@P+HI1hH&k^0eWQqNV zfr#DE-$~QrmZN17JsSI-$zvpvkJxCioI^eNfHD-N>pEw-mYc^Pl8wZgEg8JGki%U-sdMR{>*l%u@p|7I)k zNO}|f1ysOweH?EDX%~b>Bw)1jfI$J@SzPwzmWAuRW1m!GqaUV)P;8o!^lQ^ z1$Yz9F#SWH@NydKhnvCa>Oo#kA8AKUW!*72MYj&?j$hnII$^!`x?}K3BX#K(n6)j{ zqg$i1qIJu}cSrR=Cf4eZR2R!!6fbL`PO5CEU)geZBK2xm)#}KbYT$VOVCjWHGcJ2r zTeBylux|&ieYF*~elgwAR0xnrgSbJ!FG-sx<{!oX<6Geznv+62_hG zWFxi~UT2s8i|F_;l=>8NsO6~|q4*h7u=4z$IkNKnx#BJ{vhsXk3^f2THJZtAlJy8? z=H!``AHZ7kP|~f)0*~0d#ko6i3D*4^l`bcQ=iA|f;y=eOA8yEAwt=v4CL6vI>eB&z ztW_wrGf8{uePJ$x>+jogHdb$^wALI;_+CYU$p2!ye3)WnwQDHl&&A|G4)MZiT8BQ6 zBGX#9H)}OkLwg)pczG0m7q*hWb2?ZKO0gbkD|57et>pf+le=Aig?9eAq#sg~-fF88 z2(6x;v}!U)nDUYEm)n9r)&v9-9V@)b?o&kvgF#y`_v=!?d$Y!i=|>4Y6*(SIj@ z;a}z7qlGA~5mANE-6FpD;rzEo|KZwG=Rc!0{@cX=aQ;>Pt??gK$bZa#YxE!Hj_pVc zdgA)Ov^DxWEdi?t-Qag@Gb^- zC0Ja^1nhbJi>86QQru2l z=qqyU*QPJuO&@5J$1WnB-P z9|94APWS`NZ0T4>{0is)7X8aDzp(fGBaxr8|E~uxsXe1~9BK;8+>lU;Id~3-q4vxu zkwOtUrq<7l?#q+Tw)6gLeI~*4$d9pa0wV+tv?6=#1RG z+F{2}&i*IIzIwZb&3#%C`}*4*(s|-$RP2(bjYW=p^VcP>?n8TOxBx36JuR5EaIIU$ zI{p>@de{nweuARX=_h!56Iw3L(|@f$J%4+u`g8F1HuPszwVSserawaee`9|+C$Ybt zQN*>dzyI6%`(N|N`1wTsC1;IW_$~N5nf;PJ<6bVHkMtohe|p)rnCc7h4kufT<>(oj z8{X7}Et_a?=)CQ-803DY3ujGZfYwLuX9}fUnTKvua6lIvS@dT9k(ld)zE~{OmEqKx zT@tS2!(_0i3!heXhEcx+A;rnU)B86Wp z`0o!y%0J(W@9M%QYW!G*zfJHjYy2mejFQTg$H;eVje zKS<+m_2Ngm@TM+*k;2C*{=d}xd+}Xecq^p&SNPY?qx@dh_)jn!7G3{8*Ze=G@jVrO zq2Om}{1aaMgD(72?`Zz}2>*8oevroB>cx+A;eVvdU!?HsdrSTA*Zh0&U0wJC3pD=< z|AF9N*7#2_ffddFEt>xs8sAglmkEBB#y{c3Kj^~$B8c)aW>5e3W8r^=;0I~^tzP^{ z7ycYw{vw4RsQ3?S{=N9FF8n^0ul(;=g^yGGYy2m#d-*TY{4dt{o(lh38s$Grcx+A;V;qnMG8Mo@ZW!-`S;?xy70$;ulZN_biu!@@t?fr z<$s*!e~rfXRQUbp3jZ4agctvy3xD4ht^XGY|N8_#NaJty;zzph=jrknDf~>qf8U__ z_u{*{@J9ohe}x|+_?I>Q6HH4*>;G8I{|b%osql%4e~o{_i+|9CFW2~8>B9fp=TLrw zH2zjEexwV3{H=)m7AgExY_{{%-dM)QBO=6{{W_f&YF z;Ad(46JGp-F8sY3zw3PAznkKpcup%IObVZmV_5#V7a?4*hxM?N8`kRZM|IBQFidzP z<0#zwnM&3gufwzFVc9w7hmkcfBfP8m{(E+ zU#;+of=|`>d@nxJgy8eqWO2>zkUUHtRN@d@nxJg}>-Al+RiO z{|f(gPvQSl&A%7lc$4OT%$LBUPXK(5!mkzl5{<9J>{2xUF8uS4M#^tW6aFg%U!?K4 z1w0yG?7~<7Do6}B&A$tu`#-=d{cAc`_+KXYB8~TZ@x?Cux|cQo3V(;-Q#C%{i_di7cfAv# zzf9o=2!8h`ntw08@n@Rjht= z@qRD9*o8mssfhfl6@G!>Q#C%{i_di7FMk~6W0x=WU*Sgye)q?ke=ojql;(fIlacas z6uy_@U*qdAdlb#T3;%bv&$jmgl)Jyn}Q~YbZ z--|DH;lmcnSN^A3;a}@c`K4-nz89bA!Uxs>ul#SB!Y>s3?me1+FTQc4=Ktk$pg)Pq z|0(=9!7tJHI?P5z^Y6m{_AQjJ>aVG%@SiUDB8~TZ@x?Cu*3}XEs}+9#nZm!u=X>#) zF8n>;0&my9!mkkg?vFJ8UVP&S&HukUf&b2me}$hZ_$3-&huNrT{$2Pr9A8oXqv>qn ze~93VG~VyU7rXG6ZHvgSTHzBF{~Dj~#b>(kkF5j!-IV?-{M#v%-|i1J|6Y9KaLxZs zt0MBxQTWAzU!w7KnDUC|--SO%7{VJa$`e;0oAQsC|OuZQqoA^0MV z_j~chF8rq}Bl53Sc%R@?H9p^q&vfCF7=POFkHU9T{C}YN_u?C`*ZgmJ19-drSNIRk zp!}9-d>!VsqWO2>ms|w>OA`HS>Mr~*6MT`z`@Q&L7ybraezn5iA^22{&-dapUHF(e zpdTCd=>HXdfZ%uU()@ezjfI;3KmHMTRew1O|6Nz%U*qdAX%@}D3qNcG_%{^)XA1x8 z1z)7`elNb*h2OsdGwPxJ4^Hx_9AZ#;Xt6n?GXmuP(5OJ4q6`09-)-}ZmW!heO} zi!|Qv#TUEqevPkIc%R@?H9p^q&vfB`G7IG^`zcfSZi@f6HUD0G<29Q9bsWF2+dqZ> zAd&K0qVaVrz5KiI^EJN75dN15zDVQ!UVO0&AKVa;U$w&DA^22{&-dapUHCPB1K#fc zDEt7y@7}KY_u?CeYW`>K0^Zhth5xRz@UQW8|Mc?j!sqGon@$)0*9*Q#yx)s2cHztD zKkfEU;a}@W`K4-nz89bA!e6cNWeUGg@VmEa{=N9d!J7Yjcc6S*{}q0m;FoB8-3wm+ z-S{cM+y1|^@SiUDB8~TZ@x?B@@ig#u{HyT$6NG<_&-dapUHEr7{%za8!mkkg?l(36 zUVLMo=KucpH2(@eQ}9bPzV07h{$2Q2j{$G%e<$I8h~SGf-tWa1yYN*SU#;+oihqsI z_u?~M_^}#artoifp!{~fq51dX8*?@P?Wci$rGGgJzgX}~G`{Y6FaIulU^4J_{dW}p zZxeix#{0eaVi*2C#(#GEukif@pQ`csUVNqt|35one=7biQ~0k>6aHV<{Cn|@S8M*y z(Bd-26Cd_^zNul#Sd!utfDs`2?= ze5MQk^k*pF9{*DKZi@fcH2+?F<5ik}-<>GGi}YV|6#j#F%5RCr*FERu--REb%Wvu+ z{4W!Hk;ePI_+l6SsUx6Y*-y2?-y!%^jnDVuGhO(}8egXH0|dW&i{{^pZycogFZ!M4 zU*W%t6aF>6?r&cHUHGd$jmW?0G~s`};EOcg@5L9p@Ch1Ut?&y3pQ`csUVNqtKbrBM zJ^rKcqXfTuv*zE6Zyc!kPu2Jwh3}>K*Z8_;z5KiIMI8TD{(kJ2-x7_x}~XMDV*eY5u+V#vIN6z;A%J$A1-mpx~Ei zeBCo%{$2Q8)xg{KA1D0BDgHIy@5L9p@LfLv-j4qi{sri3{>r3qTU*X3Ieu>7{J?-V+h5vX4@Jj!h+6({bf-ll|zZYNZ z!uRI*t*XCjh2I}5{A+x^7oX|Ef57n{+y5#23c>H*sQLHe8?!b4%l-_!(%&3~pDFky z8ejKUFaIw5Z#BNDo$xqVaXhz5KiId-26C{4e6P{VRMw z!KZ3`z89bA!gtW+mnr<$&5w}(S2h1$eB)0v|4+XT{_Xfz;nxa&iN@FckC%TJ{%`Fg z^f$!_{}qBS(s;iYU+lt<;`oEIziNf|2|iWh^S$^?7yk4=Me46i;kzmR*K7X0_{J+V z|L4C1yz*Z;3je`z%5RCr*FELs--UmCUWERpW}Xk7vP|$r8t?bwi(U9A3K}UhqX4@Au-1UHI|$M&wtm@CyW=s`2?=e5MQkBaJUp_)&u2y-xG*#WxPn{O_-f zl%J#Uy%hf%U$@N5zYG6@#y5R0{O|jY@+;DKzZYNZ!q2-M<=g#Vg@0D?sT!Z}#b>(k zDT{%(`+o{wBKY04ntw08@iNVS4(DHN{a5&bf?uNXbx(Ntci|Uv{N0X!z7ziA6#p9U z_u`9P_~36e{|f(F6Xlnx@%dhSrVHs3?i$U%7vGqv`G4(J;8p)EN8!f_ zeu>7{{l&|_3*T9n-_#`hrwhJFV`V*d#;2B4;gtHsPKRsDag~WG zgNq=0;C>Tqk3$Xu1;)(YK1;T&Vv}9s`*K9E?2q3CF=5B*X4%inEkH=Q%~)*b1u7D( z(Ur%WxjDDtr!6<|kp8K+*t91L?bEXSN7LqX4Vg!<|I+_$+|(3&FG&ucHK-Dtm2?=i z6d$FXWpg4ZcJJH_COv!fkys(l`WS?%pM{9+6^aPY{lZc*65yPRrmnL)Oqko;95by$ z|4j`+6oTV8a9>dN_Stutp#f*}Ad78Z;ojP*zbWwVIsVg7T<$f-ONlteH~Y=vv+y`7 zrrm_R>|;~9${SoBc4KT+xCYyL!_|Y0mwYjC6a3%CmUfV%A;Ud}^nDZjO~BcuDS@N7 zs_@9c2{`L;VQrwETT!v+>CffIa4L2+^qkwZvbW4GG(+7w;{QnFr2)wkvX2yJ4KZFC zlFUMn7Vkm{$x$Vo+4snVD(2s_)%;lo_Mhgk6lXVL%g-qJ%%Nb)9l^-{VoGN`rDKbx z2zTU6y(XAgeob&xdBQcpA?0xtPx6rLjZ@Fy6HW=fF*aOJsqlWsJpZwXNV-8JLvby0 zH`1GTq%m3?56(H(Z2b*(VoM_zk|+ocsDd2&<8sxiI7;D@psy-{Qtl{H#{T*)eUCr{ zJ(%T@gHbtB0N@|lo`8SR&pU1X#NJ$N>;;7vV}}?R?MfXOiaN;nZb)|BG@MYz`wtHU zJ~DCO$Y0bsd}%lcAUGU%n!i z#D0hThh%S=mW8C#ZWZGD9z=>On8NJaXa?Rek9=s>9>2Pv_rYPIxCF)6CLG_S2tF}m zwGjb0j9Fj(>3Fl%fIn3c9<3|qx*6=}VNmHGosj=%`zg3m{#gIR;Z8X5hbK&;{>DO;5MukqynN@#eRC;!`2{=ZWBPmuh@Lt2<8cNef_j$Oc$Qb4Quw?coM z%0FJ^f11jlEu?jGbpF4M&YzSIqFAS0WZqhjZRT@k;|R~B-8WGjDR1y2umx3$V_Z|J z?nGnsQrvY#b+Cc#gR?Kh(XOYP+x~54HyH?sp}?WIH83|QZOv?)Q8XeT=+d zr@*?t_5S+U*xIUaTx@M%UH0bEbCAT*utX&3i_4Ra$8LjiZKKEMf9Tcgi(w%3{8NWN z&@g4+FGA9e4p<#=NVpaEs=B|<+Vuv$t-KS6{>|UJce*~f)ZSx)oe=N#!A^+&jf`ZH z9z4iM?4gx*B$aHfevFZjeL^b48owN=ot+R9Z?q#JtMQ-&LSqF!%7JHCGX#!fSe=cg zzj47Yiojn~@N|KvXn2knexVEg)z6&LOBDRe10??4f0B3{SCE1AIgfhcxG#RJssHK` zTL#tuh5x7EA93NUz4)hH_(_rSzdj(`&l3EN#Jj_|&z@6Z+;dK5t%h+mNM!}TkE*3r zoT*`?47q2ZWGg5ICH0bmzFZNhr86XJS1q-3(Ybp9a$$eh@+mq${WsClf4a!l{p3cYOI*5DkDkF$FB6HH@v zt!b<|cr~8x+*Ae0q%>f&9@1={mVm!CrR~bv<5&v*ut)u{ZE6a>CH?-jLotoUm|AmV z&1;Y;D?;TaH@pv+ySEt~ViQq-87gnb5I}AQf)^?`dv7z>pm6-#bG6xV8;h>3szUo# z_nM17p0pB8-!{^hTA;|-9-%Lm)TItquXhS{Df{sa)U7i&*4or=D&2d*tcBEGJvYyE%}(Z6C_ zzi}K*KeVPODQO|fl!`rLMi;ZW-nglz(KIe(uL>tCL8$zOqPpO+ZDkaPV833Yh`$%P zfF2kG@|2{banuX5P-cSoqk5WSC=HXqmDfsC`|}cfi%nyeanoBMY+Gq(iT{n@A&m1N z_tdV6;vH1Q&+!h4-k(s#Z(Gzi91{Kvo{Zl=slIPw{TP*x%DV^fS7g2tEsSm&~9L4?;8UzXZ`$Z4&)`y^H8O zLG;g`TpY_QyA;ice{d(ZP4xrN^H!+-;q;yc0V$ddF^%8eMPQrJEDwRfcV5Sr8QH!j^i{|lz;^$R!+#qkPkPkW%ES|&lp$;i-1-l|v= z517&qB_sDy>3vjrRv9`?NPxrasPCKPu@4TjJ_M5S<$@a&se3?rHic0Wu}W6`2gai{ ztaanj+N|2rj*+?+9Y_GwF`7C@EF-rHGo=H>UT?;(!$%Do z844)n>GeYL)~WwOEy`OnG`2bXJd!Cr8<$RRxILT{^>u0&f|mdcd2BO}>9ZeVLXJ&g8R4LnCv)vsVCe&)6f&D?REOD@9YO8I89#j95b-f?7hx$fCuK7 z*;|eK`YEHjlS-R(nXq$dtugNsWq(PrLgN_J+r{rU8W(OUAN0V|#j&wQ#Z@Xn%5arn z8#Eb`NlwX#`aUMUk9(z5DNw1OT z(a3*{e1G2aeW~YrRn+&<@ze2rZkAX7d}GH811R^H@!A<@7%iM5@ERVF*nvhbTQ$-P+DE<4#lkh_~6ST zx^LD+zKn@KfG^~$2k2V=@wb0X>fk&aUS_}f)OmQ@d8l(9{^C6R84slX)uz!&OI*(n zxSlIr&v)Y)1pPIBA|4vT2xwgTSSPl;G~dkLJmn&BjC3y& z1fhP`)y9(bBegW0QQ&+uDon|iW4W$S%bP#OhI?;!Jah)K-!f&OWY0fuNf{H2pKZkh z!>e_*?IsvEZbn(Dmq}SatHbvbm3K1!S}FhhHp+)%WKpfM6)DDRpS^b&6}Le-5XDoI zpkT)RL-^g%IhgDY9I_JU2`=WaJ4G zW|FQ*0tu~)r*u^MQD~pX$&c~!<7j*zvmNgw&yMQdx(P;~oovhTiH2*;K78)S=aBm6@=r=JUOLNrC0mFkRJN9T@q~${z2y=c9YY^ z;@@3_k$~Rw*d=d|j{kc@U&UNQd=1|E2YriBM5S8AR85%hQK=^1RmW6+kyP6wsUByl zcOt1eUn6-{;H`}B@A@tJ-&0$O>=li?fA@KHIpH6jL8iI;>!~`p)@p}*E>7RWPYzmh zB)fT?FPNKv6ZLt2A0~UIOyErxxbgxq_jdbiwabTG`>M2mR?`3u@7fo*2CnOa``?6g z+*(u2^YwESsZ6O+Rn5TTiVHsp}Dj7|9v9 z4KWj+lald(`35|t@d20$@)_5GC_a3l3VAuyE*775v3yd+@<|oTCsizOsNI9i3WEtl zjg`46zTn7=pN6`%!(E8Y1xI$^#>}d!DqmnQ<`!`O@KB>m7XD99=ASgS62n2LTp)sb zJ4WKx7r8FyI*fzi-hpNeaJDnE-=A_V59`Zy>S1w*k7KN9mqpb9uIpI%7hB0XS!*yc z7CCbdHyEQB-XM@`29RqgajZHPFcHrMTfqu>>Q9!E@h};*DTXJf`C_lb;expFB{T-@ z+WS*|02c^2*cHPDop3+=R@@0o)sm?W=Mj2^$;cbf=}ttNf@Xv=xLF?O2xef~z)57S zfU&4a1F=Ob?l<8Vca`f@5adtK2=4ejG8wA-dk`i6-M3^d8o){UXxBKz@Q5piavbNzmyU>a;3X z9SWMQyOk@QciK zQIq5Fib~2NKuJb{zorA`DvzF2siUD*qUQ;9L zH8suj56-~ZLB-Io+0d`!Q-1{1R6&b=Wm3OzN1T6uIn~R4s;aYQVD{OqIh!X$Y0j>; zG{^Ce?)zKccE&;G?&n>7sI=~!VJq+-JV-PU^I(UVYpApvum#N)=hqz+iHna`y9tnSs4_Cr|On3$oUWkW; z300ExQE-B!rfAmLNomL+|_$;U5LY{EL6sKeDPp zZv-4k1L|XxelKeEcgX|fK>wqER~N^cK~PEeh?%8pqGhXc9U6tgiOb{7<_$DXb+x8l zd05Rbkqto)GLGrgpP0e2Tgo3$AVg&TpMZc`AJ z#VK7ameC2Aa~)eyyEhJVmz{7$uGj&bzH+m8u-z=5(ER377b5lVKi19&vEM+enuH{t zHe(Vv<+SfMb@9~3iu7{4P^NC;3ZDh`CAOHk<}u&Rb-rLStljYQ7G}zDIPRTsS^cnB zG$=p1SQ))i_3L>5(_(2*e8G0sZ)Ur^AMRDu!W=F%7Vv&4C290Ozk~9KqBJzP)yNF| zM`D3iLL9FO%N6NM@#&R_dTR^i0rI~bsZ7Y_d3?(Ippr{HzN10#%H@}~TyQCoTP~Ny zKrW|a_?G@x%jKd)5xI<*)s|dFGoVI2IAi=l`u>)E!T_sQLa{@`S>+; z_?8kdAr%$+EtGf#QV>l!N_3P&szg;LLL|}BxS%<5fBA)8k@R?6+6Sl#+lQQ)ZAry+ z2z5*4`-oJ&z|;Iu>DO9k{YmcBtiqnnYOWc#=Ku9rv$1kW`nAk|(GyrUa>bwVXM{?3 z`;`cgL#gf8V(f;$V?NH+Ja9C%hxOEW63sa!Mi;WQsi6@AT{^CJp49mG2XGMf`1o|w z-<)8~0*P#khYo6e5eS;3-XnKW0KfbFD9kzCk(C$M~{08UE{RlYtWL@CCLw0YuFAxcYNf zAEh5k3Unn$A9d?TPfUa%eo(O#ya{d*Ggd00n7G4wDa(L2kzkE%C^`!Q?-!t}jUOam z_;7|q4YiK;C`lsLAD1QC5WnV7j8)Zyso79`fqM1UYIK2d{s>-r^+T@I$(>(<8%(XT zTUw}!+@xcy#Lw_=rx0JnKs+i$9hhM2(cJyhsV&fsTnL}hsL4-sM&{!^BJXVczndZW z-Ry4M&8YnDT>cr(KjZml68@|%2iyE4`}|yLe=f%-czt=%dok8y+t9T^Q8fPv2n4TD zCGoa(Kw2va>jD);n7`On8VBt}#9VLP|23Kn%ueK2?BZglg_7ftV7t5{HCH2Vqw+<} zbR&>xz=!MSs>tvA5%u8r)A9Q%h(Z`98MwKYbx8twb2DXPteo8q_M3ZnV{A!>Y7@VN zp)}HlqSbk(hVma`>L@AQKoXM_>WW z3YAl6z?q19RhOrcZ%w4AsxsT-)`ta(zU+gBe=D3al|2`~`a;(<`+|vY`f!ISE_YlZ z7nO&*`a*fJzU&Rgy?>IlC2zuYt(AM#5w95YD)82q{f2SRR6c+=GK|Zl3i^IKEHrSW zS^IfhLG8C!`+C3Wi{0q!`)s9_^X7isJO}Jgz#72PjzjzJ>wg&Y zTh|ORR^HMr?{J-`ngO{bV`%J7tOt6_jQy}Md%H0&0Yn$}-B}oTyWq&qg4$2o7t|iR zy0G_7Uo2J$$sL^ZSAp9&!muK}2DJiJ7)(`oo;AcSw5?rwFP|-3=0iFZ~QY<^HEgu1~c}!ukR-KryNNcUC|`l`uHHcK~=+ts9#@SJ1`F6 zvQeamSIEKtGWwsgH2$IgDa+*_`k%7#{6qg!U5>2yS!I7NwLg{rak5M9k2IHId}cDU zoPs~elbP=n{7Igi!6*Dlp3GsCDTujo%RR_IV@DhtJ;6zsEV#+gF@>89MN_!RnAF2{ z_K+L3E{*aFUDv_%?>)+Jrw_m5eFi?UpfmlN3HXv_e;L9rS2D%i_4LbFOy=K^VKzg4 znC~&}Tf;fX5H4&3jaPu8pWt&UIhjUIrjnCs=)fXD`_flwEb}3Sg1}L;w)twa_TPhG zb9iiz$f4boz6H1pz4r6=1$~dQ{tGK>W_B5DtelxRWQg(1#=-OP5T0vYFbW~gxv(&6 z(Nrw`dW3%-;GYHjGmn4n!5`DV5oErB%a3Q@!PuJw{sfjsVNRnlaug?d8ZB~?L*N#= z2NFoVfwC0TT7wE>>+#qg{oHm_G7AIi3TpSXFYH?j`!B5AG_&V5h_>^|aj@X3acIfL8;FjY0`#G-}Q5XK*P{} zZ7WTyh{5Xkj#J=$*w7udI`l=JvWx`dKP7k$#do_@;;7f3M;v7~wh=N}*9$RGakT_X zB4sC}j{5w8^u>X`ChOOXDQ)`7rU-o{mk50qlfLB#+oJEeQAive_n(A5Uuao6P9n79 zx3jxP;}zY5F0;2%x@@z`l-K$Wb**J6O+%+gDp@1}n`23s?o0^KxHK8$a& z7zp`~bvG(cmypO7y8l?WX+2TSS5m-f6n;1l>AID4Z`g^GV_42K_4-1>OV4x);p|1O z@$iQ5Q1M^>V`m$c%Yk4PQ$VQ_IyUI6+1p`4)fC*Urrwyr%fg)_UjiS(sWTgNFpY{| zux&!6vJ$aP#s3*Zp+Zb7Cpq42+Bv?^^IS4Y_#u(&JZD;>HP9z z{L;O&D^-CaDDY=P0Ull#{t4cL()CEL6rw*rI!sA&QWgfgggZyR1U6$`G=W1a-ZCl< zA*V2=j8vWoV!~+aVy9hT`m@k6E)o(@6Gp{IJd*J#@n$e5oB*Z3^<>Zt{{|pXlc=f{ z$_o5fiT^h$69qk+=vbRLz)4Lq0$hqrAsFojniv~qAM*u1Dl`Uvz+2k)Kx95+@aMk3 zG6~mM4aJ?!(4dijKMemF?rFUrjD=;`DT6AN8Q4e*p?y=|RPO>q`rwlpEyX8|eYt$X zxcC{0zyHmxqTIAG1~E)-J^rV|&E;9>9Nov9V4Cz+dF~_nd32JOfchY)NknvUElqk2gl;x@3@S{Ht>~(@^$*EUxr4(|DzG zxHl5S<9_d3JBQE2;=u~=hNS*urx}$Yf`Xk%kmGKv)cQgY*M3?r{6#4R(5ZoZVN{+E zK!NeEE>+=+@B$?i7_W2*pNr@C(!_#WyM)mwNq&vxJ6Tath0h7;W5#uya{Pq@KA;FJ5IY0 ze~~}wzZQ?kKhId%C7c8Q#@~&~kKs!5jF-BE``~-0(oT6unJV(bcN9Zp5*|^^OGw(1 z6_Airdd49mx&0yI=9+MKw|q}GDhmL@bbEUWm?R~Yc0QD6BzHvOO<@BskY-;J((ok~ zJJmx>#-iHZ_3r96O1r57l842y6oRY5n5#IJY*gM(G)ln#VF^-9r2dT3vsqXd{ux8$ zTll{#e73_M&|#ca!m_*Y&ls+gUguDN=PkyfZ)$_RaIGOk5lNai#dsd(;Q+L6xJc(^uv z0lvcbo`*!@p3ai;PAdrZuL`&KVV73rVI-^ARMJ@{9hA978!sn8u=}mzD^TkTY;ZJv zIli(&gudyZ4_+DcebzCY6Gh+eV80H1`0*T}uM_D*8?@0O@LI9*&pH;LjV$1V3xe6C z?@hC^naOf1noCNo-=oJ#$LWq;*aIUejsu`eqKjek&Nj{ZnSkJPKg7@_J;G7>)p2M} z3#oFkevSJ>A~gkWE6|1Qccry4~x-?xC{rdYe3W(&uk&}dh_C2Kyz-KAo{cmGJe2m}h0wasn%Q#fYUO{GTFu#wxz`dNr! z+DPRrC8<(5=M;qO%0Wm0`DgQO2{bsS;TH)}HA5HFy|lBcnS~px!nA!5dnJ+)ih`TN zXG--zf3ih?RQ)X6n49&UQOQ+%)`T$(CkNjLMB*$lGQ(5uBAdU+IO6fY=Q|3q43;B9OvF%D-oCE%{ZIi7AaV5RQ&EhX|&# z?>(K}?&;|1cA1{bKg0QFJpW*%+6kc-$nY7zD|K|{s_YRO4h$gMh71l!;z2itE<48+fgjsAgv{|aWRrI5#rl8Owp#` zS=>d$Y;ui-8&sf7wLETAZh-X7;FJVWZ)on_31JN4m2lP}5;I^*!+Q2c%GU8F_5d5a z2|F^pSr_XX7AQqV1P7?dGW&>8c{37N&sCm6^#z#7u0HHP-D*@YW^oFoM=0)sV6W?w zhw*Z;ln};{Z?vzn{BxO$iQdzWW(;i1Uq$VbXEe|y9WWB|f&}#riSbXD{y`?(7uvia z6dsv?_|ysC90DwyJ&c@onzTH7+%7x*4x%xtj1e#p>kHzJra1}WY*{tn42F8Gjq!(- z!`#qUGZ{zM2$3IgkR5^Kk_$-TGH4okOshLfYyz<{|Ps1B|qyd0iPm6)-Vjklb?bU z@)L?b-~S%_|5n*bOpa~LO+eQYeYT|htM`KwsH-jN0C)Uj3Mqd3>04r~>p$WQqH2q* z+Ch*XimIRjMcxK;C<>?jv8@~0Cl1PiUX#s4HcM?)r*SUEH>^dMAt}^yISawUoE(nc zT@eAd87l?0DSXbCN*+T`B9Alf!A#+u|BMpG6*#7@RbgyMf-v$vln2xzQO3j`(lUPHC(;29Nd^7u~ao-{WBPgf6vE$KcgZ?x1mZGi{@Tscz9br|S zm!7CPot_EQc3?R~_2`RA#=J2BI)2%&+o+v?cZR5L|3GBi9zfd1*l6sL2@&j4<`$`+ z7m2+DSXbe%%t7I2+Zosf_DxPCgXnrHW(HqkIvrHsOW@uYqBLWz21b{hP2dUzEF^Hb z4dew|V7J``ZIl>8V3`7TBk-cNy#+{|5|qSF2Yg>Qy0MEmyDdPyp^< zw)3~ef9sWz{2wE+k@`E-5&7S#kR8a=FQb7MYG5>BYY4m?z$&)C7}Dd48m_XDRTPZj z`fwdd2G@{eS^WmJJ_66!t&b0FWCmB$W;Ik;Y6gSj?-L{A@4rFFBy$;a_a`%YLX#sC zeekbpf)DY&yvNiyKB2#ym95~UASd!F3>zeF0H7+0z;O$3uICsli@Wn2pt*09<0s4k zUDvHD?{F=a%M3jbKCS=Z{%`f)rP^+c{xJzjo{omUol}`9(lX{6?#>=L%P2lp+7xiQz{%d1{XSNP%60(G3S@^5qs1*%V-u_vOrM6Z z5FQObdSkBs8sAdsR$~>2=O=dCGE9F>Zu6$nPx$wJr@9bY%QD^IpD_hs! zh8tR6XH5Ma4qvU-|0G}l#n#_Gq!)B&$>(BO`@y)uTmE5NSB89 z{y}StIZ=qwe_7Qc*iigqNNc^w78nf_)0v@#k}u|dv1LMLgNret*<}*q8m@OtW(?7R zN>Me%kY%BmcF8PdBPQDmKZjuL_>Q5}qX`u4LX|a_jR)S~U<+=D#QZo0QjB@kOc9Fz zX*P#`56FH6Y*yf!=Y{DtsBF9X}j(B3=z&Su~z|Afo|gU-K~y z(K{v2<6^M=0Yn=A5-L}@sr(74#OX}buj(n9RJB!vwIMyiQ2bRSHCvI|$XOv3IhLz( zL29BVl@O5H*(Q}=U8J&no77D++9LIpmZUCtLt&`WOE%KB)(vw8g@p?txdz0PdO(c0oSs$VJ zB9b>+kvBOxLLQQkyh}8BOb_W@Y?H^YF7jBYUAxcR-A3&y@)$2f$ou<3kzSUIJh(o| z%Li8Rg`Pv{4^Efgsg_IHU zk`;M>nB%T)`=^RLesz(zoVh78 z{&IS>^w_@^J2qZwN#CT0M10?3|Ce?)dn7Y#@&|oalfD_tMSO=a_-@mOrjzsy*Yptt z`hIHD$FHr^7ix<>RlDRw#D|?wN!uPg98(2nI3|j|9Z15a+XQ`o>IwRG{*TZ%1x<%d zAL0el_xv3Z`4I&A{(ilZAHTLv-^FdwXFKaEhd?^(3=jzVR^REC-&UKxT+r8iHt4%j z(RU~zLSL?;FIm$^5a=^(`uNpF9}BhX_w{LQ)UQq7QY4M&U)2Lb-&s-g)k|g!XF~Bm zCw-4UrR0ZwRJQ!G6n&F^8<8JDpzp3iB|m<3(YI8xlxF02E$Iuz_xNUejCGkRhKFLH z82_NI%pK>W$l^XW%H-e9pI=q}3A#NB#c%x@`GlVoa+f*zY`#50rJc(rpQ5tWT-fa1 zoM6SD7aQZ>doJ7OZ@Uvgz=Q~!x2?vU5K3Tg-4}}g{HiZw@>ZXVR~R`9rB>rqU@MsY zU9!zG9 zvVO`rUp0++W^mk?orxX{Z^S!Zmu!9Qi;W56V9My%Tt9{%IC0mFzX6-s{4Rp|cd@)G zjmseAF9TugtxIhB!a=8Sd~*NgRu$a74>{Pu?Q)TlGqj66qrnk~8n<%^Pq4okEWlY_ z$5Kizp`Yu+9uNp0#}4BTt6wJMi!gQ-b3hQ^htdEiOcMfuh+?nA{~4SCnvupod^IDN ze>ej)V?6($eICcb{M3wJoP4s@u@TEIGq(vEavnB~CqK6l4ReEBP? z1XdGcP)fE&mrxMk6x%^jCz6*`4Bv}Dvfr3J+gLdeyDx$FH_w@a0}IE*hEvEX1i2OC z&*kpqEwXoL1ih(q*@vX$%Dw8=$ij@f#QA1P;kQ zl5g{xx3U{>7g&Zu;3O9NuZW~twnR}R2hmM;X@+`K@_9ka2gD3vU$YhYbjL!D;IM=+ zdMNFzx`E16AOVOJ!wHyB?MepHWc*I@;2=Zx=2;^sFLG`@w@fjK{K@2t32ig!$8Rl| zEd3)`>mv;EuQ0gtB3thpGVD5cGpYFdO!EhYLtoReL8z~`!AZTq5;%YexDV#QZSZs@ znBT!n&x{0X!XtrAdz^`y*~qXR|3)P%8!YzPHY z!#amd>M0YvfqpM~LWu+bJ=d^rAGlz*>VN2p6pTY19qU8bU&IWHrO=9m6B&h5Fvu8ABhf8dA0++OIu$qDS zx%w%E%plA92TtVWOF-dZIAv82{&UKe&~rI>j?V5(mWd%0Yp_i7jUp||>i-NrM+=|) zOFlXNxr=LIA>D+A{;gEMZU6r({B8SlYy6F!(*}RPtWZCkguf=)pY@;ehX&&$^_QjV zuQSBh&sBR_kT0t5dWgE8b;HjQ2SnGNjDM8P_VR}^S%3HVPl>;t|9ku;8rWEHiJL*3 z&rSWD01hv)4i>fGkoGyN4gUUe&nfYj^W#&{&wsXMe?O@H61nN}(rEs&>Zkl{KHf&E z&RB_I%gf_CA3?y`3)^z)t<^JK9HL2^$uI*oXt#edPwq0q$6J`8b<>X=9xwLV;Qyk3 z8S%%~>~B|@i#xY}`Pg3mo45U-_3=w*Q>Gq&5DUX0*XyyHn$DQTl(w-w)Ey z*8R&YaY6z|26*F@GrA$|MI|?796tuyW3lTHh+U{ z$9fX}cAa+${QckbFSAu|I;qm{4e{t;Z;2&DE zzcQKg;c6I9{Bn=&RwInH9>4UA@OA?KvP-uQ;~Du(a^ly~(uqNYiY~Dc8F=Ylj)4~h zA45)f*?$+CeRf6>yKyL{#6mCKco-TQN}4Ze&`bYn3?krC zEL9qnJ}I1J9mrud;2HOJ;^3SFhIxqnW$8?Yl_>*s4DXO{F7q{+7!*b#Y%?@7Jy#9@ z!5p4dy9uQD*N=CC)-JMBjFCku1MG1zaNsr2~ZRtB5^f}JbEtXkET3?x*_ZSK{t&?wUnGC0~l(c^a`dJ zv55YK!a+wIeeDy>Ey>0hJ+<^67T?)ZONss1{l=aUj!2>UAX;ZaiE~LQ(|(4(T}png z*Y6)sF)Dw@)S>vl?}ZX=eo&OCy)$6+*PCo5Vn090dM2AnglA`f&A&dEK|Q9aD!4EV zPu)ukkl8Ph8T@0J%5Ic1kae?U2f;GC({cW6tNFRszhnDDc!fbYm39tFv0=I22z_@FE5N+8OSf zAz;m4S?lOX)u`dH5n}tpV7xtNwmBRY{({3{KZY!1IP6*64FLK62;*UoJPg++<6*BI zULRw1SVK>Dv-GdVj<&tWj_`8oA6$yFfI!;kre3yhcB%T0^;|2*pH`{yr>;;Ed;F<} z^?`W^8LVbkv+eOG*h2}u%sBe09oDlL&Exo!LUL{$PDm_N)ZWDC(y5L=!M+gX(#VFZ z@h3cQwSw3}h|{8P;rNru_F3lSXjLEq#Gq3vKUssZT89HuiV`fz-pJ7yu|Mc$22Q{r zX}JY~M(hyCYkmto^~W(>Mb@G3_5XEz$jT<^M7r(fRj}CqViCh-HeW zZ)5zbX(a2<8NZrjOA~(C8NWha;-x8N5N?_{rr^G6P{}c@Dm{MHoxDQ;TRDF9>2TE+ z<_0!m@6`ax2GXmyUVo5^1P6vQo!@~f;mESfsvwgA))^z{ozQrwagJ5rtjFdJc;Cy! z``&}{BNUVxMF0|y=HV(C0Q ztlglvnw2$YIikgl)h!0Vlzfk)9NYgwD`fmbjnNL*?#~voGse>cE`j3@)qNpf@CBDG z4dFzJDGTQsU@(^o!$S=uL%db#vbPwac_`3Us2$d04=ACTb|)>?432?G6eJrfQ>wu6 z{88yYsbaq@*ZSL;st1X?4$Ukbwf30CZef+9^s9adpg3sGWZ8{&jM z4*gp65uyxW!8fES{%dT?50hy45EZW#iQdwhMBzWWJ0kr@E9z&r|35Ik`^i*ye79OG z{3P*Rw~x@)TpE;yDiYtFKHP4oRD72#hbp!e-=P$!><@_V_Pzpu%MkmY=}4kQeD^9U zFe?7h?Ke)%x_2q-7aN6)dmrEv#-@G2PBL zC}|}s-4{TqFk&A6%n~8YE;{?XbXGQvGenz${R3VJ_A3ejUyiHy&uzwB=XJw(8B#M!~-C%~2 z5;sHLk!?K%8CsBDg@kA`TRUWkb2dNZIHUf%tkak2T+P78b_|L`LU1Y;a^oo>$vhDj zr(*FbgHQOAT+Fg2<4XG3!EildVZQAbs!A#ImP2nasi!!KglGh%M?;Yg1St>pJWo$WeTaXsp;}!xs;at z51XnNZL0pURNi-aQGF&0H2}Y;sEQx`&z&*WL-W`^+7%Ok`^RD?)Qx}8Z+vv4305)Y z_nep+VaG()aA0_{@e-Cq<9R}0IL_7>$izGr5(z{j)=GR5?k6V)2PgHhf-+60UKa#% z3Ig2wp;F@+(;8EHn1ShO$hr?A!qu`Y6$cE=T~CEX;1Y`e>wff#La7hlDd%(T`g_Zj zrPgO%TPl559Td9yKh*z(i2mP%E&jItPa^ry+j9AYqRQvm^vCeY1(=5aOeE&k8Lp<_ zX7A@kB3SY*pE%kkDu>3opY6d9F!j9d1s$d_<59;PLEULQIAuqj`NLy&)LB71 zW=Ea*Gc|)xxkxq@f0Xe|9nPome1|{Ec&56IXJt965x+Rbv(jTcD|sH9!KW2%!@$({V7iYHjuRt+m!_Z)$51#IFsPLO`or z6j7?8Rz2f*K~%2QJnzri=S(gHwU_7h{Qh`&Y37`L_GRt0*IIk+wbx!dwwmqfdz|~$ z>=j}Wapa(jN2H*fUXOhEHvTCiG{@)Wq>M>FyXNC8Z`kklX3Uivq3?QZ5Sk6c>(rDDj)p1Roxq z&3d}~%~ATQyRP2t%DNz25MBC4SDm;z`bDM2ca@6avPw5>DQ(zV%X!$7o`?B2G?A8m zlJKGS#7kEC4=5ecZ~Au-IQ{hqFy%v9?bc5$Sf)#8%%_Beh^S36!P&>w;F}Y~FWH5C z!_kW!c{95V3mgqN`hP`9-}vyKW)mC8#ZxHPA-Z#QNV??3y3rMhal^`IpH@%h(}p*2 z1ChdQ6pHv1_(b|=sG&EncK))f&aWrv*~~oeujsL6UrGr;)981y?xGP^LH)Vi_$eH3 zi4e6Gw{>rrxhQlV$P&9ix5>n84t(ilTQVqY1!7P%%%Cc%(-8v$hp1Xv?M`7)Y)>e= ztoSzEie`-;{aH@KPn^eU#*d;WT{_zR^U%Ue`$c!Gtfsc7_&@6}h5XTaF53NLvp=%` ze+WXrf zdnz~!aZ$baUn?y0ygOx-I28ica#nMxEnI_>Vh?RvljRjrquXDw{W&tiu<5^b(BE3Q z#EwXK2lV^`RMZHR@zdu}vO7B{H_ z9Nry0_G&nNzj)E=KhUo~&r7-*@(>HsMA1LT2PMrLHTcSWR=F6%X>C#2~!M;?;UsUI%<=wd`K=eK)L+=fdcC;?@i|{(c1+iS6 zK1$NDiSohH82I;y?rbHk^>y%BUKB~zB1n{dtFAV_Tz@EP%D?tq05&J4m%MHpL{83$ z2{XvxXgmj#?`1pS6Zpe>P(`2_95$>;bxc%`l&@w$V4-omHp`Q_N4;s>lJy-}WBdb-HHLY&F(V3b#p>E4f;pM{N;%vy z>}JOue2`yifxxI6ta-(9IR+8ygq;m={tGZjSL&60V~_2hxvXLl2)Er5$J>qiCLF+K znFS7I{Yk^xLh&K!a zXIupaE|KRH=e=Fh041G8l3R;;;{)(glfdd;Ea2t`(WMXLMD=gFR$TQ$VQkhAWOPrF zaN=SCO$?8;J}`G^&X8+UL|Cs@xp9rr9ZRc8=B~3RUeB9+w9oL(-X{;K268wtC21>s zRf|My?n(5kNPH^{hgJGlOCYCr<(FDqi;7U$(^|qtbysrt@*T_7MC}no^Tj_-qwXrU zI)m!St;0c8M4B1hFWTeWaMYc9lF&&Ge{ZBeg>aNyF}*&$Tx2WooN1%ldou}EV=E>a zx)*LSbbt75aQm(tmXf)@bV<)B=|z$px`hd-NbHGSQ2tGu_uGp+OuI-Cgq`8o7kw1A zr4Oc>FQP!-*1yF1S6VW zkX3uBOwn&}2OIk35N;`s60D3Ub1{OH)qX9Sn4TBtTW7Krs(^(T>Ap53{*Y+wh5|zV zH2Je|GWW?>tY>$8i*9Va*LwDlOBzAXMBgs)c9%Fv-EAhxbywfJ`u+PN|1{L1pnoPz zU_-Y4G(Ql!hpRl|yJPPh%GBG^w>B^3#LjN5U!qAZ`p-UH^U8U`MU^jbY!;9wBb}$e z-W`W%mKorj7soi~Ma~Bt@-`UU;O&^H2|}g80nBCvtqRyUs*`E^-ctcnn83vC1zzYr zjfhDAxjQCvFCWSDvv{hTe!_10`RQqzehS?L>*gM{!dDp=dOpY8Gw4V!pUXr~R z{He2BXDT;8jbdxjr~m1i-L)vt6y-?a$)bDh-9=>&&UY)0rIe2f|BRo4?MaPr-DGuB z&kGZr)VbMaN|8(f8#ThlL_hwTuiVwL`?JH(#s&nzdLJdC$ErC26;9c8bVp-Yg z4!Qvi`g$J9^Sydc4uAFLHvQVIh&}YnzR@o$1MO&3Tl;0Ht=L|vil7zLnFdEyEDiIb z4^@+1o9i8Uui6bx3A9JA`Z|$Fy6o2uzpyPJlYBs&#{88KJfSf($2NZ)e(P!di}5?o z{HHf~NBl8^)nKqRL4a0G5c?b(d5`-J|p2pY3mriANhVbAskUw>kocxJ68G7L<85vsbFK}Vq zK!!H2Muv{0M(OXT*_Ix&iNxr$V(m5}sKff!wn?O0M0C9b4xp@025>)zcs{RHy>GP+ z*^<}oihwjuqf;tX&OOK(J=^rV8+_R{MBxY7ujtD@Uq&Jpc$@BaT}BqWY2&EjbomE0 zts<9I%ePO?bh*&)azSgCUudSwRXAvQV{E^z-L&Cd{7=6RsqeQ+RtI83R-4NzGf=la zIQc96Kcjy@=?8=shPN-vsoihrYIb^i%b4LbhVo>2Hr5grf4H!mG>I+R>}*8`yk!NX zSsLFNduLX8d^M~7=!SO?y^(1D?a{+_koC~g?M?M{O{0^iA22$3(gEB`!0vKcR@U}q zU96S$=~D^m&k<%&mF$UMee!}L-M_&3irQ|8p2g5kKG@IqzV=6uaAXmYpkzqEzaTk= z3)xQ!RU~uD&q?N>?$z$sg@6b%ic1xfZx%~TS(P@tEpRIPH(6}@ZR~~B*R7zXgDG1A zG+op6Uh$4yE#BAo(`aPm%ctD|Zr9m_+lo4SQq=WA0{3wheW(A7KE?&~5iQA$J#=UG z)IrfiugN?_mu|_4Ci2-3zbqTFUF)c((OolhMf0aEi05`H&X z6(RCqvT9iRYy7QBAHm-m-T$p5tP%VrKsO(H^0$~^6ziS-w!Zez(BqT$n=og4odu{! z@2822J80;RB4xeAZD|Tx@lvN4a`dNd&j3dXV^P1W&$I!C|9Tve*fft8r%xcU4uy}$ zqWWEZ<+c|c)|f7+-*u3mqgVYd+hHe17i@2=zq`v2Wtj55j!9?nA?>mG?GN9}@}9`X zL8xw$%0&=xzLk91(bXb_U}=wj*x|*$)2Y9pFa@>kKK*1b}^~$ z&)l=a?>``w6@~eW3Yf|baN+vj)_+msr~db<8_8|10NQLF=(VQY`foQM|G}P*2Y$O| zy4M5ly_qhx?U49Cw(Ed4efmCIfs2oB-=~~y?*o6!o)+)n>w`YMwRQ#OXXJ}FphL&J zW7>Bpb!yO+y?Cc}e1Ft#e2tAh5A5f=bEb`qCi1w6va1aF+%75OCkp+m(G731bZd(4 zcuDv`7Os!>Z_)L@J6?=--xb}kCtC8VTZ_TU-j9gdxcG?nT|4_HbgjR-_WX50*Y>At z-l!i3!=<@2>|MCsA0?Z`QfFoQ4Z3c|%%| zw*~n1xd41rdw_3U4!{#X2jIaOfG>FtfN#ff%5jtf`2J7Z0eoQw;0~kU;BRxjsX+7v zIu9hecXI6KK)C-@#MW4ewd|=x7vFVY-Lc-U1eUWjYrPXD`JmcC(b&=yPubIY*j|gv zVElsB&6~u$t{ng!J^%Chc%bAk`!zK%yYzj4R}7YQef-8PQnWw+FxtsMe?H1~s1A66 z9jfvnJ2Eo}{!^d$9qoL5+*m)o-+^`0Cd8%}XV-P(=ftequ0xxa(@;Jml(l^+_tGqm z(w%hf;$iAlqGxvf4U~yYh}}S$llVC?yY4vd{o#U7GB0wO7b&yddmVcNag3q2=l+z- zCdRB|F~qX|>wxc$uMYp%SOWRnihl%jMEu#i_87zZ37*UtZLrQIlKTFoh~LT0X940* zKd&9)kKy8ZY?w$3qk96*z*%xKGp8kjU@A8%K&%KTR z8UD2fXgfcG)&6y(H2bs4$i3^&8#wlO`xo&WzD`XuN7nI^G$;F#Q}m$Nst zaZDb9{^T9ZIkv@vtyo6Q=zS$@{EOXtTG(H?22|S2c-zzP@iPkoKK5ScnhVpMQy1?W z$J&3XcmA>L9Jo%*es8BW*WhBrBu1e6xHZ4``=7YQT0I%qxd;n*7rnBfNNEed`}6uGu@ppGzhHpYi8MtKiRLF$g zvc*Xhe?SXud~UkK4Qc^{irHR=TDZ!xRXZtc-`{w`Lj z-~MDzuu8>?;Y~{Kr(BK(lDQvtNHOWRAOrPPK2^B!-_;6Vp@fCRZKwOQU)KN5C)XC6>WRzNVhrunLOA`^{#u@jVjrA6@R8ScV?AnmEmp9r_5=cf13bB2pK|B zH0jQGfYMHPK?Lm)!lL>01cfl57OSwX0LP%Fi?D~FNoUS~;6#A*U#WguIphIWb-%@u zjiKb*0wFOyqU$4L|1fw|gwaV1{HW2(VUNk=&uM)a74T`Tl{{VdE8D?!6(PU9yU+Vn z(H||$k@BP)TH6%LmatVXl3~L6mz9E6)ck9+zgt}dxM+hGud5OCcm7 zH#e%1u@h5e{;+-}`_dp^ei!=WD@US{LTQG6I@(0NBEQX!X3z8=T4_g5j{n{cNGB6t zhMkCNK|e0NpG9Zi3QvR@hys{JoRqE#ky7&V&AmbkPYOrsKQFBPfY;ExpNe9R#wqC4 z=#I_NrF+iQk}`X_42TWGRJ2J&o4Cv2<^iFF`OGj`^}7qFhU#~pTDyP!?!#+y>vzwp zdj*ONHRP$TWEHnnZVWBhqt0>zMC?RTae>XDXai~3BZ8!o${%PUd%YetGGxI*f5Ec|)cQX3>RusBdJ~y$zOE9;Y<{fdN}hRA$}5iM!hw~aE4b^9SEEZm=aS5gQSJ>bSrwY| z1cNOu!nq%TA(tUW(qac;N!aBrI@d`22vG(!q7Uq%RLeMBn3_r1jI-G=qy?#1$?ybn z_K%zXj9M{gb=_vOEI|?E@m8`a?JeaG@>`D!_2*H&i-PtdmK|?70_{jFjL(iygm2sD~C@sZmE3-K7CT7Tv2~N%Um?crddrPku`* z;D>)Q(qwDP(CsGdh25}r1CX-j{g<=Od%ahCd2c$5yr2>T*Mt@h*uFe3bcY|kKS;@z z0n*)QFR^d($FC*gW(HG`5O&m(vqs+s96&3$wcv28{SL(VM5jf$OciSYOVWvItuwQC zWzokOr!eJKzpxVjr*Y^t!AI@3YF^+r`FeUzM!Q*F6NaACr+YoCKWk|KC4Ozm94KgM zbjK#<@w~}{)zm&qJ89wlrhvi5|K)#e-)BbTWBgz0eWj;H@K5*NdDGDYQ1hB%2c~sH zq`mks|GO=2{nreL{`$cU-z}Lb1=kjvhaRL8`C1G1d1vaT0_))2Vv2h1Ul9FTBU|KBTP>H zBlXE53%yN$@~j#>;29h~$U)n`#V49TDg|#Py7G73# zvyOev5ZS15fv6UR7=wWHoxG>Q;+|ygpte=)#YId7^pHa3#E#h1D3B?UF(=Jbm_5&3j;zvQje2G;G?DID19dYb;e z=W_7_9^tpU(D=mH9#1uRY5FaCH^@JHm7C1`A$09EDI)?^L@PR>vuY}P=3vcF{>Nf# z)dBAv@2Vn+g1&F^oEG+vFyyn5eJH~p-^12m^5mSw+8~NxpO=4ekQbb}sVQ(h^5aD7 z%51iGfF&#fJE}!x{5(1U?H4O~X)@~&S0>#*cyduUk|*D`2>U^WHFtZ_z1F7-Hth_K z<)Az2E|o2$SC%ZDe6U_bDk3!{iY;cPe$11&QrMDoY_xaRe0gkV_N*ajw-*%6;#SnU zL6R|A5^?)>3IE>^eu@_t1SDN4=u|)2JK`sR@%IPgned<-j-j)A$<1kW#omuUYwZVJ z%JkSr0_tu{`O-IX$HXt|9Uc>}=#AIjZTT2rh(9Z-B+5z;IX5w|_qmCydgoQdU-I5$ z$13<#8UI>2XNk(=Bk>Qvvf$kKvAxH{%X)LDxlF7|d!(+BE_UlX=D_-F*N9vVCc|Biqoe z_kn*M#hux(Iy48n8iU*53rnZUdVl*weRQ+ke@jbYN_rc?TPugC-wjTo8X>(oR;y003`>ERfS$z3WI6bF3|>fMYr?uId`A?b0}0k!0A z-<=Oa#1xW&=O%KNvcS!16t~oqfHemno;+Q&sTFk5tg`N_M8DP&%wwX65jKEj;W>eN z@ik;tTp5ZTVZ-KX(u_CDR&9a2P3BM41flj>H?8x|%5pQFK}|e~IhUKVOjH6_zxS(% zEs5D>a9v9cSB4BU_ZY+`-*5WJanvH!{jZyVI@S9#!||_~g*w|5as)ejg&PC{A%_~i zD@B_o1o2lG@nqiu8|#1-f>STPrz3jSy;S7=*q1E-m*N5Lb13kRVZ*!)BZ>Fx)q%+` zv}Gs_ypmH(zWDs6>+&6$91hxZp2-~AHk_1QRGVzHE6rCRIRLR;UYu7}}Gyr?hVT+Rfu zK7C?9?S7i<#qLp7t%%u+gDHX|u^*v-MoY$E_IXzno~VgLOSXk#9~ik~<5X)ber3;h z>-xmNb&cK{c4$N$Hq#`=MqJehq}an&(DwvRjHMWtpaWfE;5G=Z*=tlu(A!9ww|vhh zyx3{jV7={1dJpMK0#lsmg9!^-TAiMzJvii#M3~p@bdyfGL%Bcta%BYwzo}p|K+rk* z@*AxuL0RdLTdrmH4Vw7ko#gk*vSEh2eW~-0Mw4jxofUP^`8yWZdV@D=j${3}S=Vy< zchP98;@#b@W5ps_j1PW)KYjtJLuL+O2e>P>_~gnCT*Xn0?_alGQp_tl?NhVQ6H4k3 z2evy)C}5){(Maf4;uh5|DunDR?`hhpA(= zgB|FtL=xCHj8=$@*wUU-qA89dx1*G33OCn%Q;N5Z9cAx*{@CQLYo4)Fiqj`6rS3Qa`xmE==DDxp{7)H{ z9t8jMYVNUoI)G>MkL9_G?BZ+j&$S+Snqx?7>No>x{QlMsf6p)~9q~8yrT}-*lI68m z%Hvqh7KbN)GY5VLMh@tV1q3jmIq2&A%@$P%P zs+gzZx^6?)r+Vd>=3rqI#D>w5s$r(Dq3uT)o$myUUB+FrPdvz^WNzrc{Xl7Z&>pD7xAAw2@iea)o(?Sx&>!J^JNmKD+Ui-XrQftutPWqk zFtb$^2M{6|c%Oo5AlYF0iS%n9E3uaTbyqVY;JYePcd@X9|HL*oU7(HG4z{`Fp=QLC z4*!t(C6Mlje4O{*i8dXWCs7SyF-?h!u<=_SAiv{p!1is%r!`6AUj~!8pm|itDIG;O zO5UaMPF%tZCRq$oyg--qjTH8YxtqYqwE%M|dZ5%Uv$~qs(s)wj<-tmn{n3wH|G_gt3q3Up`p~a^kN)ulJs5j>6N!+~=Lzf#d zuM%sLa?8arNNiYL`yI7l?NTyljkod(fbt#+Akz4?kzV|n*l&*5liv(7mYu+uO#bJF6&duik3LCc*3YTO?BOLA?o%t-Z|N?mP0giFR{@R z7zte+u+#V-=VY19zsYQp>CpN#YLL`WUFD3H)Dheh<2z=*-7-sX3GP=6?i%3k2+Ztv zlnam|#bw#6LXWpZvsadL-}5{XK*iC7T-_Dj@ml%PEnTBaTW}dz70v#<0+)i=&sF8) zH=XDzU^if6;{;53bZI??opLNRBRM`5$--olU7J_xoWl1jHLq}*8$)x?(Oh}ZfgoVw>9-#MfR!*jpZflrygs|I&eayqOIO)vzLRiIt-l#px!N!-(%LWd2051)r{4I zve3pSi^kcgH5AqGyRxk4C>c%A_0iDdOBu1`$rHEVon2}mZY>Kvx?d!8`^reecBX)2 zZY7_*yM8Cn%Ui4hvOi=~8G@PTNz8#+0^|4(s2`Dn&Bqlw{J zdgdx5Ne`CQxmmw@8zJ+NSFiw2IHT@(-+vU4C*JoheqzI~`wVieWyN*!UwQW$x!v85 zAR3M5{!uvts1hgtR<9)=g<`9%yUlD!AgWKk#d4iK6pkH=^FvE$4!6-!;?4x7 zyJX*+RXeW_y05Qpdf8sJ$XCIg{4%@KVBh-tT*0k+W%Z4-!1mlH>kVzH460&2# z=$L&%W2XhYv)Ci|O8JBQv%hz&+69SpQZtO=O<(5oN9u#Uj9q5mI@;IW5ZNR08kfK> zEn7oN3&j5|Pjg)PCn9jOIeE7%{j4Rurd0!MZ+||bdxpPcjdT2^5h+8XQ)e|o!|b=g zdE~(kRrda*-5d-8&K3ndX*7cT9L4N)Wt+9qxtNn$9PQ>a2xWQv`QakQ&zuzch3;VS zCmX3( z1D%M}wvb63*<`;cEJIto{68^QUw;*UuKBymwN_t&#c~6SRprXI$e4qvt2(;l%~1Wd+P>#Z6|3@j)p~}WRC`00*zoV|5|JL!&;@z%$P3~Y z!q@bA``62|yem$Z=TEQ?Ol92o_cuO_3WepFa3a4oVIC%j^;D>*LOrns*n2Vo`y3i& z&v$4H!vC#yE(q(>`!sRWiE8{P7O?PO)*&wwtQBawv&Z|fs_s2uFqaRn6q}i%s zc~Hq-cty$PQ0#wzTnDLZw7IR`R>bcwYT_3zsL%}rXO+kH;-&ZRaEZ3fbOe`M(afnW8~XX z0Jg6!iU!#Ju)Jl3vwxPy{+To5jns1}BP&Pb7shW4Pl%5$o=_IQ^hA>n!hg@w*-vNH zV~tcQ_`CpKyY@_`lH{OQCfaOx%3X4H2HKe9ml-rUjW-o z4_HMoMS!xQO^vC|%u$Vv(lh#osndpaYv|DvL$@z8{Te?An)~z&=J(?J5yQ#8adQxH zt~b2C%qLBmVG#fmah`s8M`B6KI6E5xm0u_;l-z~Nn;dkMgS!4F4(cjz;oAl^2eUFQWi~*r?~1 zsR2>bs1&63UHsZKBiSe5%ljb9V_Ura~RWmCy41{`bUtpBW7%>89#Y-mbdXe zToh10_5#qsHxL_0JNUK;HS|=on1k=J_YJ-$Agdb+1fPErkKwS){=j9><8Sxre1;~x z7bXEk6;R*}2Z2v`&l7?E<)<9$+)ZjAHK!VTNoKyE`U93+ys^kV%;mmKxu3C~xQR*p zhff;{(8l*U@jeOd3G}V`k+^11*MmN``FqcWjDIrsF_-#EU))_ik{Z1(Pe~=)C+>n3 zjA*-{L!1#sU?1i!UDS42BL;y>h!&w`KhrZNW5g{PQ`5J%x2d*jXMz8HDP->JcoQ`c z)7iL0Bt-bX4B&r$s)>d0RVK`?{;?AaW$M3o_Zub}n1lN^F7!pi8#a6gRwPCup~r;N zdBp$GT6leVa$I&fE*RKm*S7Hrnsz;y{n2c?6JJJn56%8n+<&kYp)WHv%c3-{q!lmk z^!~P9eI}ti{&l(ZXysTfArVDjzPyu8N4(Vg5F4EsCyJ{UUq*$TDzC9vLoulQO710R z^nalt0b%1QF)juc>=)yh-Rnupnozo9c~*U>p~O!wE^m3d zLY6o+g3j6%oplO}GlP@)PH;vI&dqLqTQXCAXszC+t|5SvTGAKnHmGoL~aeD7v{TSVw)N$W6(Uf42al z2Zu#~Wd{;bw4N23TyDRCV3P9@B3f{8`;8{^39X7>1B1QRyJ4e-BbWt)8k|Q_W9mg@ zdj-p+1HXC)+)V5**{N7#qL4q2P5X(-(*LIWkD#iO#DM};15sz~N%=6&yY4J(i>5zqn8L2Rk*^PP zoM1~Lk!)ZVTUk*Ms-jUT<{aaHTCf+Uzu7qRf{Ns5nD*%@BZcIxmZvS#oObLpC}|Tz%CL1a&_$h zH}H$q15Obns;p5i)yaWIV6HGisfkH_=5-ax^SVsnyNRRQZG9l%&?0 zqIXYGJs?N~WC>VWYR5qj{m_l?VS-nKiM%#R>2mvx0I+IF-At7tn3>1fp}P%J3foi5 zc)zv{H>fsIhmkc47I!Vgp1)w6oV_9fBpeL;{j-62*6Z?!(1n_lD)4QwZS|7i+3lZy z2qYOB6jOU)XyHYepUV{AD;%2hB%h;+i-?i)Zdb^$Tlvyd*NVhNg_ZFQml#Q*eNrrbmPp_AD%oz0<8M^xIt{=JzZtCkTIeN%PcS>rSoE!_QVEi%Kf9->Zzj zQ@->)=7=|^J>xyf_ObUn{wT_9H}AeT|B3&KciKNpYrK6vgTi{T2l`?2m;g!AY{H#s zfZmEf_}G(vgI#WKvQL~mjhr(TkpAob1LddZ0G4WR`Mf+=y*+Gxo+#dYs$X+5!h=bTStYv+Lf0YU6mN?yM=&?u9G!mcyr z`UEh^lMmg3tpg}0(%~tC(HozI0j)>94E|onxAw@K!-&s%)VeJ1okA>cpuZWoV#Ax? zl5u0OW>fALdK?`(nfum}>*yZz?JXhNk62iF(Xrn{$Hvc-Kq0+R@7=XPveLP0fn=o% zPnLnMX2{A&zM&B7v+eH(E7Ny3e$wKNx=Q5ZR*I}jW%#Ndl^7dl+6j-kdcAB;rLk?} z7eNqO;>=8!#m^&d>mUOaavNRjjaVf!Ob=<{6_`Z)g>75BN?f)l8v6gMR=nE!VaXQ5 z?PC`kp}c>8fZOG-3b#SObMp@ez1L%g0UF{HCwhH+X+SK|_>L%NU6;O{!&nT>t0-wA z24!-Ze?FFdID&y{Z&vuteUf6{JdGzcx)WDqVXCm2Q6B!8)#!8e4uy zjk{kB)*dD;yx;t$tz<~;!8{!Z(@uWPzCSgPt;y)miTpFo_dB{c8U0I}SB`joD{x6V zJ+^b!%#+a{hHKw>+Cf|w265hc*R9z|#{IW1t;W!<8~l1b+3(J5sfo>ApCNd`w}xNC zK^3me^Y%RSS&PjAlUe2L4WN_%FVlz*BbzU*Zq(JN-G73Ut=<_;Tjj|=EVMv2WaK#a zH^g?&nzdgvIVqb!gDfixz3;t-yoKBgb!O<**1{|#2TC$GXRz0s0M(f-Qx%=$3DRm9t54vm^#kF0U( z@qE*d;)wWQe=D}LPiWrbbjIY?vwDc_>=~LXr#|V2v7NnZL;UR%YWO8dDd!A&i(j8R z5UMtu^-5EMI76!iC%?u699SDI?Zv((${8rPRoAjk{!Q{pEYxQQV!TOpkVCcVel|`G z-o6wU%-Ji{r*AHILMeCyw1aAU^0$BOq5M6#?tu2+L3}1_Ya3phHe3@8)@+Q}B)v5r z(}%7$_*1JaX8>GzbpV;&0G<5r#)Be0u%^#!Ru_P(DYd@jTXj9!bs<=$++(UP{&QNN z1U+oubyZSNC4NAi=@upFO(h_h?E^D_L;87{exZf8tdIV`)iL}g++9KSXCO-qT)e^= zY|RsLx)ptTN71KP#((5!eRp8`7JA5XFgO9_FU*_L0 z{wmDy*AfWOSE0u7C_GNL-+SEVK72M&?}@5v?j!@1jSiQNE&k>BAezjpn9SXMe!-z| zzs(l51A}3_#cwtq&~*(^K-U2Qurs(IVB7}{(*efgQq0A>ki4=x@Ew_}5{*ecCCCCz zY*pF+(jgaQ@bqX`-xs`uGkCNnkvMyWP>WOqny&(@^*|&N^toNV&F!kpkb&vcMn5;{ z{Ff#mqX$!@Qv^{7WUj_P3rnz5q4yh{8UN{+;-tgP=hy9H*YJeJ?RuvqH=zOAp#+XQ zoc!BnwAF>D4|ST=(B0xl4o=MYhh$}Ao0?eTULdS<|HEQ!*1qK3{XO8Lojms7v{jJL zXGo%>$xojmRMh^HQm13F`wEU1H|~r+(R%3I6$^@M>0L$T-m~XAV4?!~i7B;{>#nRV zyh)!0mJ~{%!yWf~Dgv?CSq-ee6+YycHcE8}pNR19k3u7DnqO9QUFrW)7#DzRi>_f9 z)qnacBG6$Lj_~QJi2}?Mlh29gd@wp*_5s7i@>V#BHBGEcjxfKC2gz9;Utb#kn~s28 z18!A|%pR%(<8lQiUdXCRZxHq)_Vpd9nPFzmQSm*M@n^RZ1XQg|b=N_xtUPn)>toviX-4U9HVc4RU$OUqcIq_Mqw{f{dc@H@ob;x%3T1 zo(J9fh9a-0LOm7h$<+Lao+3)C(i1`ui!NL?%{Lk(RD1rP9o7-`>vU&OP? zesP-6FTGXcY=kqvdv~)rAo)4{P(CpM4dYW*sG&fw+AFywfK>4b1&hTev?a$Rfb4Bc zj!AszU1MJXvUiOjwL3p+1gXU*tQqG$a=7Y5IiLwaRd2r-M(mdfPrt-hA<_y92SAnn z!TBaL2kR`c476L7i7U3}9Cio~^hIN(J4m+WIY-FumhQJAE2;I_jhO;IwoftZl8+s$ zi5dl$H@I0Fc+!e$b8+-a6JKR1Y?Y7As69 zGOHBor7}ju2+^-w#~w5BgE;aSYIsA*~OUTz8Bm9K|zkyt;lNJ%DF?f-OD7Gd{fb+!ezj%~M^hxr^kV;d7lh$yl5OmaNW?Y&yj)=^r9TTV=>hR#&)?(bSq0-o>!5LQvammTv$UKY91X_ zoI2rPhi1qBK_sr@l!1bwW9Y(WzKD<75<*hbOJhp%7zN!Ey#qE!{iNHqO*{zlTr z@poAIDE?NZ594o5dVr<$wZDXnC%rp=i_^k8{i?lQQpI(0^~|0VN@LUM<-8dO2}q8( zN=Oi9c;}GTv?gP^-SCW_9`ATahhhw4hJmbY7TG#f=P7!nw`JvR9RJ* zdpCVY^Rufg8egek0nmxdAC&j2N2I7pbty~rWV6E)Y*IY`zp4gvf-?C1QY3@xG!KYK z1ebsmIt_3#TP@UTg)(B^&yOs!e0+ELT>1H`6Z_Esq6i@7H7Bb*i2+qDvEco>=k}I{ z&9y^<1ia?637ipb&5GV%OL&Y(R;p*4)J*|^YRfn>?MzvZSIAqkM-n>w$pS&WAyN~OxP>1|fAa=QN z9uEqDwpU9R9nN@aFP`S(YlqtWzvLopYK~19z(>g7MIYSL(qUj5Nr%Uee}sWe-P@ME z2ex5v3s2&+ce#MI5enEm!%*6XECOyc5YBfPQI~Boo<}_ti`%9q-)a zu>&iU-)|Wef31AS=E}p;l_h@<&HDqYCq22U=;~3!{yDkps5qMMk(JqhuPk{pG;by! zHDp4dFx?2ospdSvEH=@oNIl^$IG!J~^~gE#%RUH80bNU>%23(gW5f5LAE7>8sAvFC z{~}7@ta7btECykt6Fol|ow(qGJa6QqG9R&L~h;D?Ji^19o_CSX5GxZIuwmBBUD z52RZuM2SkVKXo_doJaCl75$xxp6wUi@&!e`Z>u16WO)S?9Ex~)%(Mybp_P7(ZvA~0 z8#c+l&)??z4n5E6Fq-HZP2k+afH&EIv!_w6II3J7_F}?`#M|YX3}%g$!`dJNUZr$X-{Pv@>*|hWE$1v#LD=9 zz=!Q-C%W;cc^`Jr*J#qV$54en_O4}Cmfmx9XyGkueU z!*AgdT&2>z+o;>i6M^UTW=HHfl(h?hf${ISQ zQ`86?z|`2er)Xkwu~*J@@R?&YBZ~PXB*VCN=r5W3=z+HN`NrwCqjlP~+Sq;4K6=+J zv8~TTA^5=%yw;a;rIk~aTxs$9O`XWI@9$epMQ#0kiMb_T-*S?@vgu6Q$-b{h6Q}87 zddTbXYMR$!_Ub3|UbCMwO$AF=lIn%>WNwZF_GAa_g6}zC_0d~O*jUb&*B(a2b&WoI zeqS{w(BIDIcD^#ivqTVM`#cOKSm7C zHYE|7%84jhbn)22X*?DcmdIL%Uo+%s*oC@`2e9P;Cgs3TDI1^+mF+v2p(ZEa7PH;D z@howM3pN=aIRv~v_Wq|PUpSv=@N#XvlT~cn=CL?#eaoPe>*?r|Ns+oB3hT(C*zn3#;$B*tROp?@ zMjTulT~%5LqO($e;}8DBvp>(u>XJ3>238kg#$Nxl$6Me(GYdXhR4AfgN>T=t(TPX$ ziYZCSS)sYpL}@^-BC+8wuk?A#VMDy-o}m6hPy1iQ&(}Sx(fF7`>;pLFkIj#*3C|y^ z^K{2ugJgU#dk0Ku!N}rF~a-3)H8K zmQ_V7M~x-m{|H)vu*dfTdR=&OSO>t_wg>A(|WbV(>(hmMRq{;k!+HXaA#Prk{#W?Z-O&d$K ztg-ox3zrw1t~1!k1WSjBEia)q6Q#_-KdfT>v_pWqh%v}=H^KN6>K)u<1bnwh)-o`g z_5g9~-~AN&ahDvKjnoRWnBJSa?AV*ne|vG4dD-?YW9n#pN?YMhoTGG^Ezfo3S?HNC zxY+46S-Ecb`4SKa7r-Rqt=;fC>&E$iv2OfaxUvks+~`3!e7TVk5g1mjilpd88E1up3*B`tGFH@T#I zB|S_Mn}NweJGh@C8vh*I%i_Z!UhkqGb0b#ou4+Xd3};iu`+>^S87-yK7~sE01jV;< z%9!(sBa(G?{Pbf-#>7G zd2IBqh{#QTNmAh=0s zUFW(i>VLZ|YR@~-vK&hmwPHY0T1`j??4zZXdLlXdz0~j7A)>K~6pY69beT2Wl9`}S zk^(3Ycb;5>=K6;?6d z)l}*fGIJ&Y*ZDGSX1uAX>_Nf6kV$z}{n%c zg){J_|J0T>@cgrymoL$XW3j#~692X}#o)h?gDHQ*B7O#yDym=%#G*Ar{61181Oz zL8Ilk;l=;H4^lDCEmI%RR`bA>NG8jE@xG!$akScy7pvMWO%#+Sq5+xkmZ7-0?(k|OfIHuW045D4e=_$Nm-Hu+&_BKLE;Zk! z-mHvKl8A1FQq9zBu8-&I5p(!5%;8+_c}7KY(BLONQTdTAMH@It7)_tT-$=Tczr)hU z@V6>m#NV3qA(m2LfBRT^PyTYhCw3^xb1<~_a6Fk=n8}jg!%m8909PM6puxR&SXcyrQ z9)SS6g_C9FEvzhqMKiRz*4%=e-0UFMST}?gOu`#Lw7OH{0&Q;PSG0LA^#&Gn?Y%i# z?O&QGZ>81pR$47@L#xwHYeTDR=KHkzwoj{Spfg%E`QhDkdWK*{PGUh_9nc6#8O@HT zZto(ONto%F$*6X!G7WW^gt3m9jBdv&Q%^G4SIgCbY=wf|MWfuV78~O0EXxqGXpGg}y+o7xoVvXI7%MFpA^rK6u^jIpj*+Qh`?osZ~^(l+Bh;Tqr z>Fy6zDN2bVR3--%rPEp7`GWAeOl9{|nXL~u58A83=5sn$IO@DK74{A)-0&_HcA-M_ z`vI9M#|pk%RGous_FmOo)E=%|RLzn&aBbWfbh4)^Ia`%@SIlt-6r21Rs#(98MQ?jo z8t6X%OG7P;N*#cwVLm7^6|zC-GYz!RwwQe+BS0 zi^U4O-CJ10DC>f1r0$y+|G8#W=|Jd-U zkJ}ns5>JpSRQ!zn^Ss8Nx-AH$nd$u|I?nk?qE_yo2SOv>A0Cs}bK9enRl<1GyO0SN zNX$_a0y-Wk4|1XbD4j1a#0qBsr1hCf&pCzV&+13oJ1k#v zb33&E5Mj|uAVwcwc7C$oMB0og=B?M0%G#cvwDN_4e=}m{YZsg3dH!XoKN0kwgGK9g zDz>4u+02v9Ppoy$Us@9Q&VTYtt7ioxI+AznlXg;>%M2bTC7Qf|NT67jB%;N(%d$Jo+3)ahUr}XeUmlEEMmVn?(oa9!#`S?oOc+60Zn3o~XFEx9G2E?4JlY^%0PG>Fd&pU$nnfKm9ZVu*!{SV~a2OkG= zuINHv{*LE5BJZG|i3A-o11y{9KC(?^_rIXZ4p(J!RoO2xmA!ZYLbDGQHG0S1^jS-4 z75=L}1v&q99Z>RVaENXM?q4^}qQnwgkY-k4vLuM!{?X(VthY#{tyqO`=KATAA_%^Z zxLI{(UY5L&mZ$$N<K3lkWnp0|pQM;q+vUSM5vUTBTS0WL`bRnimJ$}7n z_}@$PU<$=R*LDgmIFTu|4>fsz+ZG_GD}B=X;4}_EHky$1s&4cdHFYHLx(;fETg{te zkqh!NEF#{Js4TW$thV~amHU?d3>8$EtC`zcLyq_my< z>Yqs5)y1+-h56P@dXRsu@{lIF(mxpvw&*vR`?E}lCDK#@weF_e1I{MOH!#k(b}r*!5G1Njc=?2Y_3dWv z7?h^8iIC`?A8kW?t}fTf_s!9y;s+-Oy}TNY=k*`xWD^TNzq0Ax^+&l=fU2?W`KJG) z9Bs}wJyvwDQraQTci#OX#3ggDna5cNS8vu)r`X4>C!OApUxES=kmvIBe(_1+rC#2grm2P8I7IBbK38wIkUXJsuR_bPk=%QLRx zbF^k_=o%Y-ydZY_U>Y&E4`ySRm^{oYy-j_<T~`@eIGPT*&rBF+=aMadP`jWl^EWm@zI4T-O!lvp40xtF7020<~6Bt&V^zF@0R(Ey}nc8pkCjS zxsB(d8gNv3$Qh6fRGMd?xg!#^1>OS9?kyy}Dg~G8;hPY~r3Zsb|;Sj9!%&uIAdI9T6 z7l9Stw|rL0GLp&m&q{XRe3VvEa9jzpnLAh4Mzc3GVq1x?X?aoS+a5OsjB|c&K8USo zf8_7dnznsOjmfB1reI0GLc;m_)qEtnzXb8bXQ=Kw`DJ44cpikL8&T2ydwZ(&RKuSq z>cND5H4yr}*Z-B0fnrMJ><^{ra6-KYf$H-cLk++7T|u-#A%$*{{knZTy{|QfM=z7K z4Ul z;!~OPIH{lto&Y?07Uocetz~qkqPMMObf%)Wtz~qkqW2`6x0Xkk4k9gU%z10dPNnWt zMJBmGZX1Zc%Hl|#U{>L?R^ep7!a$pVwTrE*m}!MH8qo9$u>Zlrt6D(wCp=l>JBdHx zKi0cJeboJi|L70)qwY8S$9w(n?l=5L4L*e*)h`wvk(P67urZfJ0;yha?nD%F4EF!@ z5ZHemZ04IrQ6?wKYV@mV-k;umNxd%jE$&C>IQ7a%Uz?vS-Az@}coN<15J>3eU!#V3xyNf!_(D1~_jIa-wc27>ngDppPA ze)f>$>OIzTujc0t=bH@T+}S-iLC80C$h$z_l7lJBgFU;*^XCY}*NaM`0_gmIGi{=02_}Q#jvwwko=fp|aci!I;*mnkxaQ2#UpGT4kI3`l?*uUZWfZDlY(*ZntCPNqfp&eSSmr_Y*`3b#)DuI4t7t{N z+^tMM2sO+y7#rHf_Y{BMOS*QoiRqO;Z5V%h*K&qy#0MPs$_~x_lfFXV`WkAu78Xir z_T>7IDxNb7OwMlXE(pz?!zZ5l*J5(peQ@m!>F)+tPfX{q+~{cRy?Q28G|Y*lV{tuc zD%SID;b``rXrf|Uo_C5?`!WdG6=goG2*G<*Z{h-HOutJnB^z(X`SONHwB+;2e@O4= zYW6OggNn#j<>*G{j~&a-q!=gUR;S*y%BsR;iM&z;NGe$~?ditU zVp9D~3dB%~T{4^q$2SlU$?3Q2rV@KGihm(H3vYG{{r1(!{F8dOWThKIhn6wwn;S%i z)K))mmF-qc`--e(TK;fSF@ahhj~%p!T*@ssVX>v8($af77mI)PIsLk!od?$ z0LDjix9gw(M+;Fc@bkQv*;!)o>K6F&?x;iqQ;L;hYc3>6HGJ`fk~4MerJS2QMEVGA&+X=bs}N|zgwqluv`2DU}B zKlUzVXf%d3wv^~NwrnD+*Ck^kvzDcfXX~T=Fg617k&SHz@plrf9NzK=k@#e5rahCo ziPW~a_NY$F#i8bM8QK8?iIct7?mqfT_Sv=f^49;vr z2876(im7RD5)gf)unDt&_=C=fV9CCSAkv-)3eI2vetcXaVP-y4Fc4?)b^I6KpSM}!#xp=17`JDY*uwZMpXx5yxxdW3uNtVs+j`swr{J_c8lf- z#J|94G9yj*esJsOc@T~-ql;VD&n~iPVQoR^iPyVL>8?{7{^E9%d$9CV`I|R|xQKRl zWm!?7_u%Ui@MSES*~x&NhX|@d?@^CrY`7%*2F1}>D7`e z_UcvYYFLZr4Jc0DG6Xb7x#mw0VO2<&mtf7!L-m<=$-9UyUp;3vnyKuwGgTQHudj|t?Tf6F4? zv%E{rrQ+Dm+|WF^9jX`AAhzpOuUP-at1O+VX1#*VI1*+SMR|)3iw!^Fr_h`;|C(N& z@14W$R-o*g`I*( zCS4#968D|iyY(he=I8u3!;lbEv-c#nSco3ZN?9=t6n(*V9xVET>;o?Pg2gnDr68=m zP8WS)l8R4>%1Ae#K0+Vtza21><&MJo|>ci>|n~uI}Io zvv276o#X5J;QoC8XZuSh=kfQ_sXY~6Dl}&|(gBx$3vr}jHEZ7k+uqGuA|hl#?h?Hk z_@4VmFK37GEu^kdxTEhSr`n7rs`TZRPLIlwWrW<$J39*_3aGt~>t^2N6G7+YVFf?f_GbTwT^F zs>+UDLkA=H=iuMtEu7W{U4-itx|UrQpo@5l0lM}Q;HF=n=hH@^N+Q4+NE6CO>aig9 zdUZ6mnw_Bvd|+Te}GlV<9gF23z^r03k=g&mpa-!3vQR6ju~ z(+K_L3tvU&^NxbfyWmqbf%Q|J8@fVK`g0vRr0?j59cJZ@^Vif-KI}A6#%u}f#ew}a zT9P~Vhj(Rjz(i*z+20}Fx>kj;6?l`-Y{qk z9SVDg=9oMrCZYQe z^lQ|er~`B-s%}0lPM@TkL65V?qpkf8m!i5{2k1^z0?+GyRBlnMzpFN*uQ@&35k9083<=pB#+}-Osl;PzbFlyMld2JpI|OJ0)kohDWwtK zx!$}aJb(BCqo132rn*|!Oj6A}sEo2K zCx7&-s}(AR$%9%k`E_CPSi|IyRwNG6&9aOysP5zA*M^jLhsfMc5GmHf|8uAza><|R z&dN_5A`9RT;uDGD!IWdi(Raa)zk0eIJI-nRB6i$480=1=O7A+mj02t(Gg{Cy^p}i+ zTyybWsA^1YZpBqc-q3q1&LvSpKWcK6qealS`xzbnWyAIHKT##7 z%Mx5KioxsHEsG^CB`w*Zkv7iSUf;R*X=yb-wHK*awTO?UjqetPG1C^8nK~|0WYK1? z8Iz1ePPN1q%8ZgRuv%V>f@)98iF^6Q@4hm=>?xxIy-jQ`Uv_>b_f{mo*0!rl7jRKidh zAIyGF7h1{0IL?0WDXQjI$13LAZ$nYNr9Woj?ZhQDyu*UsC%e@sli>iiD!AB!|2C)U zg)w=0hy~#-om5rrI_b#u?gY!I)=RPhXU!zXs(vb zwbp(eMCQIgU2-B<8*(Cdb>p$8a3H#OMiJV|22e@t^X_&1%by&1#kJR-f9=&*R+Jo7 zw}1Vtyzi8TZeO8LQU4&i)x;AU`8&OMRKq`N59Jn$zh>2k8a_sYtt{CUx@A2NGekzwwESu6|eaEDt*Tpxr1P9$l+$ld;*}*^FhwrGkNR zyKL_4g|0RDzS@tHsa%&8xpb|clwW96Jz8KD*n3B`yY_@$wS#+*g9udl5HUb%G0=}H zx$HDqM1qceh<0>a!rVjYl)5Z1#v}(u)UF7MP`@u@bsYFILh)q|xJN8hK)4kBqxq|h34uovj*WoTGOa)B{OPa;h02EsM`gr7D5b6pDunW&X70C~}Lcqkzqj&A&7TAf!jhyOw zzm6L%i1yfIa5hzzd={E}t0JBOk0!n`iGfJA-249UDM{>+KIgr2pPF|Odbkd|lY4DL zkKc$2Tn1oVO1qz2{_L9FjiN0Lf5!f1SQ$ub`{Mr5iJX-US>E#(B0^EV8020BKoXo= zW*VeA74|?S=KpgQaiIf>puR|PMajz0oTb>1w24?_g`TuvD%`bm;sh8(41@DLr%d>0 zQ!2)UPPZe2t5C^Xj8N$$8%h7Ndxu=xe*cPQ3gn)c3;GD_H%ahSn)x>^DpkOuSdZb! z)q3L3f6Wyk$*wN|QlkttgyV6B8pY!Yo1sSWc*16=Q9K@JsF@nklc1U^s02{&sr(7c zH=_4c{)GLFxZVrv84|rq<>BK(_ZxonUjNl)?T#V&W#ezynL{@mTKiNa zkQKO}(0Ls|Yk15Qt|yCzkbp132rAQeAxE)9HF_KuuvnrxHb96JVu|XBGX_|*lvjB; zy!rny_a^XBR@eW3SR!Gagf)t2)TlwN2G<~>0YN7)!ML>2V%xY;+S-bc0TimiB*-+5 zrnOpIY`?a()vC2_UqrFWCIs9-)S^_yrTUCx6>uSdCBOIQ+~=8@WD?YVzyJU1%j-qv zdG2%9bIv{Y+;h%7w`=Ie&!{6cKNN1zU7*pVTwP2Be1? zPC>I&yy2aJHLg!*rp1_zB+HvS}MQtWXnnq*yZT?r}+`rx{730-ha7gRQW zn-*_-QG6otAiZ@h>`x0*Xklehjj~X)pXElfs8Y*+ts7_eP(v#R(A36chxt&b&a)J^ zbXr^Zr_xz`xM-=eaf-EC#yAOL=EKi54H*SZ6JspMKU6)i?2OGN1}SFWgOWM+=R7UN z6t~cdM71J*)v+9rEjGtf1etv6AbOUl-(!yxXGe9*T^iKe_su`>Lp)kYhgT8N~$uWX((`PHW zsBNh&^|?#6(i8P_B1`>R7P++}HnYe@x@?Y&TpL<21pl8&1U1w!ODI37vHQ~k_7c@q z&*;5KY&W;puxGgQm}JfqEL#G$H}Q6mK;O!(ZC5rj61U~$#86Xb%JdeWWO!w1 zxOE+)#i|p!;ZX6S_`Ly7JPrmJ6>}6nEQpFJ&J6aF5 zW2J%SL|ej>wUfe=YfrRSr1pK9OEe?#fueCXdRWCxd2YO+x>-DFL~2Iat($btF_C|F zj~@N;*ie4=QGtAoVF|`Eic(X@gsy&yS+>eJ!r}h@gW=_c8gltQsqv^$F8B5x0)@*6 ztP&^F8+AQwZE~R}U9F5CH9#1cQBpVh&a1Ux46bZEY53k1jEBH7`hTzbJkI)UYYyX5=j`O_6SR zvXH=D$N7HMj{a4R`tdc*vML%f_<2LmaPiEHU$Kz;Y{3v}Aom>t8_QCgn%FkBl@X*a zQHb|z{CH|dkG8sVy=TU&Iwu#H{{`_8zO9l1irjJ!lw7{Vh{*9K=Jbwdkt_T{NYc~( zlmH4(yZ%k-%l@1m=ZkKFJOFzW^^Mrvlsqf5^5Fr)^NOuXim9deuoDhOkfF4C;gyWs z!@+6=XGj0jtPn@@S82PBI*8zTgzAdF0?~#ZnQ`p=ckNocCO>R3H-js3^i>G-Yv6NF zhM8u`+$Y87K)~42aa~r29{DWXVjFpsf?) z$M;C_7j6>`Ex4JSl4eT#{iG%@tKD6K@@>Vp?+r$l~Y>icb{nd5*s|JGGT-(p8y1satz6}36 zH;q*eUvXBv`xH6~m)ZrF(rW>cD?y4 zSi=;xtU1AkYtoR4`D<%|6GwhqSZy69D!Vk-jgHL~RTf1W2ew2SFKFQc@_%^mVoJkT z(%naXdOlZWV>&p#g@e8=d5QCxZdCal#IthbGsKBm6B|z{Ad)7+kw7!Cab7`DpkJ(O zg&AF{Q8GB|3BdYXTxn7)vJ5ZIp4R@bN!**qedx>byzd8%E3)TY8b7yiLhSfu6Jqn0 z0ZiBP1oyZ?mhKq7WP(jLHoRkmG~J)PT%t0rtA<2B?3u`xe2JU*1D#L5o%2e>G+gpa zp&b!ddE>{QBWxPE$09rE;Iyj*pka~5?mM{WYDb>ejIGM|pQwmUp@S2FPWK&Xf_LQU za=T!b#5M-qRqdKEiJ{i*W@S+e_)jPj3C@sOf^7YnZk>48@W|Gp(~XN5g>a2BsB7qk zl^Rjqo^Da5{E5I{H~PjaHL!djpW{7@Wy~->F%MwpB)-qG zWBj9T5BzD?H(OQoLl(#O!7@=eE1o$@Uc|G_=>cC5#&A8pi6>X zHl4BB&N5JM8F?z`o|D)iF3th2P<;-c)9VAnYuK#e!AA`^$Y)yM1yeVk_KVvo*iYO7 zHn|Re$iJU&km{LCn&w)X)=-76%GkJV5XAX&j36o-yKk#( zJa1c`_Xw6S&KXr&@HS1Ca|51pQSZLOZ-~0ya zMczN4-FWVDmvpz1KHZFF^?n(+xnIns&-nFr`B!e%ms|Ma{Y-zZ=Z_@Vt(tKuh;8*= zd|vHyvef#4uq}u(EQ2VJRQ_;dAGDb8B=UGG=MlXjp4$& z!U$hkjq!i;zgqn)H>zLs9`ttyP=+WJ-{LEju@|$1P_}!-)-KQ{Bdn-vN_dJ(0UP<>W>kn1cRQ%O5HjBSa8>Xtvt*kL&C5WCC`% zZmOkIN=d5uY!n58__;ClW||9(xb4xL?$?&NWc|EPm^CBRYt zmXMzz{=z;aPgF0Bn&Y{5{zd}KD@K2dx`UsfR#fzKO1V<}1%LBv-8}^EgTSMWB}lBc zYBmZ-fmT+EO)qby5bC&*V6P6Ff8?EXXkxrix!@mQ*XoMZJP+SEP%@ehFM=If5N1RZ zN$knTKaZ*D`8@AO-;j>NrQ79*oQ?Ifb50h{a(ZDT)(4wb&GUTNyYgGe%~RK)xn_P< zk%pd#CvmyF_?x0&;#cr1_-qj{8)IS1h+`_h?gA)LSUtzw2aWlaj`wZ|HT+9i18Boj zHbEN!vb`TZ%?nuC%E$&PW4!NUm9kkw8Uia#8J2j@0hoHX^1Qd`J4NL}CW{qC@0}^X zIN+hIG+AW7kh^}#TFNh_ly!5V%UYsO)N1AyikAEDGP|g%GJfT=#MXwAkILCjI^%Q8 zabD{8Aec25jBx|}_zrW;pQ#xc_KM5wxa7KhIcu2vqtAl*kA2)5tUm>2DfiFGry+Tl zgJb}w0B#^}8DG3n>uBGHmp|y6X1I|A@Crr}z$+L@CcMOi0YdE=8Su&gwZSa|)S2+} zTOH%KYVf0%1~+=$3A_$DjX==Q&*u9BkQMZo{}b*^UJnf6URVB@Z`i6U-ghU2@QwWU zGl3tKckLL9KeQ-SenWx$pD54Ndx~d3KIs|osN&n@N@|3jEC0*~5 z{&}-jhjGAnsY|bM>3<{LyUQhA=#qY|q?<`<@Bh%wQmkM(WfAPv<=%BCY0iwxyz{G_ z%~%(r5-ys|iEq8#xp&nw=AT)PQ0VNJKSBfP+b_#BsQ`c2ei3o(7m>?;A1|)vw|4Xy zQzeS@^c+f;8X$f3^UKI|(_VM{x8PM>6E(Zo4I+=*RE>8*&eF5I|8^NB3~nyIeEg zvDF<@8r<~Gy=H5ZxlNIHAG@Y~3v58*-(;#3{}+{r|BHI0y--slUO*9erj#^Ayj8S5 z6||aqs(_?*_~i>`jUihHuz5|>dR z(m3yBTOMy$DTSRMMrsAS?`uP<4>)WUTcoszpkny*;o+!Gp3?%W4`;>uR8(*eKzR91 z^a5)q#QTIQwcUOeb)wY0(N<~82i%-wjllJ1% zi?kP49;_ozy7J@Ey)P@04TR;DFK0D&@79#K6V(txOTYQ2F+ zYMK_AQ{*fak&l1)Gz94689uL zJya{L2?ALInB!^7Kaap}aU}LM*bTrEc^$ ze;}57z@)~=8V`lVnyucFh_4Tj!b180DJ;gV@g~GBShF>8lQ#Hte4)D2cq}S)qQ%qu zTHZsCTz%}ASj+tPOwA=7Q^TJTN>KXLT%{}Or#5BH{xS2nC^Jmp8>MH)_lN8r+00Eg zl~RdMQ&~oyV+SK2_{^s+vB88V=V>9ahi3Nsm)V7tJk#UMARF%t^kV^F%%w zWpnuZb+kyQT9k=jWe)Vim>%k07KXsoR(!a?bu!qQa=Qpa4FzteKtD0-HVu_E@`q}Wkg5;eZ%piHfU`YH`gglNCS zc(PwqWBQGsGC-=Z_$y9Z;$~tn2b|SLGt=gRj{#d(D4Xa_Lo|<`=rEd6$3k^I)hJz4 ztsu=*Uc1RROQ1kKS#h9nEXs!6d+TEdAXYzRZnzVJD!qu=wj9t%LR zpF7UGWo$}t*4U<(IApNWO^O%qXYkoa+Wq9Q;;Yt?*cNYM7s+n$9+7G0NQ65h3gfZl z(5z8On@!{_w|6(Iq=091noWsaOmJ@?JOFOhw};8CFE2!<9J3CY(%Y?2rt#cQ_OTCt zY2-r*A4q!BCEcy0K_q$W$?83=KZ<|qE$0vXoxkd@*oXJy!ZwF<5vU)yNe2s#rXMD2 zA2an|)PEvdnbZF$wkF5eD{04jcrC9%HHT+ab7Z;Xa_!fw8t+o7dGiFFZ`gfDP|pa} za~bt`hpT%Bt7Gxpp>7ldHHx#;i0Lvh9@JAA0K{qS2E~*8GHa$*##$qg7Id0xDQ@da z^o;th`XqvNtIKplHi`{?C;6*P-RLJT5odQY4@rZ~m9Ke;ON~ZbpwW-i z8ESKs>FN+6ILd749zCkQYv%g43+miW85Xw}!e^+ieW@!LAN_$oSM$BTD~5RT{x{E3 zZj#$Hn|X-@BuYN!@dCc_ghuoGJZZ7gV^v!dpGB3cXD3S3oC*t}-e+J9Xnj22I7oY(A4XpA&( zmGel&c%k;lN}NZ~hj3tdBHGs7lVX=Ody``0l;>Tyo=g9e7%1Oj{NKCT{2Q%_dDm+C zhyS}vnxLecN%E=`9hLiWTzdZo)346emlOHojnJQ?_#*+^;q7sY^ed632ECgW%dp`y ztzWf#j5%z$a{AR0@^}}2&ornH76kg$7p`#nRr`ABW%hN+iGhCgVgIYu5B^g6)kS>p zzVUtjT;Xc`X;&NR#n<`qkDj9cv(BXJSLn}W`tv>gxrjdBBxc>^e+3fxN_0PF^D(|!9%%e91Wp>wO>#r5IK4xG)59e_hwzU?& zqRWyzHM`^8Q0=9DetgSk6k-hw%RX3Ti8aNO8!vdSJ0YCVbJi$&VxM*4cm)=nNO5_S zz%b1_pQe3ZckSpOu+cQz`s6K|Nchp9QEZnBWc%0cVvYOfHJ+E(oiUu!7|F|%_Q0>M z`86Afm1j6LGaRAC;6 zV@&uYqzV1+Lf9zvn3AV>zoQxDoF+(3Pi+}+{GQ{7Iz6J=*UV^(v{3zq12yr>!t(MY ztq6m7@ira9dh+pasm<1t;W>2m66rwWxx;uyPjeV^#XFlMug{dvoz~~M?{;4IS>ID6 z)Pty-_%W*dmQ>}>w64tYdQg+CL$SS7azeU;C#jBeQgtj;9V=H@2j}rj2OEe<$CYz8w!j0h)O`Y}j>@L>LheC;dPz0b8-QWZi$?<+_hXYZCihP+yTkIDV zsS2Xv*~0Jtnu=!=3W-M_5(jk^SH#{#Sd~#y5sB^CtGorBH>JD#MveXH4hmfm(*ei-n!iyC_ia`qlgG{=0tlewY8QU&Tol$7JIz_eBC> zIrqgG+KQX|qJkw8eVC6kv{AQf-e#2RsY+>8dZI%GazD*ihv*eges5f_^zM4&dZl;Q zn*#gQyLv<6AQ;yFii(YeH(0QRX7A_+K?PDnj&Kd`Tf{E^FQX>ki1GgtYUEw}y&(uv z@j>AtS^78d^|KVM#k0 zs;JS;zs`rOyvpP656z|4qb{9fB>*^2@Nisb$zqPQBlPAtgdAyK{iZ}B{O1R_^=J1e z@&5r5bi=U$iM~*Tq*<{JOm%Pdn0cZ+X+Oh@7Bf>&5ni-ES3OgkYB4QiICc_TVq*{anlavFjJpL5i9c55b?oI*u}VNtpg6bC;CygC6M|DU)B&weT<4S&*i8>r%NSjuLXU{j1~GRcHsA#aP7mda%3`eT{4et6SCE{ukoNFl2b~kmYq=r z$FCy86JZoG(&L5?+Nl~!MK!}$hP!OD<07|H&dQKn5&sDkJZ?3|bH-8I$X4~|UYpO- zFVE>(p#vu0S4)kTtnN5hG|EN;Hu@ZwfkRu+Gi z)l-qy%%b4F04(I_(WG5g0}F0Y18D}tVrR>tl+y0@;pyq(VnAJLEC!(jlf-f0#%=fdjP*kw=$V#MAl``2T-e)kb0N#;*kklCr(~*y|7aDCiGSdE3 zKk z0`S7gkH@pXsqWFj8GuQY7A{_VO~vwex>s~rC0}4c3&BG=JLe2+Iy>hLOm3wXiM6Qa z$Vdc2^5Y7p`HQZrYfXf|@H|Nn(q!CW)(6M``GVR`J9!bIxZ$M6JKkDG&fxpM`FS39wb(xRVFPr7}<+{&XMTUA--|Od1^OW<%J$ z#X*xE4f~&SwCWv*AUtv6YmkXstNHG2zFDVKU4D^|hR7Q4 zpO3O|i;B=9c@SSoJ!uxq z{aK(t^If*9T(*_Ub|2X&`8}6(zmgUyiCI$7`m}WPH+)^A`Z7!i;B10e!rjozGn#<@ zVafYJKwU%if99*`zgu*iQ&Vqsv?Y2L5jEbiWf>`TqkEh!^IrGRv-u@AJ>(sSnJlVaDe5;GJA^hNDkKjO~Q(_6L7q06Dk zU!urt6Eq854qPd8-79qYYgnQW(GI*5xb4O(wJUFOhks;<+dkd&gHy2EdV}4Uko!_r z14>UPUHoY`)XbFotP}kD z>0c0^CL_Mj5ZUog&!=ia(s&ag4)>_c?0GII&bP67+XiF}i}O9d&1$kug418>^iIcp z@Z-}&3khy+L14n=982TqLbG)O`)A!w#WATXgNzT-oU5Bd4h}WQPcyVQJfwDK|JnQ1?hFFV9LIYQ7DelO?ao0_1(hjF?pwRlBHa)QrC%-a zY1+h>DTsbc6%F<)3YR8>ig+yXD+!k+hp7_ctB~r)SD_~A=bcfZjkSJoWm?74R@<^4QQJ_G+AHO}!}@2TGI0)*vJL9&#o;d_z86BpIJCHsMO8Y!Q2$UvJ@9S{ z?^sdIZw-N~ERfZCni3XQaJ{!(x)o+cX}D3zs8CCQivnGBnR$}%8$G~qTQj5$UUxSb zUdwDA^m7Ay?=l89_C6cy?)Po1m%uH&W0a(M=v{ih76c>RaTX-%;j;l`sKG_t5ZKu2 ze^j9j_`w2Xkq=P18^rv%=(V-x|NR%3$;(FyUS#ViNR+oJKO35>d}yX8Q4_J45Cpb0 zDWuixeU?DLIo$o!E*?#L3^@2NAaC~k@q;^shzU@)Ge3IR_E3H|{uA@hrt-(3`~m!* z(*5Jmw^r~!2)^W#*6*uc*7$bUIpUHg8VAQ;p44IdqklkL8}7}fB>dw;*@MrD?To_OxtlU)3&QP(>B>HH}8`w_u0vuXL3SHWKarJK_9XcL9=8{FT~Zm~+7 znPvr!{v@zu)1RCF(B8hGhM%hWk#ovtU7_G%2&val>7Km#Z`}^S@m<*iOu|D@uH;no z+@Nq2(LoV{xYVsHuc%vF)C90Nd=whL4mA*m3Ww>qel$2!g?%B4AEts&7-5IIU9cy= zDg7GH{p?)>(lz1>N8Ih0fY|2~mCX8m=Q{}b5x&mt)e(i)yaI$i`g1mf+>-ujpDZYu zN9q^GpK|bfDoy{e&T$I!bb+El&BJcQksLN&sZedea)f9UBAa6w@INGeN`OF1?8t($6IW?E>KY4;v%>9f!y}&y-LOi?VcM5~i02iZ?S{Kasfcax zV^$50-Wx;^+fNb1kOx==kF)iWC}Pk#uf^#oV*4tJn7=;uRV+3amd!;FV*uJt$lOyT zZ1$Wn(2zQl8*>I|-}fpO#hTF!LiKx_bv}oAkH{4y{H z0Z`lRpN8_=egMi(y33)w%=^*Z%5{N)D7rwHk57aGhFs(LKB?mSJ5CqhFH#%j{#=0r z1$_Spe}@wOd8atcIQAu*&0s}NvHpy3Vm5t@I5MnT&-LnA_=J6Jiy#;&NEn zKKDovr5B`@%^;SNw#0(kJlU-x_A2o;YH;dX>pi$rgyM!8^jzdp;*(2RqQEDWp8P5r z-oD81en33ruVbu#h#WpCL%(7AS7`mSihdJK0 z1qkQ?sbToeJ$v5z9Pi$FZAk6)l|Naqx^qAsoxM1t>mx$-}xkWHnVA z#-Q>P`gH#-G2pzL?{stxy^4FpbKePz{WE_?`3>?#v^~@sG}?yAuwE>#B}DcoEv} ziRY5n-FgyHsP^ngd+o`3M~^QgYc^;dNRQ6{J_md_`|bMyADsWe93!*zfw?B1qP1T5 zq^|L~)#VgR3^WM1*cm?9v?@LBtTCvS_HGjd9=mZ)_5O_FBq$V)y~`Gz$Tg~ho#kksPeLsAbEiAr2nQ5EY@n+;@|s=Pnt?uDQd%^9>Lg>qqvekL+F`86QuN^+WyBGT_bt%!Ke+oz#Bl}0 z@vy;^x;i~=%(p9`i-OL>B&n`hB92iaj%JM#X1JbT5yvKb_eT$LIAQ?`-dqKfoWDxo z${-8(+7W`hUUr~Qm_v}pJYym?YK_DdX{j*1OG#JZ?{7Z->ie5nS7pnV+S~Z^zi&-G zT%cdHQ2QHLBw7l#HNDx(c5o3z zh~T_zpqE#JN?rPq^JEc!!lCicYvE=5N^!9V}!1U+yCS?RXpbRXdUH^?Kp8fo;z!^ z31i1xh%k1y`3aq87&&z;82MGS4MyJGliH!=r&p#=o&_V9t7ts8#MQRp+uQM9n&Q$1 zy0pJl(?Xb}rZnNDB{6T3IUjdGyI=2!c7@4wH9r0B5&d@miu-fvS39I(BTd!VZ8n?# zon4KTyG6%@Lr?gm>~3X%rqyf>Dv+JIy0LucKGFTtpDqqEhn@_c@NX`ES@GX%9CUr< z(7_uzg6=KP0NsM$WP^?UUrsi`w~OyStJ)tM_>wjSp{E47kg+)OB3LfO$?fjoE<&fg zJ7>B+?I*H~_kHjtHwV|0=aT@}R>p30N%Ga)+p>G*Eog-hknJ*fP+~@hvrzMI)}em? z=$fgWPym?2tmMw0ipo!x3=uEtR zw5npJ$Flg!u&WD%Qnp)O{vHSQLUH~g4 zxfb_|54GXNz{h({KKkP`c^W)RbU%cn+jXN9dfBl$+kcV1U-S@*?>Q)~7sQYj_WE&$`~2mp=5&uGQI*RpTux;)A$bD?Dp{C}O_3XWEf z9QbL@*w*3|#O1Hs+J)6#l`Fh_Ii$a*+wA@M+cnDmyLa*wC4?I0$r&K@MDM2LktB3y z10Q;_cM=x0CpX$Bd~xq2!DnjegUas{YN#~dgx=Z=0{3?H_nbYPTs>U<QWMNkLN>q5U+q59Sxv_4g%^imk@1(Ns)@1DD;3x~04=As!XlsaQrcz&7e zWRQ3xF+MhN)`!#mDL@e>_OlgvQ9Qh=%H{i`-S>#k1fPUFT*8gInLBj-i?X;`%>2{> zZ^85bZ0S#Xm(xP3(k0+H{ibsu8L08Pi86PEt8_g9TI0Lotb51Izf##`tcu!~(?W*wsUntsXC_#He8 zbvG9g^mNQ(xl!$Y(PF8ZX6lNxkOn%_>_P&{aui}gn=pxcM#3caA-q6F(EsNGrKx|T zTWY`jou}XvuiOk<#3q;P-S{>TtfU{@I}LzQ9wtJJ)dw8lvEAUM7OQW`@?a9d$?NgCRZ($ zLUHlyi|^v;e|%8f-?`w2c|X;4i56(Hp_*$?{cfnfD+~?38$h)^CW+GPU2>EZXpC<+ z58gNUqZ&+TY+aomjL*v0=4wi4AO}UiANy-Z`+{ex;0jl8iV80F3;Ig< z{MR}u*iQvxuHeBGoQi+GU(}c1E?Uz`(Tyu8I>{A%??l=h>lgHcfV|eTlTrR!1qV^E zy~rFg{pL{JiP28fIulibzskAw{XQ6wFJmFDjKctd+ucBi_d2stw-Q9X8SRSr(1I(C zU#&3y@@Kr}a%#$IPtJ)Jhg&i1J{R8ciaZH%nhJM8pS!zDba_Tiww}xC-O3raa*mhi zaC1&gL1=MgKx_Tln)gx}u=@KBH#Zk)Ns5@DB;_1_gKoKf_h^PRh0wWV>yqe z^QoH?=JDSeYTcYF9=E&4$vnR29;K`-s;@j?Rsm9&I#8oxl51HAM+$`krTayrzLtKe(hwQm+3h=iKk|J z8pqRmJ@FlRcZswYInkqe+G0<|Jb8NJJA%TJt(Mx4rxrbh>VJSx8ek^_rQU~!!)y`- z*$1z@<3G+KbHkrSjB6v&wS95){{blQ>EGo4GD*$lnh8aEDhzhX(S2awc{2_$nU@K{ z{NDTvL%uWmi1&SdFfreYH>~cKlPD9?*RWpV%X1XZ zN>iBpsY*-i$CLjtl##Jp#`6wJs?bOLxI*Jecqbfzi#vhWooLis!nW^DZPV|R_L)2 zFv~%gwpkMD_Vt-%8yAY{e}hvdJKmqM&FVip%-@0!Tspo%A4PgXf5#DDV*Ar_S`u}o;xLo zsAh@d<0YE(WxMowK^_hf% z>w7M#$R+KpAn81p)Ym1wtE4d`wO`Y{$cNdK+LED9Z_C}Beq+}60{sbgJv+)0;_#zZ zJkt;QsuR{)^VGl;>Mi&Yt(Y8uE(bk9xj0;@ccXC0Ynk+mfZbB1On`}Zpn);@aM8cA zJN&)$hTHMq-#|Fo{MX>G+Xll%S8w(VT`R{|*%_*Q4s5y&@N1qEiGxkCWc=~_K5l`AzoMdFTvoHMZRzrCp+~#uue_q{4o6a2V62bE7{7=Fv3oB6$=98!_LRs*_iU^Y|m6sT;rTXv)_M|KRElaFzUTa5Z&7Cp2Zg z7T)&~9n+M#StKelHI|Nl{FG5-^ABHbyRZ1SEnR`$)jMoqJEd!MINe`=0o`Zpkg1fe z_a7vs>mf>EelyRF@B_Q(A&kTHxA-r5x0qGQ*Sos=LB&m}h%(--Ue<6D<9rtA`Y!?A z?|;Vn?e{+v{h?D~t)JBgrPiisbIT~MEmU(O0J`S~kVbi;dDAfd1JJ)iH1e+D>q@afe4BE56p=&4Rk*la`W zJ7%Q8XE_!2J=C6$UOuZpZwI=!=IkN&%O3JYhui*r>9^dVhq^(3)YQ?S2S3E1e^%Go zpuJn(?PR!3iJ|GWu>IPtcQ^juc19oUGi1=()qVC@De0EK$xeA)c*m=@S;qjdJG}9| za6G(B+u*vL<>7r_2=Dt@_@KXsci5t{u~jj%ZeHe#bw0AE9R{*je$$Pco4SPT#g}w6 z?gJiV+`qaud))p4fqrPwKeLAJuMakGH$H7LI;4Nbw^QTGoqb#|zWCXU=2Z>IjjnE& z4T~{t{756~U_ie-lmTs@>;~jBr}wVxXh4+@Freo7oeao(?ww8sb3$iWbmRL&u&&g7 z04oV>SQwL@DZAAflLno;LdK*)t4OFDeZnw*vo+{(-o5j&WSKEZXOxHinIz{yW9&s! zV9@M~_}f2Jf4i_%w{t-BOf#t*%SSoZ+a}UE)=M-p5g&8GQ1mBgS=iCZ#om|Uu+Osl zb1%9dc;}#+%0z>!cgXA$Nf;bG+&sCXC&+@yaPqzA<)5Rw3)P$U8Nn;xuZ-_bGDM87 zp%liR(drVqB6WxJ(?c`&8|_QQb3cFF#Fv*&MSLl(1^V&awTFPs;`1FgeI4MPy;InP zfd)MKn!ke0UDsHthg?PXj-{gaT+;0>=}Oi8B1!F~9Ft!+zm(l+TbQLM3)L*)2EC9>2`vA+^SG)5sn?Kk1$S0Sc_Dk1P z^c!zxkH1Hn+8uq@r0Kg%;|Bp3ND7w{k*t zL#c$YHKp7*HzXXJPQd4*HH?}(?WnPI$3_~* z=6OFQUZUL;aJn=nxc+vv*g1_8@?&pcR$>a2f$Ml~*T;e7e9L77(WirjxZCRLj$|T(JtDRudLt zNAw={=3edS-RMegnClLN-VZ(3kq@b&_uN9^+vvS2+beR;J<$8dbCJ_N7>oe7^Bz+$FatYU59ULcP~CwP z8n=+hdj|9i1Xu&70wGnhed;UzA_BL3%Ke>$A7g?Dc**R*r@gPW40pOsruY<+04 z8#erBN)=eBTUBLq;={!@0oIf;0S-n_2svzaNuQiTQi!A`jfK_%>Dwfcv4mZA>JgcvoJ6!WOSZ8_FxzL+?^{ zkIBR9Mqf72XT;Ea65F{*zcJ5SfKkc>nu%aa%A;vo-u8w!@7&E_gtEl+4p8Ozn+()G ze`5;REMh*1T~4<3sU6@=zh4OSp}*bp1WK)3;`(Bwll^^JmuS!Og*$Kr zR4G6Nic~3B_%spY93M7ALJiup)MI~rgM-9yD_!h*T3K+ht6hjt$}1NlL@$&+7;4Om zjuVAYnnu5$P-Nl`qQrhICNo}R|9bS{A+pR=`r?)_Nl-cc=~S?3PA z;QTE|XM^*%d=Wq14hg0VmCBHvxY$1YEXEXfpvfg;KceU;@V7q0-dsx?8 zK(5fNRvyPN5W3RBLgMU>(CF|d|6YH7(j^I@;Hu1YB~_+3VSUIpLmr|*!&RESZ-|Cz zlZMG=niOI)ph>Cn@fC^=-j071|M8P5z-g*rVt1Wj)@Ct38lnwOmKMN`-EPh5jpu%M zFwlFf0_Y)e7t%-O@JFYmc3LzY%z#0^2Wm|-vX@`$eW3NZ@ue&vSzq~XTAz=yA>`mA zqfv+O@kzZ?11?#n&hbd>do^X&tHQWFsq zL@B;W;oSE+vP~ra3n)#Uo((0NQQl=6vw&pmF!6CVZ3spVKJtagUf)&Y1Z;3=Qd#Z%4MBQMz!y4e!gSiCEhZ?IrwZ!!-u6Skgvbg{9B}1Pdx1*{*g@8bp)7wzhn?3eMRp%`N63_pTnYYf2PmZ8~ zFL#Ay?@PR=p6diEAG9MU2cOR7pXrfmqz-`Xw3EsX@+r94o1;mS0U{O1fKy?Vv%@nH zQd{>)!Rk;3VY});YD&TC$RD+X)m8m~)k|aA!0NwMQ>W(*N`4Kj{_q2*KU`$SEr0&C z*B{#av(2}6)3Y5z%mkzak=au$D`WNr{QVeA<39f?7e1=QXJPH^I{aOWHfX6c_61RN zc5mg0enWLG)^)fX8(wjer&xLMm z(u1*b8Y{6C6TX&wd3lcar*a1_wkqe*1%jHfOK`K?p7U|{z8cMk!bdb-jSPL7j%^8P zCE+f+>PCM(SD5N8`{5KUVeYhWvZQYGDf%FL<$1*=$$WhuWtK8tT_&ru9w!(@iEzl=HqH9yv2_-o*lAnZ{Vk$j+V* zAv|-M8yO-$${q3d33*o^t}x-Y&l~<+6RKH!Dc9AFZtAW<&#Jo=@+M5*yn()42KjyY&7FLeL=|00$+m^CiiG zsDj$$h3YO5%{2PNHpI!-&|80!Bb;G;K&7m93X%F&- z&`}d<`v#9NCl)#9(zvt>)h|MdLr--Gn=FJ?WsqXEdp1%e-X41FcBEKjq`0oD!{SCv zTRt5gS~vP(rLx3OXHl}Rx7h4nJg14U&=Fz&mm)$L-s8EYe=y9wG8`OTGS$(6jLR)O zp@VZrJ38=%$0Gt4Yun)jba3Cz(7|vOjpx4gd#i1(Y8y;a=NK3GO1=JT_kwm)=O#kg zTuAtzRp#>^Am8@vr|e^#tR#>oykv^+BIbp`BGhl@^EO22-O!xXhvaYC@VoXej{a(? z(eDGK7wqp%KG?C`T$<04E6NNhSzbL1B};GbV*E&**R+2tW$OlW3UFZ#2vC3bO9^7r z$oU!vocOQ-Z*3#K)P`MBwz@5L_2mR53%RisyifE4KFQ9#Ge(C%aifs?<3zwf;I- z-%5RT4)Z#ovhYn%*-HE##b1`1{i}2P*wWS6V92tMeVWGKoUdYE`EDQ+)O-p1$`!aZ z2}mqTo!D2#7zKFK-ZPNR5l&@dDdcjO)JjkV$iBA^AX_ogfeeBZ$bP>k1u~eDEq38F z$Oio!kTs$7^%~9k^yN$}g74g?vf!t6l6A92@od1MU1rpNUIg!*&QH#-4z@V~xr+I$ zJOpK>UV&sm3O^9S#AO&n{vBGq!cDP;2X+zy(&I~ZLc|76IIK3!|! zw)xMwvU<5sXsk0Y;NV3s^LgAaJThE9YpQ%`8!uSby~*1sb4iAFhuLB0PltLRn{de< z?&(2j`gJa^h}jPqV`u+DEU!r%&c&vR+tCe2&uk`C&w^UHHj za(vxCI9 z3?3ioNmOIc+0u;kumjwAc7VHQv?BC~ltu7)4raOsEd-WA=3X^LS|4`yw(NbP`=vhy zxq@E+_;FX}+@urR0PC*1Qo;~a9I&T9bF-6I{M~G5dB?2ChSityFM1$7ej1YY0{XJ} zOj6xfLtA+>$6?ePHrRJp>3he2K?AYAgGi_wyY^oAw{bhSHoBI*)u{px|*uZ|}U(NovAmV&%WJmP3gI)Xz zjEHop-kVk7Z^q^%5na0$2pw%{%^g0(2?qM@bw_& zXRh1?SJi+bhu^s_^>~-sR}D-fDGPfupUlFZ_*-I1dakFrV*1I+7X`rE=fPE?-)aGE znx0sr%m+r|I!l7ij+&S>=%HbVNqx`{bLx=L!lF>J18ufi;l`gX0m!WzG=E$6jn-&> zUbcz&&&L9ccwak(<<`Jb=4D~s==vR69oZz=$}2;;WRzqP@n>JrxJbq#BypNJV|a1t ztM0ng+8T~kJ_LOA}vdqB3`sodZYuRNzUU0I)&-beT8PN|Lk*l_Hb5s`R82y0a%YwZ4p7U4t~bDPQdL0|cAr z{d%d7)=vFLGb^6z(X83aYAN$~L((=jLk9E;@=ddv7v8I8MeqrLgteu0KQX+AIvARTBSAW7Bc5*5fGxe&oK4-+tlyFfebug{(E0$KmHY4y-}YDf5Cxn zZVI-l3Do(zPAfa#o8X|bshie&CC`guF-?zH+mvMQ$DLx~%roMzSQSbIP}9PVKX10K z)%$K$KAGNbxxR7)Dv`Te0sP*j`pzi;?=R0dYP2J)L^*ZTsHUK)uSAWl?*3>|-+tf* zq7%?zOQ{D@ALlFV{$w8aX5V~=qCO2yOW}v;hYq|!$T2ha-&R~pW_d&1&M*3>Z5$ER z(PJXnFZaIo{ZHj-w+}2*E+YY}2)LwU7o3x)Z`E1@(24}?CuS!%d}g66-8q7OL9txj zA;UQ-8idN#{V zt3RCz;>IOe9Ju{n=b3iPom=1J6z9V)tg%g2&l#ZNi}F-%^E%io`rbpPKQ57Vxa?aZ z3e9|m!s4a^Y_TXBc=8R2_Vym64ZxamH0^r6s9c&R8Z`Z2%S*&RJQ4V6>5EFfBlkQ)Si`@kwFNtSafH_6S5RYYl>IapyLx}{v)agUH zGISOnRR9CRxKpnW$Mz_S>!|BAED05{Z{>w!6Yy_1|09XZ@X}taA9FEI`3Gskv92IM zn)-Nd_a+m_{xukRsq9>;i05v*(UR6F=}?lIG*YSzG%^m1M=tIJj4yNuMh8EIE%WKC zO10YDnWhToWYQO0w5RW)R+A>Lo!{t?yv!9y`=24v8T9_4XJ6s|-QkXUpue*bg1!m! z$BbOXASMHs(>@ej^1SeRfuy%O5*AU#Rz7MfZD^Kh3LSgFZy}AFt!{n4G$6wHAJ|riCBQAlx7kvlXt{!u&$UwVi*})3UuEgR_lNCNTT{3Z zvOt_K4HIF6yA({ythJot_dugcf}85(*7om9(+NC>VRs0%IRe-#BvAV5#W8Ud+#TVHZiIh`AE3YAVU-ql*Ktx=dJ?a{L0Icj@h_(AP| zO#^GHM$E*g`6_SW*^Xq(H3JAQnfv$cVC>k#g1KXyw|^3nWq)^wxbbA4_cD0{+|^y} z&Zq631l@l2jBw*egYDc%=T@o216hb{ze=5vqGjQ4lf&PIgbpwwp8vt^j7BoO!`E%@ zlp**tK?wP5y?xi}qY>k8ShuU7hWHP{Wo*Tmx-AE4096X`RiGPR zT87m8fWL*&^KmVnJY-DmZtks^+QhE~Se{HgZly(!h&1wiIM1v$JeMVh@@yfNNe}VN z8FjOEQ^YUd8g8x#7)%B0@L*KdyIC8i;|@G@@U1;wY~8~j2IzQHT1fq2c>2qz>a zh`PQKT&g0FeKp;tLjG3M`Oo{$9%l5*qxHYq`v1B0pJ)32x%I!=`v1B0pLF{Fx%HoC zdi+i#c1iJcx((Dpc|wu?Y2hqd;6y(=4DR-mXJMrAEUO>aLg2$Q_3L5}o~?d`2(WbO zSBwCArv9~z|DBpXm9e)Y@vklKi_G7X=kX){MbnkSbtFFeZYA$CenczTnQQBYVfElj zN<`2^1o1hxrxId1LAPK7g=y+$JLq*zP!4dBM#iY+en12pQKa#Q`J##BsTTj#8})>% zxysetmMSY^>kal+MMdnX%2-k?OU$CC*zpetE7~{G$n8&8!}!n0Pgdwj39*(WQP?jl z4o6r_;3X`VFzps|^xojD{F`eRcEnd}fcyHSrdXpZ5FO{;7~zJo*hi7r%ayT~ir8{p zQ1|``u!s4pZl@0>shs>F%<1NX+;Sqop&)74Kee1>u%xY5vYh;I0>zPUC}sNZDQ!zm zOqZONW@d|3as(wAK(@?dW?jd-zV??d`P$1CY_k~+ko7rm!r zyfu9p{okw^zU%~e%yT?tq-~3~K{~K#JD`{am=Ra2qHNhmu>IRZ!MfiN|;0BVrZ%Y+hm(JNBxFRz1u%=s`F~2-$Au`j+nk1T72%nrqJSvL#8%;wxS5H{rRITI3nif+LZEQI(RK8}p5`AqcRcyx!)i9$fSz5*fb!gc4s!XfBA@ql za%Id6@6x;44Cuu4fZAYB@%Jw&-r@%zW!?AXFUP%|8dAzw$zf8dNbZWDL)|2VB3e0l zjLXz{Hv=M`WT?Vn^_y5Gbn!xL1Dn`L>^X11&3o(~IVZX)xCQlUA(EU|YrkAvvdnw> zl|4EM+;D`kMAu{xz|i}UO(-Ah&-J+{l>{n?fr>-#*GR+_IiI=0BQ`&3J|W!UNGr_7 zAeS%0jA->9`KG$zZ(HYRh139T{xNr=%x+heci&+`8Y2wi5&G$ipT-Ev^+23rLefbq z{sz>IzWWVr4e^BG3KJbAJvYy5HbWEd9OHD_&Y5{he58WG+7T^9s7FiOL`S^yi-gTU zU+1zt`U}A314Lw?o=K5=%Lmn+(1QX zVf=H>s|Dzf4kNiDwxS}o*}QZ<8IQ#$d>=UY!~OvdUik?)7&vBcIPeDDu@}fEewo_N zwc{>Fig_Sv}9F9h&HkrIuK$KWQOI{LW zS!R{EEW)yN+IFJ~`-GX!#I1_FBuXyH5?~U{F)A;vOYWd2QqV5ZKQm1|Lw%qpWwvYA z(NrJL3_9ROk?KHQ%U~M=JjBKznb3Vy|Jw>N{#Y)^%4#`nWG1C{J}4Gv$r|ZFEqNd{ zs3OL5O`jzIT)N;Y{5OMf1-~ksClu$mo9EsGzuOy)J(Ql)nMCI1_b~SS{`{V-1|Y2q zq@NbtnVuz%q~f_BUJa=aALJxxv?=z}UPE^_Y&VDV_AajVBfBLc1 zKic|<&EqiFm8XGl+&=^a=I{i1AThrk*d1AvsFq|A7#*0IKtO-Y#GqYDM{)?iZv9C- z;S;Z=&!GL>k*W3(+*6eG&}PkzFypnx;V=tj-JdMy65)aec8CL`#~L9jC|R_Ji}Ewr zYVl??5kptEp*!-dT9}8`Bq+CU&8gCD3=Dvf`|zFs2$`KYy3N1qWrE?^n&kSXa^k~0 zrhN-X#7U~)m<0i6R|T`!&E_4`c=^=fvsE=wU(y(tpr23_;-0BD(% zv-1_7a(=o@?K%9hs`>n(liDuZhu+OE$r}Fr0$6S3LKl7FRFs`y>YT#x8eN7C*jl?p&({K8s0F-8>Vpyw zU82ly#5tERzed~MoB)WjTaa9|x(l;Q6LU=$q*lP`vXavcQ2Aml-X9jVIEi<l#A*MU-1=1^PH~h|yC6(^ z&s;BJc^$b|ejL=(q!Ebadp3P{Z%| z9`xAsJb^4Eu?zURz#TUC`yfn2;=}%X*C#p2@n#?SyTcLfn?1!3^5F|d!AK>SAr3mR zxdPEo>Iv6hcdZ-sevXdq+p70cfnHk!DW1v#mD5^p{mUIS)nOA-N^wEm9VVfn_>wpW zux!8Kw_79De%F)lTUs^4Br+mKq%`MvWWc4sP)?`L3Fp-2l2P7_*?JfsVV$( z9m50rfMl*?NS2VHJLfxe8^iwMf4t{Lb9Ey_Umm%NVS%!8RG@BGx7i1qf4SZ4FgQ6@ zNuh>PSJhxyC&!VM*k4#BLr)GySRqaptnT8$$-y-4=z}yW-JPpS2Xojyv&(+_-0wis z!TkEB8BGO?kWDf!AK{eg~d{`yF`Xeur;a8|t`S7_rML9GomCAupO6T0A&; zg1*ris5SJ+;N)Tc`m72E>%xd#R^eb=D(ZGo;YRXhcbdlfM!6iy-51f6>_-9@Moc3! zr-<>s+|@VQhtK_V9|Y&OWL4mMfA_r~5$`f@lStt%6dja(o5UdO!*wm(C$R{cQ0@Fj z|5mrl-90gw65r9?6EE<8vku7aBJYVVFXyfEzmrFEnHNty-R9y6*EkoQuJ=y3i>bjL z1NRiH*Ic_W4km0wY_nGP1$5n^#m8+T-F*R$bvW|&W^UBv3J1cAFG#Sygz9xD#c}ER zt6ZBhhWqqAa#9|$=dvV3+l}Z(-jQ8Ck$TtVQ`dei2Pb+}g^+!P5{5tI5~gWJ-kPI+ z-sU0$iAi|9^ch|<4ZUL~wIM(T)kD@a2c^X>2m@lUQ@>3y&7tXw)LRylpqV&n{1gpQtuI z?DYfK-`(|J?C)0glZ>T3_Rh-@dXGO&%VMxxxX}wf_z!60uOx31AgX=Pm8a)_Cj6?~ z*I+kR2!4ZZ`VZh&E%tc{ntwv6T&^6F~QWZ@xJdoo-!sN zCIt4)KV0bSn?sKUF!9`nRWQ`H;5|V>-@7YS_Is4|-Wp*A=c?e#d9FqO5ZVJj>!`&M zDs`_bHJ(z&f4xO*i_Qv)wr}&}YD)jumF}T7FY*iej`5FQ)lr*&Q>ijnYQu|^I;w4{ z1wpCy&DB%T=wo-O4f7W&{80}#OcWZ@`@eiiM@>#plTW!)-%+VY+m^aLDAm5n0u{X8 z6&(K~Q`SE535SZVB&n&L0BgP~Y4wm7y-DOP8JC40IW!_&aU0E0qCbv$nL9`K?Bv@n ztUbPbi=>*;UoSqFurhG}>&!JfK4T9T%XFVzDOVr%BYO~{SU>ml;z3<9rlZ8~nXx4Is?3*5GhSwJnfIRD*? z^X2^1OM3pYo`tSGg_4=ocb|0v)$eru&z&_ChXeY*t4rv*{;rKb)@1bjuFRL4QZIr0 z(0}%&TDfKySqpV5bc4OBTB9W>o;x8`fMf#4-%m0}O!~X^Bh+v^@7~QTq}YwxUb0j; zEK4kO#Rp^-$8h#EixI^OP2sU`xbgH-Z^_X#WLNo!1YB{{H8U_X4ADKmL;XvB&n-G>>}bGdQ^Ow7eb5A5ngjSp&(ggKL+)qnHli8KlLIA z;M)~yctkU#ae8U()k9DpaAzpspF5&eq~L@TD7Gq7*B1orI~i<~oyu_;k?@m#{Q)itXuxj)ZV7wP#tTU|VN zAMqLVHF5{X4~dgGBN!0C3N_dP1i;7r&Hr=wg-2GEh8k>LjOR9{8Vcx#`EnZo0;x_D z2U5#Ry|<6*5UEiI;{LM-`$)yJ?l>X!D08_h5k3(`aI$m$1^(^L?1J7*lSS*N8q{;619KL5;@pj9gV z%+Ad={^rr>ET*v*6k}?}yQHsLh=^emc57ExU4OZYh-i}hN*3lTj?AvE#EI4G)L4EJ z_cb;u?lZ5F%JZTW<})gy(BiYvDb%25=(#;Se_gF`q%B=DTV_U@FO@+sIQ6g4)(>0X zM#VFSnqD~)2b;#gjZgc=^!O|cmTxFlXd+Yb-sH6Y2xxAAb$!wU6hrJD9f(9vRzGA= zj;_!vXL(>8gbi|E3SbjoY9!Vwpf-~}N)xZGf~cC7q0o zFi#zh?atnxx3YKP8#&-}pwadF0%73Qy3HPH2zsLef*S*Y^O==nXVeE zMQK%PV6sz^c$3~lG5F`JBvA)Kj5Te$6-|(8@1CW6RdeC_Z?>ZC)fB4I4ZDfFWLxvm?^U>4MxMa^P zO&r~Ja7>~9e0;xu!^XGU!UyhseD^z){SU`?_QL;oeCyKqgWaY(8w8kep2k8>5w4Ug zs>!b9J|~DOvH}<6ZnG7m(UegGk|UH5C926219UOUPN#z!kldH&T=ZKP4@ma&H;131A)GC(wy?XrQ$;-_p{4UCT43rR&oo?Lz z)_m}_9gX{zvl(~6!FwHd|AxJddter4NUyJ<1*^XleSC%SkFxP|CB?j#w{e-r(ap1Z z2pa2?{kDfLSZO~58~A)y+Yx+bRRN!Ec%d|za3faC zA|A+5ZdusQ^%Yt~I-Wb9bTD@WAvb@X|5EVz%KT;Am*g+pq&^^Y{xZOJ1in3TAMm=T z!4=Q_d_RrcdnODy32vC)00jTB!_X?=B*X|8a$+m!U@cI0I0X}=@FBg3Qe;F(O z((uB(UR;$TIIT+-;#^$!R+owmUPaIKO05VT(Y!r0d2J|vxdWof*GoT1(Oo=u(h30i z=TF;kqHfbV0%Z3|zW!-0zCxW-9p|6s?**D)d_LL1_v8q#-QKV_J$m)F~xJr^Q4+B5Fc?V5q#>` zM!zQ!jDQsJK}zPbYi_C@_goVW6tz2GfzX)p^Me*Oj^I>nE$;z!cza7=YOL(xLurt7|^q|GgCzs3Px z#jiaS&<)`Kl)O;>icmhW%*6xjyEiuj4w9PVxv?jK!#mp@9DE&f?VnO`fLH<@^Jx=- z!(&7D3Wudv?*$If@9qE+Zar!L*TF~XnlFZrsF>Kz62;i$NE9Q6ofE~}9j=kk6WwG6 zL>%i82|d{@IY_y&FGeozW^%?p(H~Ky;^IveBRAFbTZ*nw8omoBCvuW_%-LStu)(|; zvCP45)J=qh66MFd3`G|1z*L!SWJv$nP2z2BbH z5wtf{0PVM2_oJ|Y{iE@JPDLm#y_d#vfEm_Jl7R;YB zlRO~HqSA+JNxXNO`Obt?Ld>_jxQVY=~U=$F{%n%CL|+S%7=x3A5vxjFks zXUEv$Fy>KBoXXI64%KL{uQ+n3$2cQoW9*KjA!B4!!Y&x&9L`#An~f2JC&Z)eELHQ} zhFR*J=Z0Cfw~c@PUWa*Xhr`tPX8pJ$+@(nvuH+qmkd{z_rK(F%bA3FZ<_u;LEQl{> zp$e|?!iQgss7Y7u4N+AcjNtz({9MAGz8!uF_J*Hdd}O2BD}JWW+1uzk#*h4;TAcsW zloXR&RV!P#xd-5!bSrcwvY#W$oGx!5c{s^MNd7QdR8Yp8g`i{}&kL7XqMQ)PUS)!a zPrkl$thr_3@lM44^EBI3DRRdgZ~AqNQG$!s3qDwr9Dr3d9CJNM)^KaG(LaCV4v5Ov z(%fD#9H{X8H>=?(;kvcNIsTv)f>ygUf#*f6d1)`Y=N&d4Ck4946p);!7Tkxve0cN- zjQ~zCO;bg#)PGnaSL%aE&Tysfv)}{mFL&2sZ2!hbyQxpc_Uo%KwyzoB5HX$aix$wA z*z#nZ+M@>@?3|X&+8f@!wO0ly{CN(4_XPNx|A9kY5ZA`{uE;uX@o@1njWp%DW{|(p zr3sfE;SW#9;JhLzJl;oPeQ~X7@;`ZZHnc@#;Ao%5| zw&D%31r3lu+GQ$9j7xf>2EWA%G$mMUbk1w=)i{2$rig@9($v zK6A??pl`qLd;a+TNY0sa&fa^iwbx#2?X}ll8=PYg_!e(;zwcH3o~e0CH@jdR$)Wk6 zES?V-f6)EfCRm{bUNmNfe_^A0@k(ymiDQNIDnwlzng>Sk|HEN~z=*Y2Ku7+^Om?m! zko`cFFhh7YBu&%&@Ep&h08gf#Nw-bl2PL04DzuDE&>x~YM2W~;oeLMC`0WXJig*(j z6Vz|wc*~DmOR%!-HxCmJ=s!^q;&bKWEhiMQv-tgj{mOsLMIMyJr;y7COZ-|-Ekql~ zL^fQ^0m%&7nH6mpusL99BmdQ?lg#_gZ=&?g>50JUPNRd z6HvCG0pqtfhX`>*MIfIrUhtT(uIg3rEVlmOAU67)Ai2;3Z36>e`ERwq9t*vsD`s!Q zT=o`OY{Ktodb@EhSkAgqXCPFfatbxQFn~s}m}XyhK+(P;Zpb)a63@7OK91X!$(&`I z5UMH!^-G%5?tP{;NBt!UTo<#@6#uo3(LbNW0`pW{I~*##As_iq2N2;#S9p5Xe@6JK!bv%|NUP~GjZY^yra?&Uxo zp4l{n0^e8-pIZb)Xl$;1XK&|xi6?%o@}nX;#*0m$Ey~U{11Hm`oohD0&9Ixt(AFKl zCa^EvOy_P3H`NsX+t)%=Xh0sjN0Tq|tJuKPcV;N9x$U{)UyZIG%HH7X6cOvbt5NYw z$IqOJ9As%`-ChL0a#h971-fcKSu9oHJ!eA2y*L9Z?q{Dn1Y7!J5Nr?ESFMaCxJUe< ze-i?>>hVZ{4*KqyqJa-jO+`gxc~O_<5WxGhPVxTi=H5&H{7Cl?)^FvYu+GsFy}KHzcxlaDfa?3;NcX91aT@-)r?S~; z_~)L=wx{8rdukEyiWpXlV#K{FC!0}MuoQD~75~7Vsoe6oSROF$cJcTOeBs$_Ja8Rv z>h`q?^>Bs8xLQHDPY(H9?IE6!kOdYGt3v)=tg6_LF2Nu`?F5gt@4_|u4V2Sly9}T4 ziA{P1sTDNe;oc9 z_8KAf1N_&$FZoZu!UhEODJ)3U7Mv~(@%$2NC>d{0;nCT z2Wp@_5_l+_d?D4gms?+94mx#4Y2~%%H<)!_wDJWz4+sq0_IpsI#;9UQGu#OSTz*jF zA62p&%OAWJKQ{ya@Ibs~7pYm~vgoXGE6_kk_ra3=d~_Pzku$sd&<)wDn+KqqXQP`} z%Y#TsG#DG_H+$K;_80A?Vpm>X_r^aIUyf~LYyZppAgtvh**zt@K&tsa-rJ5%Zd&%XqCkRnEs$23H`4-1aD#^q(&M+Lec zxnguj_&s%obr_%ft-I2PhdOWedG;BB-xHr`M=!~##qYt3Cg ziU&Z(b?eD3I;uUm!5jQL$b`nD<49B9Z_UYR@PbK31Up|782J2BFo{uRfC+|$ZobB4 zzlFsw90GydwV2(g&T^^^hapGNFC~2@79U-cR$0s#e@P?&)@N`%wm(gIhO*k32R^A2 z5LD$H1acHC$9T0eh7N&dD&7Oj4c{`z-jPS(_er*iC8fZ?OoCQJO|V2hi6F{A-QlEV zJ4fKuCp}}uL^o;mTlFTw@;wL3ui>+LP^=0KBaxPf z2{qx_h=xeeNQpmu@DDtul+$f+*NY-ta9}Tc8sw5q1(2-=@f)ntAAhr`GG=A-9~H$c zD5+8eZhY6-sA856V|hjAnxZ2c(#!m2VEtFH=D%~zyb2jn5C8fw_B9hPhN%3^Ul0-zt!2}-S(v) z`(zf*7qTFj$_FN_L@{sO{#M1I9)0W&up(l2v1o-Z))lW7DjHn>vY*(9H`TRsup?DX zXSuPhB8*coAk~$06)6RA5FUkxBAoW20Uf^`px*St3_xQA_7pbu++x+3bd_hbY!5>2 z8POxe%s%7o!#Ep*P|E)NhjDeVBUe}0&vNx0mJnt554407OMgF0h?0UMbT2NP11@$3 zMoQ}~#${{mN3aTQ*WjPny=tg(qBhCib6fm)H9_1-;k&R6Ru5A(e|{VdI&%mZg_tL_ zDw_}UyeRERU3%F_ZLxm^E$Ny$02_%vU&6t*$+S!}aykANAzs$P8L1cIe+gFbEVC4G zjCfLmWhK7A?qj^bSi|Y5I5Cy8rY<3DpoV`6>o@k1U!uok-odm#$#=>o?x+!Qg-x)5 zBV`o))iL;KV+;H^9hCgF=McMcctgSVNC#ax&FlukFsHY%ysxXM^1DmRGnl04EZmOA zZNsL>N4Wh-`7X0zO=JgcK^z)At%sSnIbqsl_S$5oZ&il7-LcY{b=Y^^s%Y-Q`qKC~ zU>%_2t};IuqiLV34f2jMKcL5i)1j`wVC8whFm49sf{Y#wr3C=ricNfGFcJg6T+hHX3iegf`kxMwR&N)GhPEi8U zdRIp)OK}q?|D%hTTK=Dcy&il~rw|=>7M#d3 za!aXXE9?t!ItG<&sfeTSt4%m(KyT7l=NG>S(nIT43Lom%QamDhl#zfhr2@k9Swv$N z=!|_uffJxJH;mZ(v|^$X_yLLuM41sK&kRi-C@Tfa_fuBvEY`&eRkzI`sfi{A$T6(E zt;`cBxsMOrYW18r_JEo{&YlQzU$N66_v9-G)3Nqm`wS?o$0p%k4vL?+|h^2gGI2vv9c+$5FU7}4cq@cR@0NJ$6XU1 z@B{3ZPUUTlSBnr6BKFHo1SvZaB=3BOzI!GBu1B{z^nI%U^gSaA6Z~fmJl~^#JCz$~ zzfW)F*%2V#wE;x0L?Hh780a#d?VlBG-^cdv|Hh#S{PQ=SlD~|Fe@Dgf{Tto>iuvjB zPDXVV-p8CxH502hqJJBtf3Jqt?R;bnxZpJtUqv!rqpQbwwKPBdYva|8X8Ib_vt?$n znfEorQ|PY$yd_=sX0I)#)xMAEIhn{APyDqpXUr@IXH4V2w{djd%5%^_+-UFS2N}lP z0x}ryINdNLpX@>VayHgi;`t+VLn42iMttCm8{=t1ij;RGH6|XdORF>WgB_G;>x3j5ce12Sk2O*PYEz?0Rpatan3 zx&t`YC3CJ4yL~Hsg-KQg<{NNBbh+xWPvNfFT7H&Fi5uXtANCpCn`;&O z`}^T8YCv!Am{;Npwc4uYw_cB#UvAd`u8x2Ujc!f@yx;_@-@ad?YMhsO{}3iEj7#{{qOJG} zh)*E=cn+J3u7!NsUT)l!;-7LY@H8Ozv|K*RWeIT#A<+iCC&j^oGQXR57~=~F(~mHr zI9QZhyrGEt24tF(QxUq+jpQ9?-o5?d^tANAp&zL!aCPmxe-z_bsldRV=ITU&{vTRl4lPLe*C`4J#lw?+icNWs2)vx~1Pt)wcOrgkX+>`$8;;A7-Z_&P< z@iVg*k|gYfuiK#)CgZ2(tEWb5z6!sZI`nr+qH~_V%e@Kf5vP;oFs7O0X~DXixa^ z6y4+D18CU*ZQ<*13RKrB*~2wYj1L9GWCC&jKT{C!p;3(p7+LTZPN&OCLp@Ec0djo~ zJM8rO+#h2uP)>vBS9HtuNjZDWegMu^K72{o!wF%)c-lUs0E+`~-ouMw1~z0#o)knk zVE_CU6g4 z52L)4o@rLa%v*5t5j|r$0n$E3ujjDwKpmbAvs#^FVn>H(gR$^l2yMbpiRUEBQe3@O z`zrJHHux+L?kVc0lafkru|BVDwW8zDzbdC9qF!_m8eHoHK=QEB&(6vyZMD-e+yi~& z4bItmjObO!xfg<~gJue(yunS#W+sGT-bIC$59eW944E?mf0mw=&8BLJg{vnuXct{E zl-;rw_dsZwMu<2*hetK`g&LC zvrF#g2vUzlj!$>hgzv{|0xY;{A_`5(AVW3BIlZ9JpkJ7{I(h!XU&5cs>9UNay#0u& z_U7%y$wthG-M3&JMw1Wy=FR5QJs&h*;` zPgJJgx`kn!FWw&#Qbk=eYbI8iA$je47-EEAFUbd)&(sAWWO)UbON3k|eVDC~1kuIE zl1!bUC?;3d2P4M0^h?xdm-JPOXZJWuWoup`0v}ijPeKw)!vESiQr*}YyfaKBvF;Oxhkk&36-Uu(+H`%As zuY%Qr1BGB9x+-$*;j9S#16|uWhsTS!?7}`EF8WO#nU-EffpB-Nhh2f55bI(vwnX9% zoy)8pgHc9R_!=u*u#PRH$fVz>{msJ~wZEd^`?udJ+J66L+gJVjR;+)s5Lw0CZdGI{ z1ZjANyNv4J;}%I(vP{otWNVR-LUOb+M{rtM2>Xlw=P>h+%vKC8$w12(FZolL9K*8g z&gwPN4wL^wgR&{-^O=8UXm&Zo%m_Rjmup+czhN!?$e4IC3Kh`e@r=$d?}eX*xGUs# z@KHs$E25P1ngG$nZaS`Oh>JW+jW@+2_IPhRV}#o$O{c|v8KQX`pt?*?J0=Jc8bH4h zf1I5a!j>-2aCbQ}0M#PX;My#E?K;E_>m?I)WykAAKgU58w8tR`z^0MM;|5gHt+d}u zx9_6kAF>7Ki}}Ssb3rbSyD4fBKj>5&sduVrqWqAXqvgBB%8zWK{N=j+Y<4J2%UaAz zLO4|oQDJ&Z#typ^g6h@yv+Kt?5XDBJeHf=TK&68XKd&u3iGsDA8<1hJW*cdOIH zVf&?9qD|bHs)?G$P1Hnw>rf)~Rku8eNZp7Ddk!W{m`G(JLdwl~R3<~D+;XZaL!{KH zs#EcWI#rb+QtDJyS+S5)Rk30bn3Dsm6L|;KeDc*BL6Fq#OaEM~p~xZ>*rfo}$AY@t zCb-q^My(LwIU)AFtVh_$etM`TXXJ0GE7nh?{y|atqW;TN#S(DKW{_5=tRp)LBOCeW zL{ThBXKQ=vGepQa`RTzm7{L_KeY&UXoD%?2# zoQ)05lCTzgd$2iA8Y-kAr8*LD9(akv2H(~XqY4-3?jD=gVYzo*~hGO z3zq+BP6R)OU13lBr_eMX^BcQcw1F76GJG~$*{=hfMrEi9--_ahR0|A0u>G%M?LU6K zL*A6_uNvHF+{Cvpm;+(Z*K{*h-*~7NeKv%Z5=C`X+&YM4%VZS`Z>*QVb#&fylzC%23i9=5m(85(JMc zwW8JG@Xi!w*kD8Nk6iWfN%&VsJ0!9<4|15iiugGFha~K#8#|X^C7272(+u zPqJt#%+)ied|dw@C;k~p_%~Hc0)LBqx>OC`IQbz7| zx37vF+@5nFmin8OfBl&tTg$&#RZmB&It}^PZ2jXdi`H+%>L2_ctAEz-qV>NxDoTn^ ziyTs%8h&FTHw0@Qls=fxKHzAE7G`f6|Ymh zavZ}X&DdQDp6$C#@vPpjzV)u?HU`K~XTSP`?J;*~`ym+ivyvz#-5gB9P3@1I;pm_5 zAwTYTT&R`{*>qpDt(btcpT6ew+!h$kG5nFcIrPJ{p#3!W!io2`N=l<5>Fl@Hrx`O+Bmd0t{;_Du;b zME>FoO}QqFe~lj+IfZ^5TA)#betm636Syh;x`*e-Mor=WkbeCfn^_?JFrpI_Ao>Bu7qba#H7ZvS?^GTOi1#1`%Q5*ka@ zzs<_W6LX|y+Mi$f99--ir_$3HAI8E3N%HHSB>ANhIH|-XDuGi6h%3ofk|3%sodZ!7 zd{K!i37@q(+)jDKb~1q^q;ZtzZ2aRK0OSYwmwTkdOWRFo$^dKAbEqBR>q>Q~8!S2890$;^mu~8b;?w;_kG&9Ef($ zuxJa^fA(yrmB=z@OvPWNepAayfZ

RDrSMe?DRC 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 z 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%0D{% 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

Ohj95a#Tc4N5tiLyB9hnPS%vRas?oL zY!@r^=3Neh+z}Ufi9H1Z>ns4~{`3)O*qT#fM|2+Mu+GgG*5sucmbNW><7`;> z4x6J9F|wWdj_1waDe|fyzOz%KOBt~Y@X_C=2B?P_;2*v#4P=SEn>oN&in|+N089he zpN|G$SZ09n3E$v�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.OU{+e$6R3|@R%JnC5p_gA%MCWZU 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

  • )^Xup}-f5(obd~q?x;BEFh{xW#({nevt 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 z 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

    ePh152~ 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�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�K%MY8iO18Oaiu3`+! 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�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