| // Copyright Istio Authors |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| package echo |
| |
| import ( |
| "errors" |
| "sort" |
| ) |
| |
| import ( |
| "github.com/hashicorp/go-multierror" |
| ) |
| |
| import ( |
| "github.com/apache/dubbo-go-pixiu/pkg/test" |
| "github.com/apache/dubbo-go-pixiu/pkg/test/framework/components/cluster" |
| ) |
| |
| var _ Target = Instances{} |
| |
| // Instances contains the instances created by the builder with methods for filtering |
| type Instances []Instance |
| |
| func (i Instances) NamespacedName() NamespacedName { |
| return i.Config().NamespacedName() |
| } |
| |
| func (i Instances) PortForName(name string) Port { |
| return i.Config().Ports.MustForName(name) |
| } |
| |
| func (i Instances) Config() Config { |
| return i.mustGetFirst().Config() |
| } |
| |
| func (i Instances) Instances() Instances { |
| return i |
| } |
| |
| func (i Instances) mustGetFirst() Instance { |
| if i.Len() == 0 { |
| panic("instances are empty") |
| } |
| return i[0] |
| } |
| |
| // Callers is a convenience method to convert Instances into Callers. |
| func (i Instances) Callers() Callers { |
| var out Callers |
| for _, instance := range i { |
| out = append(out, instance) |
| } |
| return out |
| } |
| |
| // Clusters returns a list of cluster names that the instances are deployed in |
| func (i Instances) Clusters() cluster.Clusters { |
| clusters := map[string]cluster.Cluster{} |
| for _, instance := range i { |
| clusters[instance.Config().Cluster.Name()] = instance.Config().Cluster |
| } |
| out := make(cluster.Clusters, 0, len(clusters)) |
| for _, c := range clusters { |
| out = append(out, c) |
| } |
| return out |
| } |
| |
| func (i Instances) Workloads() (Workloads, error) { |
| var out Workloads |
| for _, inst := range i { |
| ws, err := inst.Workloads() |
| if err != nil { |
| return nil, err |
| } |
| out = append(out, ws...) |
| } |
| |
| if len(out) == 0 { |
| return nil, errors.New("got 0 workloads") |
| } |
| |
| return out, nil |
| } |
| |
| func (i Instances) WorkloadsOrFail(t test.Failer) Workloads { |
| t.Helper() |
| out, err := i.Workloads() |
| if err != nil { |
| t.Fatal(err) |
| } |
| return out |
| } |
| |
| func (i Instances) MustWorkloads() Workloads { |
| out, err := i.Workloads() |
| if err != nil { |
| panic(err) |
| } |
| return out |
| } |
| |
| // IsDeployment returns true if there is only one deployment contained in the Instances |
| func (i Instances) IsDeployment() bool { |
| return len(i.Services()) == 1 |
| } |
| |
| func (i Instances) ContainsTarget(t Target) bool { |
| return i.Contains(t.Instances()...) |
| } |
| |
| func (i Instances) Contains(instances ...Instance) bool { |
| for _, thatI := range instances { |
| found := false |
| for _, thisI := range i { |
| if thisI == thatI { |
| found = true |
| break |
| } |
| } |
| if !found { |
| return false |
| } |
| } |
| return true |
| } |
| |
| // Services groups the Instances by FQDN. Each returned element is an Instances |
| // containing only instances of a single service. |
| func (i Instances) Services() Services { |
| grouped := map[string]Instances{} |
| for _, instance := range i { |
| k := instance.Config().ClusterLocalFQDN() |
| grouped[k] = append(grouped[k], instance) |
| } |
| var out Services |
| for _, deployment := range grouped { |
| out = append(out, deployment) |
| } |
| sort.Stable(out) |
| return out |
| } |
| |
| // Copy this Instances array. |
| func (i Instances) Copy() Instances { |
| return append(Instances{}, i...) |
| } |
| |
| // Append returns a new Instances array with the given values appended. |
| func (i Instances) Append(instances Instances) Instances { |
| return append(i.Copy(), instances...) |
| } |
| |
| // Restart each Instance |
| func (i Instances) Restart() error { |
| g := multierror.Group{} |
| for _, app := range i { |
| app := app |
| g.Go(app.Restart) |
| } |
| return g.Wait().ErrorOrNil() |
| } |
| |
| func (i Instances) Len() int { |
| return len(i) |
| } |
| |
| func (i Instances) NamespacedNames() NamespacedNames { |
| out := make(NamespacedNames, 0, i.Len()) |
| for _, ii := range i { |
| out = append(out, ii.NamespacedName()) |
| } |
| |
| sort.Stable(out) |
| return out |
| } |